为什么这个 LinqPad 程序在第二次运行时会产生不同的结果？

Question

我正在 LinqPad 中开发一个简单的 PID 控制器：

PID 类

class PidController
{
    public float Proportional { get; set; }
    public float Integral { get; set; }
    public float Derivative { get; set; }
    public float SetPoint { get; set; }
    public float Kp { get; set; }
    public float Ki { get; set; }
    public float Kd { get; set; }

    float _lastError;
    DateTime _lastTime = DateTime.Now;

    public PidController(float kp, float ki, float kd)
    {
        Kp = kp; Ki = ki; Kd = kd;
    }

    public float GetControlValue(float actual)
    {
        var currentTime = DateTime.Now;
        var deltaTime = (float)(currentTime - _lastTime).TotalSeconds;
        var error = SetPoint - actual;

        Proportional = error;
        Integral = Integral + error * deltaTime;
        Derivative = (error - _lastError) / deltaTime;

        _lastError = error;

        return Kp * Proportional + Ki * Integral + Kd * Derivative;
    }
}

为了测试和调整，控制器将控制这个简单的过程：

受控过程

class SimpleProcess
{
    private DateTime _lastTime = DateTime.Now;
    private float _output;

    public float Output { get { UpdateOutput(); return _output; }}
    public float Input { get; set; }

    private void UpdateOutput()
    {
        var deltaTime = (float)(DateTime.Now - _lastTime).TotalSeconds;
        _output += Input * deltaTime;
    }
}

...使用这个主循环：

主程序循环

void Main()
{
    var pid = new PidController(1f, 0f, 0f) { SetPoint = 100f };
    var proc = new SimpleProcess();

    // pid.Dump();
    // proc.Dump();

    var values = new List<ProcessValue>();

    for (int i = 0; i < 50; i++)
    {
        var actual = proc.Output;
        var controlValue = pid.GetControlValue(actual);
        proc.Input = controlValue;

        var value = new ProcessValue
        {
            index = i,
            timestamp = DateTime.Now.ToString("ss.fff"),
            p = pid.Proportional,
            i = pid.Integral,
            d = pid.Derivative,
            input = controlValue,
            output = actual
        };

        values.Add(value);

        Thread.Sleep(100);
    }

    values.Dump();
}

public class ProcessValue
{
    public int index;
    public string timestamp;
    public float p, i, d, input, output;
}

第一次运行时一切都按预期工作：

index  timestamp  p      i       d         input output
0      53.309     100    0.46    21490.59  100   0 
1      53.411     89.69  10.06  -96.27     89.69 10.30 
etc...

但是，在我注释掉proc.Dump()行后，我开始在第二次和后续运行中得到意想不到的结果：

index  timestamp  p    i    d    input  output 
0      10.199     100  0    ∞    NaN    0 
1      10.299     NaN  NaN  NaN  NaN    NaN 
2      10.399     NaN  NaN  NaN  NaN    NaN 
etc...

为什么第二次运行（和后续运行）在我的情况下返回不同的结果？

以下任何操作都将导致下一次运行成功：

• 修改代码（甚至只是添加/删除一个空格）
• 按 [CTRL]+[SHIFT]+[F5]

以下使代码每次都能正确运行：

• 取消注释行proc.Dump()

这个答案提到静态变量将在运行之间缓存，但我没有静态变量。 我怀疑问题是关系到LinqPad应用程序域缓存功能，但我想知道为什么我受此影响。

更新

StriplingWarrior 的回答是正确的，我的一阶导数计算在系统运行良好时（即在 LinqPad 缓存第一次运行之后）导致 Infinity，导致所有后续计算失败。 以任何方式修改我的程序都会使这个缓存失效，并导致 deltaTime 足够大，以避免在下次运行时再次出现错误。

由于导数项在第一个区间没有意义，我决定通过简单地忽略它来处理这个问题：

var p = Kp * Proportional;
var i = Ki * Integral;
var d = float.IsInfinity(Derivative) ? 0 : Kd * Derivative;

return p + i + d;

Answer 1

您可以通过更改 main 方法的第一部分来测试 Andrew 在上面的评论中的理论化：

var sw = new Stopwatch();
sw.Start();
var pid = new PidController(1f, 0f, 0f) { SetPoint = 100f };
var proc = new SimpleProcess();

// pid.Dump();
// proc.Dump();

var values = new List<ProcessValue>();

for (int i = 0; i < 50; i++)
{
    var actual = proc.Output;
    var controlValue = pid.GetControlValue(actual);
    if(sw.IsRunning){
        sw.Stop();
        sw.ElapsedTicks.Dump();
    }

在我的机器上运行，我可以看到第一次运行需要 10,000+ 滴答，而第二次运行只需要 20 滴答。 我猜这会使您根据 DateTime.Now 的差异进行计算。现在的增量值非常小，并产生您所看到的差异。