path: root/Software/Visual_Studio/Tango.Integration/Operators/MachineOperator.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.PMR;
using Tango.PMR.Diagnostics;
using Tango.Transport;
using Tango.Transport.Transporters;
using System.Reactive.Linq;
using System.Reactive.Concurrency;
using System.Reactive.Threading;
using Tango.PMR.Common;
using Tango.PMR.Printing;
using Tango.Integration.Observables;
using System.Reactive.Subjects;
using Tango.Integration.Printing;
using Tango.PMR.Debugging;
using Tango.Logging;
using Tango.Settings;
using System.IO;

namespace Tango.Integration.Operators
{
    /// <summary>
    /// Represents the Tango machine operator default implementation.
    /// </summary>
    /// <seealso cref="Tango.Transport.Transporters.BasicTransporter" />
    /// <seealso cref="Tango.Integration.Operators.IMachineOperator" />
    public class MachineOperator : BasicTransporter, IMachineOperator
    {
        private bool _diagnosticsSent;
        private bool _debugSent;
        private LogManager _embeddedLogger;

        public MachineOperator() : base()
        {
            EnableEmbeddedDebugging = true;
            LogEmbeddedDebuggingToFile = true;
        }

        #region Events

        /// <summary>
        /// Occurs when there is new diagnostics data available.
        /// </summary>
        public event EventHandler<PushDiagnosticsResponse> DiagnosticsDataAvailable;
        public event EventHandler<DebugLogResponse> DebugLogAvailable;

        #endregion

        #region Properties

        private bool _enableDiagnostics;
        /// <summary>
        /// Gets or sets a value indicating whether direct the embedded device to send diagnostics messages.
        /// </summary>
        public bool EnableDiagnostics
        {
            get { return _enableDiagnostics; }
            set
            {
                if (_enableDiagnostics != value)
                {
                    _enableDiagnostics = value;
                    RaisePropertyChangedAuto();
                    OnEnableDiagnosticsChanged(value);
                }
            }
        }

        private bool _enableEmbeddedDebugging;
        /// <summary>
        /// Gets or sets a value indicating whether to allow incoming debugging messages.
        /// </summary>
        /// <exception cref="System.NotImplementedException">
        /// </exception>
        public bool EnableEmbeddedDebugging
        {
            get
            {
                return _enableEmbeddedDebugging;
            }
            set
            {
                if (_enableEmbeddedDebugging != value)
                {
                    _enableEmbeddedDebugging = value;
                    RaisePropertyChangedAuto();
                    OnEnableEmbeddedDebuggingChanged(value);
                }
            }
        }

        private bool _logEmbeddedDebuggingToFile;
        /// <summary>
        /// Gets or sets a value indicating whether to automatically save incoming log data from the embedded device.
        /// </summary>
        public bool LogEmbeddedDebuggingToFile
        {
            get { return _logEmbeddedDebuggingToFile; }
            set
            {
                _logEmbeddedDebuggingToFile = value; RaisePropertyChangedAuto();

                if (_logEmbeddedDebuggingToFile && _embeddedLogger == null)
                {
                    _embeddedLogger = new LogManager();

                    String folder = SettingsManager.DefaultFolder + "\\embedded logs";
                    Directory.CreateDirectory(folder);
                    FileLogger fileLogger = new FileLogger(Path.Combine(folder, String.Format("{1}-{0:yyyy-MM-dd_hh-mm-ss}.log", DateTime.Now, "embedded"))) { Enabled = true };
                    _embeddedLogger.RegisterLogger(fileLogger);
                }
            }
        }

        #endregion

        #region Virtual Methods

        /// <summary>
        /// Called when the enable diagnostics property has been changed
        /// </summary>
        /// <param name="value">if set to <c>true</c> [value].</param>
        protected virtual void OnEnableDiagnosticsChanged(bool value)
        {
            if (value && State == TransportComponentState.Connected && !_diagnosticsSent)
            {
                SendContinuousRequest<PushDiagnosticsRequest, PushDiagnosticsResponse>(new TangoMessage<PushDiagnosticsRequest>(new PushDiagnosticsRequest()
                {
                    PushMotors = true,
                    PushSensors = true,

                }, MessageType.PushDiagnosticsRequest)).ObserveOn(new NewThreadScheduler()).Subscribe(
                    (response) =>
                    {
                        _diagnosticsSent = true;
                        OnDiagnosticsDataAvailable(response);
                    },
                    (ex) =>
                    {
                        _diagnosticsSent = false;
                        //Do I need separate event for each one ??
                    },
                    () =>
                    {
                        _diagnosticsSent = false;
                        //What to do now ??
                    });
            }
            else
            {
                _diagnosticsSent = false;
            }
        }

