device_control 0.2.0.2 → 0.3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c076f6bf87773d4901c6e3d1f7e8455b130d9baacd3ac2310dcb114ef69430cc
-  data.tar.gz: f01f70616a8bf5da7038e595321ad443f71130ba221ff5a3a9bae9458a1a9f51
+  metadata.gz: af9b824c6799b18921c32a5aaaff2438f2552fff2b4d6bb3c72300da0867fb7e
+  data.tar.gz: cffbe03e20d0b3e9bc513d35eba821f8a11b6ea973cf5ea09b4e76eee9ad9b0e
 SHA512:
-  metadata.gz: 63b908be961a7ec43f8d1cd4df3baef1cb649e56356dc3f166e3cfc48ad814183f10cac65b44cee6bba91a7d5d8b0860f7ace50ce0c2bb41bc90f50d163ee453
-  data.tar.gz: e4bcd7948c9916692616bf7fd938bec2681f4d40326a626c2dda556c08eb3a7e6ccaaa62aa825e55a27fd61127c9be34fa7adad43326dabd5f9a26a8aa78ce8f
+  metadata.gz: cf33d6d28e0ae5d2ccfa955ca84305d526e127ba9b4d82c6573b203757f0e2a4996bbf057d8b070853f06b827a71970587d2574fa3d7c17c0f087a2fb9c2ca5f
+  data.tar.gz: 399e0470a633162355183d6a79c76ba368d7f236f4540d4e6c32c953b4f5abc4e7b85e371f2994abf4d58a08b4a8aba4db388cacae3fc141d174455d0488a4c6

data/README.md

@@ -205,7 +205,8 @@ end
 ```
 
 A Controller names its input `measure`, and it introduces a `setpoint`, and
-the difference between setpoint and measure is the error.
+the difference between setpoint and measure is the error. For now, just output
+the error.
 
 #### Thermostat
 
@@ -219,11 +220,10 @@ class Thermostat < Controller
 end
 ```
 
