init

DataPRO/SLICECommands/DownloadCommands/GetNextDownloadStreamDataSamples.cs

@@ -0,0 +1,188 @@
+using System;
+using System.Text;
+using DTS.Common.Enums.Communication;
+using DTS.Common.Enums.DASFactory;
+using DTS.Common.ICommunication;
+using DTS.Common.Utilities;
+
+namespace DTS.DASLib.Command.SLICE.DownloadCommands
+{
+    /// <summary>
+    /// This was ported from FirmwareTestUtility where it was written by Loc Pham
+    /// it is being included for
+    /// 10573 implement SW side of single command/streaming download
+    /// this command can be used to collect data that has been collecting in a buffer
+    /// from download streaming
+    /// </summary>
+    public class GetNextDownloadStreamDataSamples : EventDataCommands
+    {
+        protected override Commands Command => Commands.GetNextDownloadStreamDataSamples;
+
+        public GetNextDownloadStreamDataSamples(DTS.Common.Interface.DASFactory.ICommunication sock)
+            : base(sock)
+        {
+            baseCommand = new CommandPacket();
+            LogCommands = false;
+            baseCommand.SetCommand((byte)Commands.GetNextDownloadStreamDataSamples, "GetNextDownloadStreamDataSamples");
+        }
+        public GetNextDownloadStreamDataSamples(DTS.Common.Interface.DASFactory.ICommunication sock, int msTimeout)
+            : base(sock, msTimeout)
+        {
+            baseCommand = new CommandPacket();
+            LogCommands = false;
+            baseCommand.SetCommand((byte)Commands.GetNextDownloadStreamDataSamples, "GetNextDownloadStreamDataSamples");
+        }
+
+        public DownloadByteConverter DlData { get; private set; }
+
+        private ushort _lastSequenceProcessed = ushort.MaxValue;
+        private const int MAX_SEQUENCE_DIFF = 1000;
+
+        public void ProcessData()
+        {
+            var bytes = baseResponse.ToBytes();
+            var headerCrc = response.HeaderCRC;
+            response.ComputeCRCs();
+            if (headerCrc != response.HeaderCRC)
+            {
+                DlData = null;
+                return;
+            }
+
+            DlData = new DownloadByteConverter(bytes);
+
+            if (null == DlData) { return; }
+            if (_lastSequenceProcessed == DlData.SeqNumber)
+            {
+                DlData = null;
+                return;
+            }
+            var delta = Math.Abs(DlData.SeqNumber - _lastSequenceProcessed);
+            if (delta > MAX_SEQUENCE_DIFF && ushort.MaxValue != _lastSequenceProcessed && 0 != DlData.SeqNumber)
+            {
+                //per loc we shouldn't get here, the old code in the FWTU would apparently unintentionally throw an exception
+                //I've preserved that code in comments below
+                throw new Exception("sequence number overflow");
+                //DlData = null;
+                //_lastSequenceProcessed = DlData.SeqNumber;
+                //return;
+            }
+            _lastSequenceProcessed = DlData.SeqNumber;
+        }
+
+        /// <summary>
+        /// We need to override SyncExecute because we don't want to send anything (that would tell the G5 to stop sending).  Instead we just want to 
+        /// read whatever is out there.  Otherwise this is mostly cut and paste of normal SyncExecute with some streamlining for our specific case.
+        /// </summary>
+        public override void SyncExecute()
+        {
+            // this is a try/finally to handle the ExecuteIsBusy
+            try
+            {
+                DlData = null;
+                // there can be only one!
+                recorder.ExecuteIsBusy = true;
+
+                if (recorder.IsCanceled())
+                {
+                    throw new CanceledException();
+                }
+
+                UserCallback = null;
+                UserCallbackData = null;
+                IsSynchronous = true;
+                SyncEvent.Reset();
+                recorder.PseudoExecute(new byte[0], ExecuteCallback, null, IO_Timeout);
+
+                var syncExecTimeout = IO_Timeout;
+
+                try
+                {
+                    if (!WaitWithCondition.Wait(SyncEvent, syncExecTimeout,
+                        recorder.CancelEvent))
+                    {
+                        //timeout
+                        LogString("SyncExecute: timeout");
+                        throw new TimeoutException(MakeLogString("SyncExecute: timeout"));
+                    }
+                }
+                catch (WaitWithCondition.ConditionMetException)
+                {
+                    throw new CanceledException();
+                }
+
+                // we didn't timeout, check the result
+                switch (ComReport.Result)
+                {
+                    case CommunicationConstantsAndEnums.CommunicationResult.Canceled:
+                        throw new CanceledException();
+
+                    case CommunicationConstantsAndEnums.CommunicationResult.ReceiveOK:
+                        if (baseResponse == null)
+                        {
+                            LogString("SyncExecute: ReceiveOK but response==null!");
+                            LogCommand(false);
+                        }
+                        else if (baseResponse.Status != DFConstantsAndEnums.CommandStatus.StatusNoError)
+                        {
+                            // didn't go well
+                            var msg = MakeLogString("SyncExecute: response.Status = " + baseResponse.Status);
+                            LogCommand(false);
+                            switch (baseResponse.Status)
+                            {
+                                case DFConstantsAndEnums.CommandStatus.StatusInvalidModeForCommand:
+                                    throw new CommandException(CommandErrorReason.InvalidMode, msg);
+                                case DFConstantsAndEnums.CommandStatus.StatusUnimplemented:
+                                case DFConstantsAndEnums.CommandStatus.StatusInvalidCommand:
+                                case DFConstantsAndEnums.CommandStatus.StatusInvalidCommandType:
+                                    throw new NotImplementedException(msg);
+                            }
+                            var ex = new Exception(msg);
+                            ex.Data.Add("Status", baseResponse.Status);
+                            throw ex;
+                        }
+
+                        // everything is fine, let it exit
+                        if (LogCommands)
+                        {
+                            LogCommand(false);
+                        }
+                        break;
+
+                    case CommunicationConstantsAndEnums.CommunicationResult.ReceiveFailed:
+                        {
+                            var msg = MakeLogString("SyncExecute: ComReport.Result == " + ComReport.Result);
+                            LogCommand(false);
+
+                            throw new CommandException(CommandErrorReason.ReceiveFailed, msg);
+                        }
+                    case CommunicationConstantsAndEnums.CommunicationResult.ReceiveTimeout:
+                        {
+                            var msg = MakeLogString("SyncExecute: ComReport.Result == " + ComReport.Result);
+                            LogCommand(false);
+                            throw new CommandException(CommandErrorReason.ReceiveFailed, msg);
+                        }
+
+                    case CommunicationConstantsAndEnums.CommunicationResult.SendFailed:
+                    case CommunicationConstantsAndEnums.CommunicationResult.SendTimeout:
+                        {
+                            var msg = MakeLogString("SyncExecute: ComReport.Result == " + ComReport.Result);
+                            LogCommand(false);
+                            throw new CommandException(CommandErrorReason.SendFailed, msg);
+                        }
+
+                    default:
+                        {
+                            var msg = MakeLogString("SyncExecute: Unknown ComReport.Result == " + ComReport.Result);
+                            LogCommand(false);
+                            throw new Exception(msg);
+                        }
+                }
+            }
+            finally
+            {
+                recorder.ExecuteIsBusy = false;
+            }
+        }
+    }
+}