API_SequentMicrosystems-RPI/Services/RTDDataAcquisitionService.cs

using API_SequentMicrosystems.Models;
using Libs_SequentMicrosystems;
using Newtonsoft.Json;

namespace API_SequentMicrosystems.Services
{
    public class RTDDAService
    {
        private RTDStackLevelReader _stackLevelReader = new RTDStackLevelReader();
        public readonly List<byte> _stackLevels = new List<byte>();

        public RTDDAService(IConfiguration configuration)
        {
            if (!Directory.Exists("RTDDA"))
                Directory.CreateDirectory("RTDDA");

            List<CardsConfig> cardsConfig = configuration.GetSection("Cards").Get<List<CardsConfig>>();
                #pragma warning disable CS8604 // Může jít o argument s odkazem null.
            CardsConfig config = cardsConfig.Where(x => x.ID == "0").First();
                #pragma warning restore CS8604 // Může jít o argument s odkazem null.
            foreach (char c in config.Levels.ToCharArray())
            {
                try
                {
                    _stackLevels.Add(byte.Parse(c.ToString()));
                }
                catch
                {
                    Console.WriteLine($"Char {c} is not convertable to byte");
                }
            }

            ChanelsNames = LoadChanelsNames();  //ChanelsNames
            PreconfiguredChanelsNames = LoadPreconfiguredChanelsNames();    //ChanelsPreconfiguredNames
            CalibrationData = LoadCalibratioData();
        }

        /// <summary>
        /// Read data from all RTD cards
        /// </summary>
        /// <returns>data from all RTD cards</returns>
        public SortedList<byte, float[]> ReadAllCard()
        {
            SortedList<byte, float[]> data = new SortedList<byte, float[]>();

            for (byte i = 0; i < 8; i++)    //loop for read all stack levels
            {
                float[] RD = ReadCard(i);   //read stack level

                if (RD.Length > 3)
                    data.Add(i, RD);    //Add readed data to SortedList
            }

            return data;    //return data
        }

        /// <summary>
        /// Read data from all configured cards
        /// </summary>
        /// <returns>Data from all configuredd Cards</returns>
        public SortedList<byte, float[]> ReadAllConfiguredCard()
        {
            SortedList<byte, float[]> data = new SortedList<byte, float[]>();

            for (byte i = 0; i < 8; i++)    //loop for read all stack levels
            {
                if (_stackLevels.Contains(i))
                {
                    try
                    {
                        data.Add(i, ReadCard(i)); //read stack level
                    }
                    catch
                    {
                        Console.WriteLine($"RTD stack {i} is not available");
                    }
                }
            }

            return data;    //return data
        }

        /// <summary>
        /// Read data from specified card
        /// </summary>
        /// <param name="stack">stack level ID</param>
        /// <returns>Data of selected stack card</returns>
        public float[] ReadCard(byte stack)
        {
            try
            {
                float[] data = _stackLevelReader.GetStack(stack);   //return data from specified card and ted measure precision

                for (byte i = 0;i < 8; i++)
                {
                    data[i] += ReadCpecifiedChanelCalibration(stack, i);
                }

                return data;
            }
            catch
            {
                return new float[0];    //if card read get error, return empty array
            }
        }

        #region ChanelsName
        private SortedList<byte, string[]> ChanelsNames;

        /// <summary>
        /// Load Chanels Names from file
        /// </summary>
        /// <returns></returns>
        private SortedList<byte, string[]> LoadChanelsNames()
        {
            try
            {
                    #pragma warning disable CS8603 // Může jít o vrácený odkaz null.
                return JsonConvert.DeserializeObject<SortedList<byte, string[]>>(File.ReadAllText("RTDDA/Names.json"));
                    #pragma warning restore CS8603 // Může jít o vrácený odkaz null.
            }
            catch
            {
                return new();
            }
        }

        /// <summary>
        /// Save ChanelsNames to FIle
        /// </summary>
        private void SaveChanelsNames()
        {
            File.WriteAllText("RTDDA/Names.json", JsonConvert.SerializeObject(ChanelsNames));
        }

        /// <summary>
        /// Get CHanelsNames
        /// </summary>
        /// <returns></returns>
        public SortedList<byte, string[]> GetChanelsNames()
        {
            return ChanelsNames;
        }

