DP44/DataPRO/DASFactory/DASFactory.Ribeye.cs

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)
        {
        }
    }
}