        /// <summary>
        /// Called when the enable embedded debugging has been changed
        /// </summary>
        /// <param name="value">if set to <c>true</c> [value].</param>
        protected void OnEnableEmbeddedDebuggingChanged(bool value)
        {
            if (value && State == TransportComponentState.Connected && !_debugSent)
            {
                SendContinuousRequest<DebugLogRequest, DebugLogResponse>(new DebugLogRequest()).ObserveOn(new NewThreadScheduler())
                    .Subscribe
                    (
                    (response) =>
                    {
                        _debugSent = true;
                        OnDebugLogAvailable(response);
                    },
                    (ex) =>
                    {
                        _debugSent = false;
                        //Do I need separate event for each one ??
                    },
                    () =>
                    {
                        _debugSent = false;
                        //What to do now ??
                    });
            }
            else
            {
                _debugSent = false;
            }
        }

        /// <summary>
        /// Invokes the <see cref="DiagnosticsDataAvailable"/> event.
        /// </summary>
        /// <param name="data">The sensors data.</param>
        protected virtual void OnDiagnosticsDataAvailable(PushDiagnosticsResponse data)
        {
            DiagnosticsDataAvailable?.Invoke(this, data);
        }

        /// <summary>
        /// Invokes the <see cref="DebugLogAvailable"/> event.
        /// </summary>
        /// <param name="data">The sensors data.</param>
        protected virtual void OnDebugLogAvailable(DebugLogResponse data)
        {
            if (LogEmbeddedDebuggingToFile && _embeddedLogger != null)
            {
                _embeddedLogger.Log(new EmbeddedLogItem(data));
            }

            DebugLogAvailable?.Invoke(this, data);
        }

        #endregion

        #region Protected Methods

        /// <summary>
        /// Called when the component state has changed.
        /// </summary>
        /// <param name="state">The state.</param>
        protected override void OnStateChanged(TransportComponentState state)
        {
            base.OnStateChanged(state);

            if (state != TransportComponentState.Connected)
            {
                _diagnosticsSent = false;
                _debugSent = false;
            }

            OnEnableDiagnosticsChanged(EnableDiagnostics);
            OnEnableEmbeddedDebuggingChanged(EnableEmbeddedDebugging);
        }

        #endregion

        #region Public Methods

        /// <summary>
        /// Prints the specified job using the specified job parameters.
        /// </summary>
        /// <param name="job">The job.</param>
        /// <param name="processParameters">Process parameters table</param>
        /// <returns></returns>
        public JobHandler Print(Job job, ProcessParametersTable processParameters)
        {
            JobRequest request = new JobRequest();

            JobTicket ticket = new JobTicket();
            ticket.EnableInterSegment = job.EnableInterSegment;
            ticket.InterSegmentLength = job.InterSegmentLength;
            ticket.Length = job.Length;
            ticket.WindingMethod = (JobWindingMethod)job.WindingMethod.Code;
            ticket.Spool = new JobSpool();

            job.SpoolType.MapPrimitivesTo(ticket.Spool);
            ticket.Spool.JobSpoolType = (JobSpoolType)job.SpoolType.Code;

            ProcessParameters process = new ProcessParameters();
            processParameters.MapPrimitivesTo(process);
            ticket.ProcessParameters = process;

            foreach (var segment in job.Segments)
            {
                JobSegment jobSegment = new JobSegment();
                jobSegment.Length = segment.Length;
                jobSegment.Name = segment.Name;

                foreach (var stop in segment.BrushStops)
                {
                    JobBrushStop jobStop = new JobBrushStop();
                    jobStop.Index = stop.Index;
                    jobStop.OffsetPercent = stop.OffsetPercent;
                    jobStop.OffsetMeters = stop.OffsetMeters;

                    if (stop.LiquidVolumes == null)
                    {
                        stop.SetLiquidVolumes(job.Machine.Configuration, job.Rml, processParameters);
                    }

                    foreach (var liquidVolume in stop.LiquidVolumes)
                    {
                        JobDispenser dispenser = new JobDispenser();
                        dispenser.Index = liquidVolume.IdsPack.PackIndex;
                        dispenser.Volume = liquidVolume.Volume;
                        dispenser.DispenserLiquidType = (DispenserLiquidType)liquidVolume.IdsPack.LiquidType.Code;
                        dispenser.DispenserStepDivision = (DispenserStepDivision)liquidVolume.DispenserStepDivision;

                        dispenser.NanoliterPerPulse = liquidVolume.IdsPack.DispenserType.NlPerPulse;

                        dispenser.LiquidMaxNanoliterPerCentimeter = liquidVolume.LiquidMaxNanoliterPerCentimeter;
                        dispenser.NanoliterPerCentimeter = liquidVolume.NanoliterPerCentimeter;
                        dispenser.NanolitterPerSecond = liquidVolume.NanoliterPerSecond;
                        dispenser.PulsePerSecond = liquidVolume.PulsePerSecond;

                        jobStop.Dispensers.Add(dispenser);
                    }

                    jobSegment.BrushStops.Add(jobStop);
                }

                ticket.Segments.Add(jobSegment);
            }

            request.JobTicket = ticket;

            JobHandler handler = null;

            handler = new JobHandler(async () =>
            {
                try
                {
                    var result = await SendRequest<AbortJobRequest, AbortJobResponse>(new AbortJobRequest());
                    handler.RaiseCanceled();
                }
                catch (Exception)
                {
                    //TODO: What to do in case job failed to cancel ??
                }
            });

            SendContinuousRequest<JobRequest, JobResponse>(request).Subscribe((response) =>
            {
                handler.RaiseStatusReceived(response.Message.Status);
            }, (ex) =>
             {
                 if (!handler.IsCanceled)
                 {
                     handler.RaiseFailed(ex);
                 }
             }, () =>
             {
                 handler.RaiseCompleted();
             });

            return handler;
        }