        /// <summary>
        /// Save Chanels Names
        /// </summary>
        /// <param name="ChN"></param>
        public void SetChanelsNames(SortedList<byte, string[]> ChN)
        {
            ChanelsNames = ChN;
            SaveChanelsNames();
        }

        #endregion

        #region PreconfiguredChanelsNames

        private List<string> PreconfiguredChanelsNames;

        /// <summary>
        /// Load Preconfigurated Chanels Names from file
        /// </summary>
        /// <returns></returns>
        private List<string> LoadPreconfiguredChanelsNames()
        {
            try
            {
                    #pragma warning disable CS8603 // Může jít o vrácený odkaz null.
                return JsonConvert.DeserializeObject<List<string>>(File.ReadAllText("RTDDA/PNames.json"));
                    #pragma warning restore CS8603 // Může jít o vrácený odkaz null.
            }
            catch
            {
                return new();
            }
        }

        /// <summary>
        /// Save Preconfigurated chanels names to File
        /// </summary>
        private void SavePreconfiguratedChanelsNames()
        {
            File.WriteAllText("RTDDA/PNames.json", JsonConvert.SerializeObject(PreconfiguredChanelsNames));
        }

        /// <summary>
        /// Get preconfigured chanels names
        /// </summary>
        /// <returns></returns>
        public List<string> GetPreconfiguratedChanelsNames()
        {
            return PreconfiguredChanelsNames.ToList();
        }

        /// <summary>
        /// Save Preconfigured ChanelsNames
        /// </summary>
        /// <param name="ChN"></param>
        public void SetPreconfiguratedChanelsNames(List<string> ChN)
        {
            PreconfiguredChanelsNames = ChN;
            SavePreconfiguratedChanelsNames();
        }

        #endregion

        #region Calibration

        private SortedList<byte, float[]> CalibrationData;

        /// <summary>
        /// Load Calibration data from File
        /// </summary>
        /// <returns></returns>
        private SortedList<byte, float[]> LoadCalibratioData()
        {
            try
            {
                    #pragma warning disable CS8603 // Může jít o vrácený odkaz null.
                return JsonConvert.DeserializeObject<SortedList<byte, float[]>>(File.ReadAllText("RTDDA/Calibration.json"));
                    #pragma warning restore CS8603 // Může jít o vrácený odkaz null.
            }
            catch
            {
                return new();
            }
        }

        /// <summary>
        /// Save Calibration data to File
        /// </summary>
        private void SaveCalibrationData()
        {
            File.WriteAllText("RTDDA/Calibration.json", JsonConvert.SerializeObject(CalibrationData));
        }

        /// <summary>
        /// Get Calibration Data
        /// </summary>
        /// <returns></returns>
        public SortedList<byte, float[]> GetCalibrationData()
        {
            return CalibrationData;
        }

        /// <summary>
        /// Set new calibration Data
        /// </summary>
        /// <param name="CD"></param>
        public void SetCalibrationData(SortedList<byte, float[]> CD)
        {
            CalibrationData = CD;
            SaveCalibrationData();
        }

        /// <summary>
        /// Get Calibration data of specific card chanel
        /// </summary>
        /// <param name="stack">Card stack position ID</param>
        /// <param name="chanel">Chanel ID</param>
        /// <returns>Calibration data of specific chanel</returns>
        private float ReadCpecifiedChanelCalibration(byte stack, byte chanel)
        {
            if (!CalibrationData.ContainsKey(stack))
                return 0;

            if (CalibrationData[stack].Length < chanel)
                return 0;

            return CalibrationData[stack][chanel];
        }


        #endregion

        #region ValueTypes

        /// <summary>
        /// Save ValueTypes data to File
        /// </summary>
        public void SaveValueTypes(SortedList<byte, byte[]> data)
        {
            File.WriteAllText("RTDDA/ValueTypes.json", JsonConvert.SerializeObject(data));
        }

        /// <summary>
        /// Load ValueTypes data from File
        /// </summary>
        /// <returns></returns>
        public SortedList<byte, byte[]> LoadValueTypes()
        {
            try
            {
#pragma warning disable CS8603 // Může jít o vrácený odkaz null.
                return JsonConvert.DeserializeObject<SortedList<byte, byte[]>>(File.ReadAllText("RTDDA/ValueTypes.json"));
#pragma warning restore CS8603 // Může jít o vrácený odkaz null.
            }
            catch
            {
                return new();
            }
        }


        #endregion


    }
}