Анимировать переход иглы

Исходя из фона элементов управления, чтобы имитировать поведение аналогового устройства, вы можете использовать экспоненциальный фильтр (он же фильтр нижних частот).

Существует два типа фильтров нижних частот, которые вы можете использовать, в зависимости от того, какой тип поведения вы хотите увидеть: фильтр первого порядка или фильтр второго порядка. Короче говоря, если ваши показания были стабильными на уровне 0, а затем внезапно изменились на 10 и оставались постоянными на уровне 10 (ступенчатое изменение), первый порядок медленно доходил бы до 10, никогда не превышая его, затем оставался бы на 10, тогда как второй порядок ускорит свой прогресс до 10, пройдет его, а затем колеблется до 10.

Функция экспоненциального фильтра проста:

public void Exp_Filt(ref double filtered_value, double source_value, double time_passed, double time_constant)
{
    if (time_passed > 0.0)
    {
        if (time_constant > 0.0)
        {
            source_value += (filtered_value - source_value) * Math.Exp(-time_passed / time_constant);
        }
        filtered_value = source_value;
    }
}

filtered_value — отфильтрованная версия источника source_value, time_passed — сколько времени прошло с момента последнего вызова этой функции для фильтрации filtered_value, а time_constant — постоянная времени фильтра (к вашему сведению, реагируя на ступенчатое изменение, filtered_value получит 63 % пути к source_value по прошествии time_constant времени и 99% по прошествии 5 раз). Единицы filtered_value будут такими же, как source_value. Единицы time_passed и time_constant должны быть одинаковыми, будь то секунды, микросекунды или миг. Кроме того, time_passed всегда должно быть значительно меньше time_constant, иначе поведение фильтра станет недетерминированным. Есть несколько способов получить time_passed, например Stopwatch, см. Как подсчитать, сколько времени прошло?

Прежде чем использовать функцию фильтра, вам нужно будет инициализировать filtered_value и все, что вы используете для получения time_passed. В этом примере я буду использовать stopwatch.

var stopwatch = new System.Diagnostics.Stopwatch();
double filtered_value, filtered_dot_value;
...
filtered_value = source_value;
filtered_dot_value = 0.0;
stopwatch.Start();

Чтобы использовать эту функцию для фильтра первого порядка, вы должны зациклить следующее, используя таймер или что-то подобное.

double time_passed = stopwatch.ElapsedMilliseconds;
stopwatch.Restart();
Exp_Filt(ref filtered_value, source_value, time_passed, time_constant);

Чтобы использовать эту функцию для фильтра второго порядка, вы должны зациклить следующее, используя таймер или что-то подобное.

double time_passed = stopwatch.ElapsedMilliseconds;
stopwatch.Restart();
if (time_passed > 0.0)
{
    double last_value = filtered_value;
    filtered_value += filtered_dot_value * time_passed;
    Exp_Filt(ref filtered_value, source_value, time_passed, time_constant);
    Exp_Filt(ref filtered_dot_value, (filtered_value - last_value) / time_passed, time_passed, dot_time_constant);
}

Фильтр второго порядка работает, принимая во внимание первую производную отфильтрованного значения первого порядка. Также я бы рекомендовал сделать time_constant < dot_time_constant - для начала я бы поставил dot_time_constant = 2 * time_constant

Лично я бы назвал этот фильтр в фоновом потоке, управляемом потоковый таймер, и имел time_passed константу, равную периоду таймера, но я оставлю особенности реализации на ваше усмотрение.

Обновлено:

Ниже приведен пример класса для создания фильтров первого и второго порядка. Для работы фильтра я использую таймер потоковой обработки, настроенный на обработку каждые 100 миллисекунд. Поскольку этот таймер довольно последователен, делая time_passed постоянным, я оптимизировал уравнение фильтра, предварительно вычислив Math.Exp(-time_passed / time_constant) и не деля/умножая «точечный» член на time_passed.

Для фильтра первого порядка используйте var filter = new ExpFilter(initial_value, time_constant). Для фильтра второго порядка используйте var filter = new ExpFilter(initial_value, time_constant, dot_time_constant). Затем, чтобы прочитать последнее отфильтрованное значение, вызовите double value = filter.Value. Чтобы установить значение для фильтрации, вызовите filter.Value = value.

    public class ExpFilter : IDisposable
    {
        private double _input, _output, _dot;
        private readonly double _tc, _tc_dot;
        private System.Threading.Timer _timer;

        /// <summary>
        /// Initializes first-order filter
        /// </summary>
        /// <param name = "value">initial value of filter</param>
        /// <param name = "time_constant">time constant of filter, in seconds</param>
        /// <exception cref = "ArgumentOutOfRangeException"><paramref name = "time_constant"/> must be positive</exception>
        public ExpFilter(double value, double time_constant)
        {
            // time constant must be positive
            if (time_constant <= 0.0) throw new ArgumentOutOfRangeException(nameof(time_constant));

            // initialize filter
            _output = _input = value;
            _dot = 0.0;

            // calculate gain from time constant
            _tc = CalcTC(time_constant);

            // disable second-order
            _tc_dot = -1.0;

            // start filter timer
            StartTimer();
        }

        /// <summary>
        /// Initializes second-order filter
        /// </summary>
        /// <param name = "value">initial value of filter</param>
        /// <param name = "time_constant">time constant of primary filter, in seconds</param>
        /// <param name = "dot_time_constant">time constant of secondary filter, in seconds</param>
        /// <exception cref = "ArgumentOutOfRangeException"><paramref name = "time_constant"/> and <paramref name = "dot_time_constant"/> must be positive</exception>
        public ExpFilter(double value, double time_constant, double dot_time_constant)
        {
            // time constant must be positive
            if (time_constant <= 0.0) throw new ArgumentOutOfRangeException(nameof(time_constant));
            if (dot_time_constant <= 0.0) throw new ArgumentOutOfRangeException(nameof(dot_time_constant));

            // initialize filter
            _output = _input = value;
            _dot = 0.0;

            // calculate gains from time constants
            _tc = CalcTC(time_constant);
            _tc_dot = CalcTC(dot_time_constant);

            // start filter timer
            StartTimer();
        }

        // the following two functions must share the same time period
        private double CalcTC(double time_constant)
        {
            // time period = 0.1 s (100 ms)
            return Math.Exp(-0.1 / time_constant);
        }
        private void StartTimer()
        {
            // time period = 100 ms
            _timer = new System.Threading.Timer(Filter_Timer, this, 100, 100);
        }

        ~ExpFilter()
        {
            Dispose(false);
        }
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                _timer.Dispose();
            }
        }

        /// <summary>
        /// Get/Set filter value
        /// </summary>
        public double Value
        {
            get => _output;
            set => _input = value;
        }

        private static void Filter_Timer(object stateInfo)
        {
            var _filter = (ExpFilter)stateInfo;

            // get values
            double _input = _filter._input;
            double _output = _filter._output;
            double _dot = _filter._dot;

            // if second-order, adjust _output (no change if first-order as _dot = 0)
            // then use filter function to calculate new filter value
            _input += (_output + _dot - _input) * _filter._tc;
            _filter._output = _input;

            if (_filter._tc_dot >= 0.0)
            {
                // calculate second-order portion of filter
                _output = _input - _output;
                _output += (_dot - _output) * _filter._tc_dot;
                _filter._dot = _output;
            }
        }
    }