        /// <summary>
        /// Uploads the specified process parameters to the embedded device.
        /// </summary>
        /// <param name="processParameters">The process parameters.</param>
        /// <returns></returns>
        public async Task<UploadProcessParametersResponse> UploadProcessParameters(ProcessParametersTable processParameters)
        {
            UploadProcessParametersRequest request = new UploadProcessParametersRequest();
            request.ProcessParameters = new ProcessParameters();
            processParameters.MapPrimitivesTo(request.ProcessParameters);
            var result = await SendRequest<UploadProcessParametersRequest, UploadProcessParametersResponse>(request);
            return result;
        }

        /// <summary>
        /// Starts jogging the specified motor.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        public async Task<MotorJoggingResponse> StartMotorJogging(MotorJoggingRequest request)
        {
            return await SendRequest<MotorJoggingRequest, MotorJoggingResponse>(request);
        }

        /// <summary>
        /// Stops jogging the specified motor.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        public async Task<MotorAbortJoggingResponse> StopMotorJogging(MotorAbortJoggingRequest request)
        {
            return await SendRequest<MotorAbortJoggingRequest, MotorAbortJoggingResponse>(request);
        }

        /// <summary>
        /// Starts homing the specified motor.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        public IObservable<MotorHomingResponse> StartMotorHoming(MotorHomingRequest request)
        {
            return SendContinuousRequest<MotorHomingRequest, MotorHomingResponse>(request).Select(x => x.Message);
        }

        /// <summary>
        /// Stops homing the specified motor.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        public async Task<MotorAbortHomingResponse> StopMotorHoming(MotorAbortHomingRequest request)
        {
            return await SendRequest<MotorAbortHomingRequest, MotorAbortHomingResponse>(request);
        }

        /// <summary>
        /// Starts jogging the specified dispenser.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        public async Task<DispenserJoggingResponse> StartDispenserJogging(DispenserJoggingRequest request)
        {
            return await SendRequest<DispenserJoggingRequest, DispenserJoggingResponse>(request);
        }

        /// <summary>
        /// Stops jogging the specified dispenser.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        public async Task<DispenserAbortJoggingResponse> StopDispenserJogging(DispenserAbortJoggingRequest request)
        {
            return await SendRequest<DispenserAbortJoggingRequest, DispenserAbortJoggingResponse>(request);
        }

        /// <summary>
        /// Starts homing the specified dispenser.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        public IObservable<DispenserHomingResponse> StartDispenserHoming(DispenserHomingRequest request)
        {
            return SendContinuousRequest<DispenserHomingRequest, DispenserHomingResponse>(request).Select(x => x.Message);
        }

        /// <summary>
        /// Stops homing the specified dispenser.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        public async Task<DispenserAbortHomingResponse> StopDispenserHoming(DispenserAbortHomingRequest request)
        {
            return await SendRequest<DispenserAbortHomingRequest, DispenserAbortHomingResponse>(request);
        }

        /// <summary>
        /// Turn on/off the specified digital output pin.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        public async Task<SetDigitalOutResponse> SetDigitalOut(SetDigitalOutRequest request)
        {
            return await SendRequest<SetDigitalOutRequest, SetDigitalOutResponse>(request);
        }

        /// <summary>
        /// Starts jogging the thread motion system.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        public async Task<ThreadJoggingResponse> StartThreadJogging(ThreadJoggingRequest request)
        {
            return await SendRequest<ThreadJoggingRequest, ThreadJoggingResponse>(request);
        }

        /// <summary>
        /// Stops jogging the thread motion system.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        public async Task<ThreadAbortJoggingResponse> StopThreadJogging(ThreadAbortJoggingRequest request)
        {
            return await SendRequest<ThreadAbortJoggingRequest, ThreadAbortJoggingResponse>(request);
        }

        #endregion
    }
}