BikeFitXF.cs

using UnityEngine;
using System.Runtime.InteropServices;
using System.Collections;
using System.Collections.Generic;
using System;

public class BikeFitXF : Device
{   
    [DllImport("FitXF")]
    static extern bool FitXF_GetPedalCadence(ref double pedalCadence);

    float _cadence;
    float _timeBetweenSamples;
    LinkedList<float> _cadenceSmoothingWindow = new LinkedList<float>();

    // Config Vars
    float _slope = 1;
    float _yIntercept = 0;
    bool _useSmoothCadence = false;
    float _samplesPerSecond = 10;
    int _smoothingWindowSize = 10;

    void OnEnable()
    {
        UJeli configOptions;
        GameClient.Instance.Config.Devices.Options.TryGetValue(name, out configOptions);

        _slope = configOptions["slope"].FloatValue;
        _yIntercept = configOptions["y_intercept"].FloatValue;
        _timeBetweenSamples = 1 / configOptions["samples_per_second"].FloatValue;
        _smoothingWindowSize = configOptions["smoothing_window_size"].IntValue;
        _useSmoothCadence = configOptions["use_smooth_cadence"].BoolValue;

        if (_useSmoothCadence)
            StartCoroutine(SmoothCadenceAsync());
        else
            StartCoroutine(RoughCadenceAsync());
    }

    public override UJeli GetDeviceSaveOptions()
    {
        UJeli jeli = new UJeli();

        jeli.AddChild("slope", _slope);
        jeli.AddChild("y_intercept", _yIntercept);
        jeli.AddChild("use_smooth_cadence", _useSmoothCadence);
        jeli.AddChild("samples_per_second", _samplesPerSecond);
        jeli.AddChild("smoothing_window_size", _smoothingWindowSize);

        return jeli;
    }
    
    IEnumerator RoughCadenceAsync()
    {
        while (true)
        {
            double pedalCadence = 0;
            FitXF_GetPedalCadence(ref pedalCadence);

            if (pedalCadence < 5.0)
                Controls.InjectSmoothCadence(0);
            else
            {
                _cadence = (int)(pedalCadence * _slope + _yIntercept);

                Controls.InjectSmoothCadence(_cadence);
            }
            yield return new WaitForSeconds(_timeBetweenSamples);
        }
    }

    IEnumerator SmoothCadenceAsync()
    {
        while (true)
        {
            double pedalCadence = 0;
            FitXF_GetPedalCadence(ref pedalCadence);

            _cadence = (float)pedalCadence * _slope + _yIntercept;

            if (pedalCadence < 5.0)
                _cadenceSmoothingWindow.AddFirst(0);
            else
                _cadenceSmoothingWindow.AddFirst(_cadence);

            if (_cadenceSmoothingWindow.Count > _smoothingWindowSize)
                _cadenceSmoothingWindow.RemoveLast();

            _cadence = AverageValueInLinkedList(_cadenceSmoothingWindow);

            Controls.InjectSmoothCadence(_cadence);

            yield return new WaitForSeconds(_timeBetweenSamples);
        }
    }

    public float AverageValueInLinkedList(LinkedList<float> list)
    {
        LinkedListNode<float> node = list.First;

        float total = node.Value;
        int count = 1;

        while (node.Next != null)
        {
            node = node.Next;
            total += node.Value;
            count++;
        }

        return total / count;
    }
}