private async Task RunSyncTest()
        {
            await Task.Run(async() =>
            {
                if (!RunningTest)
                {
                    Log.Info("Syncing Volume...");
                    await InstrumentCommunicator.Disconnect();

                    VolumeTest.PulseACount = 0;
                    VolumeTest.PulseBCount = 0;

                    _outputBoard.StartMotor();

                    do
                    {
                        VolumeTest.PulseACount += FirstPortAInputBoard.ReadInput();
                        VolumeTest.PulseBCount += FirstPortBInputBoard.ReadInput();
                    } while (VolumeTest.UncPulseCount < 1);

                    _outputBoard.StopMotor();
                    Thread.Sleep(500);
                }
            });
        }
 public async Task DisconnectFromInstrument()
 {
     if (InstrumentCommunicator != null)
     {
         await InstrumentCommunicator.Disconnect();
     }
 }
        public async Task ReadInstrumentValue()
        {
            await InstrumentCommunicator.Connect();

            var result = await InstrumentCommunicator.GetItemValue(ItemNumber);

            ItemValue = result.RawValue;
            NotifyOfPropertyChange(() => ItemValue);
        }
        protected override async Task ZeroInstrumentVolumeItems()
        {
            await InstrumentCommunicator.Connect();

            await InstrumentCommunicator.SetItemValue(264, "20140867");

            await InstrumentCommunicator.SetItemValue(434, "0");

            await InstrumentCommunicator.SetItemValue(113, "0");

            await InstrumentCommunicator.SetItemValue(892, "0");

            await base.ZeroInstrumentVolumeItems();
        }
        public override async Task FinishVolumeTest()
        {
            await Task.Run(async() =>
            {
                System.Threading.Thread.Sleep(250);

                await InstrumentCommunicator.Connect();
                VolumeTest.AfterTestItems = await InstrumentCommunicator.GetItemValues(InstrumentCommunicator.ItemDetails.VolumeItems());
                await ZeroInstrumentVolumeItems();

                Log.Info("Volume test finished!");
                RunningTest = false;
            });
        }
        public override async Task StartVolumeTest()
        {
            if (!RunningTest)
            {
                await InstrumentCommunicator.Connect();

                VolumeTest.Items = await InstrumentCommunicator.GetItemValues(InstrumentCommunicator.ItemDetails.VolumeItems());

                await InstrumentCommunicator.Disconnect();

                VolumeTest.PulseACount = 0;
                VolumeTest.PulseBCount = 0;

                await RunningVolumeTest();
            }
        }
        public override async Task StartVolumeTest()
        {
            if (!RunningTest)
            {
                await RunSyncTest();

                if (_tachometerCommunicator != null)
                {
                    await _tachometerCommunicator?.ResetTach();
                }

                await InstrumentCommunicator.Connect();

                VolumeTest.Items = await InstrumentCommunicator.GetItemValues(InstrumentCommunicator.ItemDetails.VolumeItems());

                await InstrumentCommunicator.Disconnect();

                await RunningVolumeTest();
            }
        }
        public override async Task FinishVolumeTest()
        {
            await Task.Run(async() =>
            {
                try
                {
                    Thread.Sleep(250);

                    VolumeTest.AfterTestItems = await InstrumentCommunicator.GetItemValues(InstrumentCommunicator.ItemDetails.VolumeItems());

                    await ZeroInstrumentVolumeItems();

                    try
                    {
                        if (_tachometerCommunicator != null)
                        {
                            VolumeTest.AppliedInput = await _tachometerCommunicator.ReadTach();
                        }
                        else
                        {
                            VolumeTest.AppliedInput = 0;
                        }

                        Log.Info($"Tachometer reading: {VolumeTest.AppliedInput}");
                    }
                    catch (Exception ex)
                    {
                        Log.Error($"An error occured communication with the tachometer: {ex}");
                    }

                    Log.Info("Volume test finished!");
                }
                finally
                {
                    RunningTest = false;
                }
            });
        }
        public async Task WriteInstrumentValue()
        {
            await InstrumentCommunicator.Connect();

            await InstrumentCommunicator.SetItemValue(ItemNumber, ItemValue);
        }