Boiling Sous-Vide Eggs Using Clojure's Transducers (blog.eikeland.se)

From the picture it looks to me like egg is undercooked i.e. the white is still runny and kind of mucousy, ideally you want a solid tender white and a totally separate uncooked yolk. A slightly higher temperature (67 deg C) would ensure the white properly solidifies whilst still being cool enough to avoid cooking the yolk. 45 minutes is unnecessarily long a long as he egg remains under 70 degrees not much will be happening chemically once it's warmed through.

For temperature control, you probably want to use a PI controller with Anti-windup. This will compensate for the limits on actuator (heating element) output, and prevent large overshoots from "windup" of the Integral element.

http://jagger.berkeley.edu/~pack/me132/Section15.pdf

This is a really cool toy example of one of my favorite algorithms. For an algorithm that predates the transistor, I'm constantly blown away at its modern use cases. For example, dynamic pricing, used everywhere from airline tickets to parking meters, is nothing more than a variant of the pid algorithm.

It is also used quite a bit in capacity allocation in a wide variety of industries. Instead of using NP Complete scheduling and discrete optimization that might not terminate, you take a page out of Hayek and use the PID algorithm to set a price on the capacity of each independent asset. Then, scheduling and allocation often becomes a matter of convex linear optimization.

In terms of practical use, I have zero doubt in my mind that the PID algorithm accounts for more economic impact than Page Rank or many other HN-popular algorithms. Just adding up the value of applications that I personally know about, it saves its users > $10B/year. I would wager that the only algorithm that surpasses its economic impact would be Simplex.

It is also incredibly extensible. I've seen variants where the integral term is swapped out with fourier transforms, or the derivative term is swapped out with ARIMAs or Hierarchical Forecasting algorithms or Neural Networks. You can hack the shit out of it, tailoring it to even the most obscure use cases if you wanted to. Like, for example, cooking an egg.

  (defn pid-transducer [set-point k-p k-i k-d]
    (fn [xf]
      (let [pid (volatile! (make-pid set-point k-d k-i k-d))]
        (fn
          ([] (xf))
          ([result] (xf result))
          ([result input]
             (vswap! pid (fn [p] (calculate-pid p input)))
             (xf result (:output @pid)))))))

If guessing that the first 'k-d' on the third line should be a 'k-p'. I'm glad this bug didn't mess up your eggs!

  $ lein eastwood '{:linters [:unused-fn-args]}'
  == Eastwood 0.1.4 Clojure 1.7.0-alpha2 JVM 1.8.0_05
  == Linting pid.core ==
  {:linter :unused-fn-args,
   :msg
   "Function args [k-p (line 32, column 33)] of (or within) pid-transducer are never used",
   :file "pid/core.clj",
   :line 32,
   :column 1}

wrt

    (def pid-output (chan (pid-transducer 65 0.1 0.02 0.01)))

Unless something has changed with core async I believe you need to provide a buffer if you are going to use a transducer.

From the current doc: "If a transducer is supplied a buffer must be specified."

I built a sous-vide rig with an Arduino[1] last year. The first recipe I made was deep fried sous-vide egg yolks[2].

[1] https://learn.adafruit.com/sous-vide-powered-by-arduino-the-... [2] http://seattlefoodgeek.com/2010/09/deep-fried-sous-vide-egg-...

Out of interest, why are you using a record for the PID, and not a map?

    (defalias Pid
      (HMap
       :complete? true
       :mandatory {:set-point Num
                   :k-p Num
                   :k-i Num
                   :k-d Num
                   :error-sum Num
                   :error-last Num
                   :output-max Num
                   :output Num}))

    (ann calculate-pid [Pid Num -> Pid])