init

DataPRO/DASFactory/.svn/pristine/13/139e57961b17e8c6317aeed88705feecbf56ba08.svn-base

@@ -0,0 +1,204 @@
+using System;
+using System.Collections.Generic;
+using DTS.Common.DAS.Concepts;
+using DTS.Common.Enums.DASFactory;
+using DTS.Common.ICommunication;
+using DTS.Common.Interface.DASFactory;
+using DTS.Common.Utilities.Logging;
+using DTS.DASLib.Command.Ribeye;
+using DTS.DASLib.Service;
+
+namespace DTS.DASLib.DASFactory
+{
+    internal class RibeyeHandling : IDeviceSetup
+    {
+        static readonly float AAFilterDivider = 5.0F;
+        static readonly Dictionary<uint, float> Samplerate2AAFilterDict = new Dictionary<uint, float>
+        {
+            {500, 500.0F/AAFilterDivider},
+            {1000, 1000.0F/AAFilterDivider},
+            {2500, 2500.0F/AAFilterDivider},
+            {5000, 5000.0F/AAFilterDivider},
+            {10000, 10000.0F/AAFilterDivider},
+            {20000, 20000.0F/AAFilterDivider},
+            {25000, 25000.0F/AAFilterDivider},
+            {50000, 50000.0F/AAFilterDivider},
+            {100000, 100000.0F/AAFilterDivider}
+        };
+
+        public RibeyeHandling(bool _utilMode)
+        {
+        }
+
+        public bool QueryInformation(ConnectedDevice dev)
+        {
+            if (!(dev.Dev is IConnectedDAS))
+            {
+                return false;
+            }
+            var DASCommDev = ((IConnectedDAS)dev.Dev).DASComm;
+            if (!(DASCommDev is ICommunication))
+            {
+                return false;
+            }
+            var CommDev = DASCommDev as ICommunication;
+
+            try
+            {
+                var dasInfo = new InfoResult { MaxNumberOfModules = 10 };
+
+                string SerialNumber;
+                uint NumberOfLEDs;
+
+                // Need to bootstrap protocol version ...
+                CommDev.ProtocolVersion = 1;
+                // Above left in place for future use.
+
+                var Status = new QueryArmAndTriggerStatus(CommDev);
+
+                try
+                {
+                    Status.SyncExecute();
+                }
+                catch
+                {
+                    // The ribeye will always fail this command on the first boot up (problably because
+                    // their CRC is not inited right.  
+                    //
+                    // Silently retry.
+
+                    Status.SyncExecute();
+                }
+
+                if (Status.IsArmed)
+                {
+                    SerialNumber = "Ribeye";
+                    NumberOfLEDs = 18;  // Would be nice to have a better fall back
+                }
+                else
+                {
+
+                    var SerialNumberQuery = new QuerySerialNumber(CommDev);
+                    SerialNumberQuery.SyncExecute();
+                    SerialNumber = SerialNumberQuery.SerialNumber;
+
+                    var LEDQuery = new QueryNumberOfLEDs(CommDev);
+                    LEDQuery.SyncExecute();
+                    NumberOfLEDs = LEDQuery.NumberOfLEDs;
+                }
+
+                dasInfo.Modules = new InfoResult.Module[NumberOfLEDs];
+                CommDev.FirmwareVersion = "0000";
+                DASCommDev.SerialNumber = SerialNumber;
+                var serialNumbers = new string[NumberOfLEDs + 1];
+                var firmwareVersions = new string[NumberOfLEDs + 1];
+                serialNumbers[0] = DASCommDev.SerialNumber;
+                firmwareVersions[0] = CommDev.FirmwareVersion;
+                for (var Index = 0; Index < NumberOfLEDs; Index++)
+                {
+                    var module = new InfoResult.Module
+                    {
+                        ModuleArrayIndex = Index,
+                        MaxRecordingSamples = 300000,
+                        NumberOfChannels = 3,
+                        SerialNumber = DASCommDev.SerialNumber + "-" + Index,
+                        SupportedModes = new[]
+                        {
+                            DFConstantsAndEnums.RecordingMode.CircularBuffer,
+                            DFConstantsAndEnums.RecordingMode.RecorderMode
+                        },
+                        SupportedSampleRates = new uint[1]
+                    };
+
+                    // this should be adjusted to real-life
+                    //module.SerialNumber = (dev as IDASCommunication).SerialNumber + "-" + Index.ToString();
+                    module.SupportedSampleRates[0] = 10000;
+                    module.TypeOfModule = DFConstantsAndEnums.ModuleType.RibeyeLED; // for now
+                    module.SampleRate2AAFrequency = Samplerate2AAFilterDict;
+                    dasInfo.Modules[Index] = module;
+
+                    serialNumbers[Index + 1] = module.SerialNumber;
+                    firmwareVersions[Index + 1] = "0000";
+                }
+
+                //these are from the ribeye protocol specifications pdf, specifically
+                // "30 second flash memory" which by default is supporting 6 ribs sensing in 3 directions
+                // at 10k samples/sec.
+                dasInfo.MaxEventStorageSpaceInBytes = 30 * 10000 * 6 * 3;
+                //note this could be inaccurate if we dropped into here already armed, the code
+                //above will just constant it to 18 and so our calculations might be off.
+                dasInfo.NumberOfBytesPerSampleClock = NumberOfLEDs;
+
+                var icomm_dasinfo = new Communication_DASInfo { SerialNumbers = new string[1] };
+                icomm_dasinfo.SerialNumbers[0] = SerialNumber;
+                icomm_dasinfo.FirmwareVersions = firmwareVersions;
+                CommDev.DASInfo = icomm_dasinfo;
+                DASCommDev.SetDASInfo(dasInfo);
+                try
+                {
+                    if (dev.Dev is IConnectedDAS idas)
+                    {
+                        idas.DASComm?.ReadFirstUseDate();
+                    }
+                }
+                catch (Exception ex) { APILogger.Log(ex); }
+                return true;
+            }
+            catch (Exception)
+            {
+                var dasInfo = new InfoResult
+                {
+                    MaxNumberOfModules = 10,
+                    Modules = new InfoResult.Module[0]
+                };
+                DASCommDev.SetDASInfo(dasInfo);
+                dev.InUpdateMode = true;
+                return false;
+            }
+        }
+
+        public ICommunication GetICommunication()
+        {
+            return new EthernetRibeye();
+        }
+
+        public ICommunication GetICommunication(ConnectedDevice dev)
+        {
+            return (dev.Dev as ConnectedEthernetRibeye).Comm;
+        }
+
+        public IConnectedDevice GetIConnectedDevice(DTS.Common.Interface.DASFactory.ICommunication comm)
+        {
+            return new ConnectedEthernetRibeye(comm as EthernetRibeye);
+        }
+
+        public bool IsCorrectType(ConnectedDevice dev)
+        {
+            return dev.Dev is ConnectedEthernetRibeye;
+        }
+
+        public DFConstantsAndEnums.DASType GetDASType()
+        {
+            return DFConstantsAndEnums.DASType.ETHERNET_RIBEYE;
+        }
+
+        public Guid GetGuid()
+        {
+            return Guid.Empty;
+        }
+
+        public int GetProductId()
+        {
+            return 0;
+        }
+
+        public string GetProductIdString()
+        {
+            return string.Empty;
+        }
+
+        public void SetHandler(DeviceHandling handler)
+        {
+        }
+    }
+}