common/CordonelPreadjustmentUi/MainForm.cs

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using Xylem.Common.CommonCore.Consts;
using Xylem.Common.Hardware.Interfaces.Ports.PortCore;
using Xylem.Common.Hardware.WaterMeter.Genesis.GenesisConfig;
using Xylem.Common.Hardware.WaterMeter.WaterMeterCore;
using Xylem.Common.Ui.CordonelPreadjustmentUi;

namespace CordonelPreadjustmentUi
{
    public partial class MainForm : Form
    {
        private PreAdjustmentControl preadjustCtl;
        private PreAdjustmentSettingsContainer mainSettings = new PreAdjustmentSettingsContainer();
        public MainForm()
        {
            InitializeComponent();
        }

        private void MainForm_Load(object sender, EventArgs e)
        {
           

            preadjustCtl = new PreAdjustmentControl(mainSettings);
            tab_ZeroFlowCal.Controls.Add(preadjustCtl);




            cB_SinglePath.Checked = mainSettings.NumberOfPaths == 1 ? true : false;
            nUD_SettingsTempMonitorLowerValue.Value = (decimal)mainSettings.LowerTempLimit;
            nUD_SettingsTempMonitorUpperValue.Value = (decimal)mainSettings.UpperTempLimit;
            nUD_SettingsTempMonitorDeviation.Value = (decimal)mainSettings.TempDeviationLimit;
            // nUD_SettingsPreparationMetersize.Value = mainSettings.MeterSize.GetHashCode();


            cB_OffsetTestLogFiles.Checked = mainSettings.OffsetTestGenerateLogfiles;
            nUD_Settings_ZeroflowOffsetTestActivityCheckInterval.Value = mainSettings.OffsetTestActivityCheckInverval;
            nUD_Settings_ZeroflowOffsetTestNumberOfLines.Value = mainSettings.OffsetTestNumberOfLines;
            nUD_Settings_ZeroflowOffsetTestSettlingTime.Value = mainSettings.OffsetTestSettlingTime;
            nUD_Settings_ZeroflowOffsetTestOffsetLimit.Value = mainSettings.OffsetTestOffsetLimitPS;
            nUD_Settings_ZeroflowOffsetTestLowerLimit.Value = mainSettings.OffsetTestLowerVoltageLimitMV;
            nUD_Settings_ZeroflowOffsetTestUpperLimit.Value = mainSettings.OffsetTestUpperVoltageLimitMV;

            cB_AmpLogFiles.Checked = mainSettings.AmpTestGenerateLogfiles;
            nUD_Settings_AmplitudeActivityCheckInterval.Value = mainSettings.AmpTestActivityCheckInverval;
            cB_MeanAmplitudeFiles.Checked = mainSettings.AmpTestGenerateMeanValuesFile;
            nUD_PercentageStop.Value = mainSettings.AmpTestPercentageStop;
            nUD_PercentageStart.Value = mainSettings.AmpTestPercentageStart;
            nUD_Settings_AmplitudeTestMinDistance.Value = mainSettings.AmpTestAmpTestDistance;

            nUD_Settings_AmplitudeTestLowerLimit.Value = mainSettings.AmpTestFirstHitLevelPropMin;
            nUD_Settings_AmplitudeTestUpperLimit.Value = mainSettings.AmpTestFirstHitLevelPropMax;


            nUD_Settings_Samplerate.Value = mainSettings.Samplerate;



        }