-Notice, the thermostat essentially answers the question: *is it hot enough?*
-(or: *is it too cold?*).  You can run it either or both ways, but notice that
-you can simply pick one orientation and remain logically consistent.
-
-Now consider:
+Notice, this thermostat essentially answers the question: *is it hot enough?*
+(or equivalently: *is it too cold?*).  You can run it either or both ways,
+but note that you can simply pick one orientation and remain logically
+consistent; consider:
 
 ```ruby
 
@@ -248,9 +248,45 @@ temp = 24.9
 So the **heat knob** goes to 1 when its thermostat goes *below* setpoint.
 The **cool knob** goes to 1 when its thermostat goes *above* setpoint.
 
+#### Flexstat
+
+If we really need a flexible thermostat in terms of output values, consider:
+
+```ruby
+class Flexstat < Thermostat
+  def self.cold_val(hot_val)
+    case hot_val
+    when true, false
+      !hot_val
+    when 0,1
+      hot_val == 0 ? 1 : 0
+    when Numeric
+      0
+    when :on, :off
+      hot_val == :on ? :off : :on
+    else
+      raise "#{hot_val.inspect} not recognized"
+    end
+  end
+
+  attr_reader :cold_val, :hot_val
+
+  def initialize(setpoint, hot_val: false, cold_val: nil)
+    super(setpoint)
+
+    @hot_val = hot_val
+    @cold_val = cold_val.nil? ? self.class.cold_val(hot_val) : cold_val
+  end
+
+  def output
+    super ? @cold_val : @hot_val
+  end
+end
+```
+
 # Finale
 
 If you've made it this far, congratulations!  For further reading:
 
-* [lib/device_control.rb](lib/device_control.rb#L155)
+* [lib/device_control.rb](lib/device_control.rb#L165)
 * [test/device_control.rb](test/device_control.rb)

data/VERSION

@@ -1 +1 @@
-0.2.0.2
+0.3.0.1

data/lib/device_control.rb

@@ -113,6 +113,18 @@ module DeviceControl
     end
   end
 
+  # now consider e.g.
+  # h = Heater.new(1000)
+  # ht = Thermostat.new(20)
+  # c = Cooler.new(1000)
+  # ct = Thermostat.new(25)
+  # temp = 26.4
+  # heat_knob = ht.update(temp) ? 1 : 0
+  # heating_watts = h.update(heat_knob)
+  # cool_knob = ct.update(temp) ? 0 : 1
+  # cooling_watts = c.update(cool_knob)
+  # etc
+
   class Flexstat < Thermostat
     def self.cold_val(hot_val)
       case hot_val
@@ -129,7 +141,11 @@ module DeviceControl
       end
     end
 
-    def initalize(hot_val: false, cold_val: nil)
+    attr_reader :cold_val, :hot_val
+
+    def initialize(setpoint, hot_val: false, cold_val: nil)
+      super(setpoint)
+
       @hot_val = hot_val
       @cold_val = cold_val.nil? ? self.class.cold_val(hot_val) : cold_val
     end
@@ -139,60 +155,17 @@ module DeviceControl
     end
   end
 
-  # now consider e.g.
-  # h = Heater.new(1000)
-  # ht = Thermostat.new(20)
-  # c = Cooler.new(1000)
-  # ct = Thermostat.new(25)
-  # temp = 26.4
-  # heat_knob = ht.update(temp) ? 1 : 0
-  # heating_watts = h.update(heat_knob)
-  # cool_knob = ct.update(temp) ? 0 : 1
-  # cooling_watts = c.update(cool_knob)
-  # etc
-
-  # A StatefulController tracks its error over time: current, last, accumulated
+  # A PIDController is a Controller that tracks its error over time
+  # in order to calculate:
+  #   Proportion (current error)
+  #   Integral   (accumulated error)
+  #   Derivative (error slope, last_error)
+  # The sum of these terms is the output
   #
-  class StatefulController < Controller
+  class PIDController < Controller
     HZ = 1000
     TICK = Rational(1) / HZ
 
-    attr_accessor :dt
-    attr_reader :error, :last_error, :sum_error
-
-    def initialize(setpoint, dt: TICK)
-      super(setpoint)
-      @dt = dt
-      @error, @last_error, @sum_error = 0.0, 0.0, 0.0
-    end
-
-    # update @error, @last_error, and @sum_error
-    def input=(val)
-      @measure = val
-      @last_error = @error
-      @error = @setpoint - @measure
-      if @error * @last_error <= 0  # zero crossing; reset the accumulated error
-        @sum_error = @error * @dt
-      else
-        @sum_error += @error * @dt
-      end
-    end
-
-    def to_s
-      [super,
-       format("Error: %+.3f\tLast: %+.3f\tSum: %+.3f",
-              @error, @last_error, @sum_error),
-      ].join("\n")
-    end
-  end
-
-  # A PIDController is a StatefulController that calculates
-  # * Proportion (current error)
-  # * Integral   (accumulated error)
-  # * Derivative (error slope, last_error)
-  # The sum of these terms is the output
-  #
-  class PIDController < StatefulController
     # Ziegler-Nichols method for tuning PID gain knobs
     # https://en.wikipedia.org/wiki/Ziegler%E2%80%93Nichols_method
     ZN = {
@@ -222,10 +195,21 @@ module DeviceControl
       { kp: kp, ti: ti, td: td, ki: ki, kd: kd }
     end
 
-    attr_accessor :kp, :ki, :kd, :p_range, :i_range, :d_range, :o_range
+    attr_accessor :dt, :low_pass_ticks,
+                  :error, :last_error, :sum_error,
+                  :kp, :ki, :kd,
+                  :p_range, :i_range, :d_range, :o_range, :e_range
+    attr_reader :mavg
 
-    def initialize(setpoint, dt: TICK)
-      super
+    def initialize(setpoint, dt: TICK, low_pass_ticks: 0)
+      super(setpoint)
+      @dt = dt
+      @error, @last_error, @sum_error = 0.0, 0.0, 0.0
+      if low_pass_ticks > 0
+        @mavg = MovingAverage.new(low_pass_ticks)
+      else
+        @mavg = nil
+      end
 
       # gain / multipliers for PID; tunables
       @kp, @ki, @kd = 1.0, 1.0, 1.0
@@ -235,22 +219,43 @@ module DeviceControl
       @i_range = (-Float::INFINITY..Float::INFINITY)
       @d_range = (-Float::INFINITY..Float::INFINITY)
       @o_range = (-Float::INFINITY..Float::INFINITY)
+      @e_range = (-Float::INFINITY..Float::INFINITY)
 
       yield self if block_given?
     end
 
+    # update @error, @last_error, and @sum_error
+    def input=(val)
+      @measure = val
+      @last_error = @error
+      @error = @setpoint - @measure
+      # Incorporate @ki here for better behavior when @ki is updated
+      # It's a good idea to clamp the accumulated error so that if we start
+      #   way under setpoint, we don't accumulate so much error that we spend
+      #   too much time overshooting to counteract it
+      @sum_error =
+        (@sum_error + @ki * @error * @dt).clamp(@e_range.begin, @e_range.end)
+      # update mavg here to ensure only one update per PID input
+      @mavg.input = self.derivative if @mavg
+    end
+
     def output
+      drv = @mavg ? @mavg.output : self.derivative
       (self.proportion +
        self.integral +
-       self.derivative).clamp(@o_range.begin, @o_range.end)
+       drv).clamp(@o_range.begin, @o_range.end)
     end
 
     def proportion
       (@kp * @error).clamp(@p_range.begin, @p_range.end)
     end
 
+    # It may seem funny to clamp both @sum_error and the integral term, but
+    #   we may want different values for these clamps.  @e_range is just to
+    #   make sure we don't create a mountain to chew through.  @i_range gives
+    #   additional flexibility for balancing P I & D
     def integral
-      (@ki * @sum_error).clamp(@i_range.begin, @i_range.end)
+      @sum_error.clamp(@i_range.begin, @i_range.end)
     end
 
     def derivative
@@ -259,6 +264,8 @@ module DeviceControl
 
     def to_s
       [super,
+       format("Error: %+.3f\tLast: %+.3f\tSum: %+.3f",
+              @error, @last_error, @sum_error),
        format(" Gain:\t%.3f\t%.3f\t%.3f",
               @kp, @ki, @kd),
        format("  PID:\t%+.3f\t%+.3f\t%+.3f\t= %.5f",
@@ -267,14 +274,40 @@ module DeviceControl
     end
   end
 
-  class Smoother
+  class MovingAverage
+    include Updateable
+
+    attr_reader :size, :idx, :storage
+
+    def initialize(size = 2)
+      @size = size
+      @idx = 0
+      @storage = Array.new(@size, 0)
+    end
+
+    # never grow @storage; just use modmath to track what to replace
+    def input=(val)
+      @storage[@idx % @size] = val
+      @idx += 1
+    end
+
+    def output
+      return 0 if @idx == 0
+      @storage.sum / (@idx > @size ? @size : @idx).to_f
+    end
+  end
+
+  class RateLimiter
     include Updateable
 
-    def initialize(max_step:)
+    attr_accessor :val
+
+    def initialize(max_step, val: 0)
       @max_step = max_step
-      @val = 0.0
+      @val = val
     end
 
+    # never allow @val to grow / shrink more than @max_step
     def input=(val)
       diff = val - @val
       @val += diff.clamp(-1 * @max_step, @max_step)

data/test/device_control.rb

@@ -20,12 +20,12 @@ class Doubler
 end
 
 describe Updateable do
-  describe "a mixin that provides the _update_ pattern" do
+  describe "a mixin that provides an 'update' pattern" do
     before do
       @o = Doubler.new
     end
 
-    it "has an _update_ method that accepts an _input_ and returns _output_" do
+    it "has an update method that accepts an input and returns output" do
       expect(@o.input).must_equal 0.0
       expect(@o.output).must_equal 0.0
 
@@ -34,7 +34,7 @@ describe Updateable do
       expect(@o.output).must_equal output
     end
 
-    it "requires an _output_ method" do
+    it "requires an output method" do
       k = Class.new(Object) do
         include Updateable
       end
@@ -49,7 +49,7 @@ describe Device do
     @device = Device.new
   end
 
-  it "has an _output_" do
+  it "has an output" do
     expect(@device.output).must_be_kind_of Float
   end
 
@@ -57,7 +57,7 @@ describe Device do
     expect(@device.to_s).must_be_kind_of String
   end
 
-  it "has an _update_ method from Updateable" do
+  it "has an update method from Updateable" do
     expect(@device.update(2.34)).must_be_kind_of Float
   end
 end
@@ -67,7 +67,7 @@ describe Heater do
     @h = Heater.new(1000)
   end
 
-  it "has an _output_ when _knob_ is greater than zero" do
+  it "has an output when knob is greater than zero" do
     expect(@h.knob).must_equal 0
     expect(@h.output).must_equal 0
     @h.knob = 1
@@ -78,7 +78,7 @@ describe Heater do
     expect(@h.to_s).must_be_kind_of String
   end
 
-  it "has _update_ from Updateable" do
+  it "has update from Updateable" do
     expect(@h.knob).must_equal 0
     expect(@h.output).must_equal 0
     output = @h.update(1)
@@ -86,6 +86,17 @@ describe Heater do
     expect(@h.knob).must_equal 1
     expect(@h.output).must_equal output
   end
+
+  describe Cooler do
+    it "is less efficient than a Heater" do
+      h = Heater.new(1000)
+      c = Cooler.new(1000)
+      h.knob = 1
+      c.knob = 1
+      expect(c.output).must_be :<, h.output
+      expect(c.output).must_be :<, h.output / 2.0
+    end
+  end
 end
 
 describe Controller do
@@ -94,7 +105,7 @@ describe Controller do
     @c = Controller.new(@sp)
   end
 
-  it "has an _output_, the difference between setpoint and measure" do
+  it "has an output_, the difference between setpoint and measure" do
     expect(@c.output).must_be_kind_of Float
     expect(@c.output).must_equal @sp
   end
@@ -103,7 +114,7 @@ describe Controller do
     expect(@c.to_s).must_be_kind_of String
   end
 
-  it "has an _update_ method from Updateable" do
+  it "has an update method from Updateable" do
     expect(@c.update(499)).must_equal 1.0
   end
 end
@@ -122,38 +133,55 @@ describe Thermostat do
     expect(@t.update 30).must_equal false
     expect(@t.update 20).must_equal true
   end
-end
 
-describe StatefulController do
-  it "tracks error, last_error, sum_error" do
-    sc = StatefulController.new(100)
-    expect(sc.error).must_equal 0.0
-    expect(sc.last_error).must_equal 0.0
-    expect(sc.sum_error).must_equal 0.0
-
-    output = sc.update 50
-    expect(sc.output).must_equal output
-    expect(sc.measure).must_equal 50
-    expect(sc.error).must_be_within_epsilon 50.0
-    expect(sc.last_error).must_equal 0.0
-    expect(sc.sum_error).must_be_within_epsilon(50.0 * sc.dt)
-
-    output = sc.update 75
-    expect(sc.output).must_equal output
-    expect(sc.measure).must_equal 75
-    expect(sc.error).must_be_within_epsilon 25.0
-    expect(sc.last_error).must_be_within_epsilon 50.0
-    expect(sc.sum_error).must_be_within_epsilon(75.0 * sc.dt)
-  end
-
-  it "resets sum_error after crossing setpoint" do
-    sc = StatefulController.new(100)
-    sc.update 50
-    sc.update 75
-    expect(sc.sum_error).must_be_within_epsilon(75.0 * sc.dt)
-    sc.update 125
-    expect(sc.error).must_equal(-25.0)
-    expect(sc.sum_error).must_equal(sc.error * sc.dt)
+  describe Flexstat do
+    it "maps a hot_val to a suitable cold_val" do
+      expect(Flexstat.cold_val true).must_equal false
+      expect(Flexstat.cold_val false).must_equal true
+      expect(Flexstat.cold_val 0).must_equal 1
+      expect(Flexstat.cold_val 1).must_equal 0
+      expect(Flexstat.cold_val 2).must_equal 0
+      expect(Flexstat.cold_val 99.876).must_equal 0
+      expect(Flexstat.cold_val :on).must_equal :off
+      expect(Flexstat.cold_val :off).must_equal :on
+
+      expect { Flexstat.cold_val 'on' }.must_raise
+      expect { Flexstat.cold_val :anything_else }.must_raise
+    end
+
+    it "has configurable hot/cold values for its output" do
+      f = Flexstat.new(25, hot_val: :on, cold_val: :off)
+      expect(f).must_be_kind_of Flexstat
+      expect(f.hot_val).must_equal :on
+      expect(f.cold_val).must_equal :off
+      expect(f.update 20).must_equal :off
+
+      f = Flexstat.new(25, hot_val: :on)
+      expect(f).must_be_kind_of Flexstat
+      expect(f.hot_val).must_equal :on
+      expect(f.cold_val).must_equal :off
+      expect(f.update 30).must_equal :on
+
+      f = Flexstat.new(25)
+      expect(f).must_be_kind_of Flexstat
+      expect(f.hot_val).must_equal false # default, subject to change
+      expect(f.cold_val).must_equal true # likewise
+      expect(f.cold_val).must_equal Flexstat.cold_val(f.hot_val)
+      expect(f.update 30).must_equal f.hot_val
+
+      f = Flexstat.new(25, hot_val: 7, cold_val: 19)
+      expect(f).must_be_kind_of Flexstat
+      expect(f.hot_val).must_equal 7
+      expect(f.cold_val).must_equal 19
+      expect(f.update 20).must_equal 19
+
+      f = Flexstat.new(25, hot_val: 7)
+      expect(f).must_be_kind_of Flexstat
+      expect(f.hot_val).must_equal 7
+      expect(f.cold_val).must_equal Flexstat.cold_val(f.hot_val)
+      expect(f.cold_val).must_equal 0
+      expect(f.update 30).must_equal 7
+    end
   end
 end
 
@@ -182,13 +210,34 @@ describe PIDController do
     expect(hsh[:td]).must_be :>, 0
   end
 
-  it "has an optional _dt_ argument to initialize" do
+  it "has an optional dt argument to initialize" do
     pid = PIDController.new(1000, dt: 0.1)
     expect(pid).must_be_kind_of PIDController
     expect(pid.setpoint).must_equal 1000
     expect(pid.dt).must_equal 0.1
   end
 
+  it "tracks error, last_error, sum_error" do
+    pid = PIDController.new(100)
+    expect(pid.error).must_equal 0.0
+    expect(pid.last_error).must_equal 0.0
+    expect(pid.sum_error).must_equal 0.0
+
+    output = pid.update 50
+    expect(pid.output).must_equal output
+    expect(pid.measure).must_equal 50
+    expect(pid.error).must_be_within_epsilon 50.0
+    expect(pid.last_error).must_equal 0.0
+    expect(pid.sum_error).must_be_within_epsilon(50.0 * pid.dt)
+
+    output = pid.update 75
+    expect(pid.output).must_equal output
+    expect(pid.measure).must_equal 75
+    expect(pid.error).must_be_within_epsilon 25.0
+    expect(pid.last_error).must_be_within_epsilon 50.0
+    expect(pid.sum_error).must_be_within_epsilon(75.0 * pid.dt)
+  end
+
   it "has PID gain settings" do
     pid = PIDController.new(1000)
     expect(pid.kp).must_be :>, 0
@@ -200,7 +249,7 @@ describe PIDController do
     expect(pid.kd).must_equal 1000
   end
 
-  it "clamps the _proportion_ term" do
+  it "clamps the proportion term" do
     pid = PIDController.new(1000)
     pid.p_range = (0..1)
     pid.update(500)
@@ -209,7 +258,7 @@ describe PIDController do
     expect(pid.proportion).must_equal 0.0
   end
 
-  it "clamps the _integral_ term" do
+  it "clamps the integral term" do
     pid = PIDController.new(1000)
     pid.i_range = (-1.0 .. 1.0)
     pid.setpoint = 10_000
@@ -217,10 +266,11 @@ describe PIDController do
     expect(pid.integral).must_equal 1.0
     pid.update(10_001)
     pid.update(20_000)
+    pid.update(30_000)
     expect(pid.integral).must_equal(-1.0)
   end
 
-  it "clamps the _derivative_ term" do
+  it "clamps the derivative term" do
     pid = PIDController.new(1000)
     pid.d_range = (-1.0 .. 0.0)
     pid.update(0)
@@ -233,7 +283,7 @@ describe PIDController do
     expect(pid.derivative).must_equal(0.0)
   end
 
-  it "clamps the _output_" do
+  it "clamps the output" do
     pid = PIDController.new(1000)
     pid.o_range = (0.0 .. 1.0)
     pid.update(0)
@@ -242,7 +292,20 @@ describe PIDController do
     expect(pid.output).must_equal(0.0)
   end
 
-  it "calculates _proportion_ based on current error" do
+  it "clamps sum_error" do
+    pid = PIDController.new(1000)
+    pid.e_range = 999..1000
+
+    pid.update(500)
+    expect(pid.error).must_equal 500
+    expect(pid.sum_error).must_equal 999
+    pid.update(1000)
+    expect(pid.sum_error).must_equal 999
+    pid.update(-1000)
+    expect(pid.sum_error).must_equal 1000
+  end
+
+  it "calculates proportion based on current error" do
     pid = PIDController.new(1000)
     pid.kp = 1.0
     pid.update(0)
@@ -253,33 +316,130 @@ describe PIDController do
     expect(pid.proportion).must_equal(-1.0)
   end
 
-  it "calculates _integral_ based on accumulated error" do
+  it "calculates integral based on accumulated error" do
     pid = PIDController.new(1000)
     pid.ki = 1.0
-    pid.update(0)
-    # sum error should be 1000; dt is 0.001
+
+    pid.update(0) # error is 1000; dt is 0.001
     expect(pid.integral).must_equal(1.0)
-    pid.update(999)
+
+    pid.update(999) # error is 1, sum_error is 1.001
     expect(pid.integral).must_be_within_epsilon(1.001)
-    pid.update(1100) # zero crossing
-    expect(pid.integral).must_be_within_epsilon(-0.1)
+
+    pid.update(1100) # error is -100, sum_error is 0.901
+    expect(pid.integral).must_be_within_epsilon(0.901)
   end
 
-  it "calculates _derivative_ based on error slope" do
+  it "calculates derivative based on error slope" do
     pid = PIDController.new(1000)
     pid.kp = 1.0
     pid.update(0)
-    # error should be 1000; last_error 0
-    expect(pid.derivative).must_equal(1_000_000)
+    expect(pid.error).must_equal 1000
+    expect(pid.last_error).must_equal 0
+    expect(pid.derivative).must_be_within_epsilon(1000 / pid.dt)
+
     pid.update(500)
-    expect(pid.derivative).must_equal(-500_000)
+    expect(pid.error).must_equal 500
+    expect(pid.last_error).must_equal 1000
+    expect(pid.derivative).must_be_within_epsilon(-500 / pid.dt)
+
+    pid.update(999)
+    expect(pid.error).must_equal 1
+    expect(pid.last_error).must_equal 500
+    expect(pid.derivative).must_be_within_epsilon(-499 / pid.dt)
+
+    pid.update(1001)
+    expect(pid.error).must_equal(-1)
+    expect(pid.last_error).must_equal(1)
+    expect(pid.derivative).must_be_within_epsilon(-2 / pid.dt)
+
+    pid.update(1100)
+    expect(pid.error).must_equal(-100)
+    expect(pid.last_error).must_equal(-1)
+    expect(pid.derivative).must_be_within_epsilon(-99 / pid.dt)
+
+    pid.update(900)
+    expect(pid.error).must_equal(100)
+    expect(pid.last_error).must_equal(-100)
+    expect(pid.derivative).must_be_within_epsilon(200 / pid.dt)
+  end
+
+  it "has an optional LPF on the derivative term at output" do
+    pid = PIDController.new(1000, low_pass_ticks: 2)
+    pid.kp = 1.0
+
+    pid.update(0) # error should be 1000; last_error 0 (1000)
+    expect(pid.error).must_be_within_epsilon(1000)
+    expect(pid.last_error).must_equal 0
+    expect(pid.derivative).must_be_within_epsilon(1000 / pid.dt)
+
+    pid.update(500) # error 500, last_error 1000 (-500)
+    expect(pid.error).must_equal 500
+    expect(pid.last_error).must_equal 1000
+    expect(pid.derivative).must_be_within_epsilon(-500 / pid.dt)
+
     pid.update(999)
-    expect(pid.derivative).must_equal(-499_000)
+    expect(pid.error).must_equal 1
+    expect(pid.last_error).must_equal 500
+    expect(pid.derivative).must_be_within_epsilon(-499 / pid.dt)
+
     pid.update(1001)
-    expect(pid.derivative).must_equal(-2000)
+    expect(pid.error).must_equal(-1)
+    expect(pid.last_error).must_equal(1)
+    expect(pid.derivative).must_be_within_epsilon(-2 / pid.dt)
+
     pid.update(1100)
-    expect(pid.derivative).must_equal(-99_000)
+    expect(pid.error).must_equal(-100)
+    expect(pid.last_error).must_equal(-1)
+    expect(pid.derivative).must_be_within_epsilon(-99 / pid.dt)
+
     pid.update(900)
-    expect(pid.derivative).must_equal(200_000)
+    expect(pid.error).must_equal(100)
+    expect(pid.last_error).must_equal(-100)
+    expect(pid.derivative).must_be_within_epsilon(200 / pid.dt)
+  end
+
+  describe MovingAverage do
+    it "has a configurable number of items to consider for the average" do
+      mavg = MovingAverage.new(5)
+      expect(mavg.output).must_equal 0
+      expect(mavg.update 10).must_equal 10
+      expect(mavg.update 20).must_equal 15
+      expect(mavg.update 30).must_equal 20
+      expect(mavg.update 20).must_equal 20
+      expect(mavg.update 20).must_equal 20
+
+      # 10 is about to drop; replace it to maintain 20
+      expect(mavg.update 10).must_equal 20
+
+      # 20 is about to drop; replace it
+      expect(mavg.update 20).must_equal 20
+
+      # 30 is about to drop; replace it
+      expect(mavg.update 30).must_equal 20
+
+      # 20 is about to drop; replace with 0
+      expect(mavg.update 0).must_equal 16
+    end
+  end
+
+  describe RateLimiter do
+    it "has a configurable step size per tick" do
+      rl = RateLimiter.new(10)
+
+      expect(rl.update 5).must_equal 5
+      expect(rl.update 15).must_equal 15
+
+      # now at 15, attempt 30; limited to 25
+      expect(rl.update 30).must_equal 25
+
+      # now at 25, attempt 0; limited to 15
+      expect(rl.update 0).must_equal 15
+
+      rl = RateLimiter.new(0.1)
+      expect(rl.output).must_equal 0
+      expect(rl.update 5).must_be_within_epsilon 0.1
+      expect(rl.update 15).must_be_within_epsilon 0.2
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: device_control
 version: !ruby/object:Gem::Version
-  version: 0.2.0.2
+  version: 0.3.0.1
 platform: ruby
 authors:
 - Rick Hull