        private void tab_Maintab_Selected(object sender, TabControlEventArgs e)
        {
            if (e.TabPage.Name == tab_ZeroFlowCal.Name)
            {
                try
                {
                    var _serialConfigFile = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Genesis", ProgramConfig.SerialConfigFileName);


                    SlotConfig[] meterConfigList;
                    using (var tr = new StreamReader(_serialConfigFile))
                    {
                        var _fileString = tr.ReadToEnd();
                        meterConfigList = JsonConvert.DeserializeObject<SlotConfig[]>(_fileString);
                    }
                    mainSettings.Meters = new List<int>();
                    mainSettings.TempMeters = new List<int>();
                    foreach (var item in meterConfigList)
                    {
                        if (item.Type != SlotType.TemperatureMeter)
                        {
                            mainSettings.Meters.Add(item.Slot);
                        }
                        else
                        {
                            mainSettings.TempMeters.Add(item.Slot);
                        }
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show($"use default meters because of {ex.Message}");
                }
              




                mainSettings.NumberOfPaths = cB_SinglePath.Checked ? 1 : 3;
                mainSettings.LowerTempLimit = (double)nUD_SettingsTempMonitorLowerValue.Value;
                mainSettings.UpperTempLimit = (double)nUD_SettingsTempMonitorUpperValue.Value;
                mainSettings.TempDeviationLimit = (double)nUD_SettingsTempMonitorDeviation.Value;
                //mainSettings.MeterSize = (Xylem.Common.Hardware.WaterMeter.Genesis.GenesisCore.Consts.MeterSize)nUD_SettingsPreparationMetersize.Value;
                mainSettings.TempOnly = cB_TempOnly.Checked;

                mainSettings.SetTempUseTempFlansh(true);

                if (cB_TempManualAcquisition.Checked)
                {
                    mainSettings.SetTempUseManualInput(true);
                    mainSettings.SetTempUseTempFlansh(false);
                }
                else
                {
                    mainSettings.SetTempUseTempFlansh(true);
                    mainSettings.SetTempUseManualInput(false);
                }      
               

                mainSettings.OffsetTestGenerateLogfiles = cB_OffsetTestLogFiles.Checked;
                mainSettings.OffsetTestActivityCheckInverval = (int)nUD_Settings_ZeroflowOffsetTestActivityCheckInterval.Value;
                mainSettings.OffsetTestNumberOfLines = (int)nUD_Settings_ZeroflowOffsetTestNumberOfLines.Value;
                mainSettings.OffsetTestSettlingTime = (int)nUD_Settings_ZeroflowOffsetTestSettlingTime.Value;
                mainSettings.OffsetTestOffsetLimitPS = (int)nUD_Settings_ZeroflowOffsetTestOffsetLimit.Value;
                mainSettings.OffsetTestLowerVoltageLimitMV = (int)nUD_Settings_ZeroflowOffsetTestLowerLimit.Value;
                mainSettings.OffsetTestUpperVoltageLimitMV = (int)nUD_Settings_ZeroflowOffsetTestUpperLimit.Value;

                mainSettings.AmpTestGenerateLogfiles = cB_AmpLogFiles.Checked;
                mainSettings.AmpTestActivityCheckInverval = (int)nUD_Settings_AmplitudeActivityCheckInterval.Value;
                mainSettings.AmpTestGenerateMeanValuesFile = cB_MeanAmplitudeFiles.Checked;
                mainSettings.AmpTestPercentageStop = (int)nUD_PercentageStop.Value;
                mainSettings.AmpTestPercentageStart = (int)nUD_PercentageStart.Value;
                mainSettings.AmpTestAmpTestDistance = (int)nUD_Settings_AmplitudeTestMinDistance.Value;


                mainSettings.AmpTestFirstHitLevelPropMin = (int)nUD_Settings_AmplitudeTestLowerLimit.Value;
                mainSettings.AmpTestFirstHitLevelPropMax = (int)nUD_Settings_AmplitudeTestUpperLimit.Value;

                mainSettings.Samplerate = (int)nUD_Settings_Samplerate.Value;
                
                preadjustCtl.SetSettings(mainSettings);


            }



        }

        private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (preadjustCtl != null)
            {
                preadjustCtl.CloseConnections();
                preadjustCtl.Dispose();
            }
            if (ThermoMeterBatch != null)
            {
                ThermoMeterBatch.Dispose();
            }
            if (TempMeterStateCtls != null)
            {
                foreach (var item in TempMeterStateCtls)
                {
                    item.Dispose();
                }

            }


        }
        private MeterBatch ThermoMeterBatch = new MeterBatch();
        private List<MeterStateControl> TempMeterStateCtls = new List<MeterStateControl>();
        private void tmpStart(int slot, bool RaspiMode = false)
        {
            var ctlZehn = new TempMeterStateControl(slot);
            ctlZehn.Location = new Point(5 + ((TempMeterStateCtls.Count + 1) * ctlZehn.Width), 15);
            TempMeterStateCtls.Add(ctlZehn);
            gB_TempMeters.Controls.Add(ctlZehn);
            ctlZehn.Enabled = true;




            var currentMeter = new ZeroFlowGenesisMeter(ctlZehn.Slot, 3, !RaspiMode);

            currentMeter.LogOnEnable = true;
            currentMeter.LoginFailed = false;
            currentMeter.PreparationFailed = false;
            currentMeter.AmplitudeFailed = false;
            currentMeter.ZeroFlowOffsetFailed = false;
            currentMeter.AmplitudeFailed = false;
            currentMeter.CompletionFailed = false;
            currentMeter.Ok = false;
            currentMeter.EmptyPipeCheckEnable = false;
            currentMeter.EmptyPipeCheckFailed = false;

            ThermoMeterBatch.AddMeter(currentMeter);
            ctlZehn.IsEnabled = true;


            ctlZehn.Meter = currentMeter;
            ctlZehn.EnableOpening = true;

            ctlZehn.Ok = ctlZehn.Meter.CheckStreamingPort();

            ctlZehn.SetUi();

            ctlZehn.Meter.StartRecordData();
            ctlZehn.Meter.LogRawData(true);
            if (RaspiMode)

            {
                ctlZehn.StartTempWatch(MeterStateControl.TempMode.CalcTof);

            }
            else
            {
                ctlZehn.StartTempWatch(MeterStateControl.TempMode.Meter);
            }
            ctlZehn.SetTemperature(0);
            ctlZehn.DisableTemperatureinput(true);
            ctlZehn.IsEnabled = true;


        }


        private void btn_LoadTempe_Click(object sender, EventArgs e)
        {

            tmpStart((int)nudTempSlot.Value, false);


        }

        private void btnTempRaspi_Click(object sender, EventArgs e)
        {
            tmpStart((int)nudTempSlot.Value, true);
        }

        private void button1_Click(object sender, EventArgs e)
        {
            if (TempMeterStateCtls != null)
            {
                StringBuilder sb = new StringBuilder();

                foreach (var item in TempMeterStateCtls)
                {
                    sb.AppendLine();
                    sb.AppendLine($"##########Meter{item.Slot}#############");
                    sb.Append(item.GetLog());
                    sb.AppendLine();
                }
                richTextBox1.Text = sb.ToString();
                richTextBox1.ScrollToCaret();
            }

        }

        private void tab_ZeroFlowCal_Click(object sender, EventArgs e)
        {

        }
    }
}