Dough133 Control: Yeast Welfare through Applied Mathematics

Introduction  

Like most living things, sourdough yeast is happiest at certain temperatures. For consistent bread, sourdough yeast wants to be somewhere between 21-30°C while proofing and fermenting. It is not a fan of the conditions in our New England kitchen during the winter, when we do most of our baking.

Dough133 is my solution: an intelligent heated enclosure built from a cooler and an ESP32. While the electronics provide the muscle, this post is about the brains of the system: how it decides exactly how much power to send to the heater to keep the enclosure just right.

The dough isn’t actually that picky. It can handle a range of temperatures. But it is boring to build a system that is only good enough. Instead, I built one that holds a target temperature to within a few hundredths of a degree. Driving a system to a precise state is the domain of Control Theory¹. While Dough133 is a simple system, it shows how applied mathematics can command the physical world.

The Physical System: Energy in Motion  

To control the temperature, we first have to understand how energy moves through the cooler.

Think of the energy like water flowing through a series of pipes:

1. The EBox pumps 12V power into the heater.
2. The controller regulates this power using Pulse Width Modulation (PWM)², flicking the heater on and off so fast that we achieve a precise average power level.
3. The heater coils turn that electricity into heat, and a fan forces that warmth into the air inside the cooler.
4. Finally, energy flows from the air into the dough (our goal), but it also leaks out through the cooler walls and into the kitchen (our loss).

We can’t sense the dough’s internal temperature directly without sticking a probe into it, but we can sense the enclosure air and the kitchen air. The dough eventually tracks the enclosure temperature.

The System Model: Simplifying Reality  

A perfect model would describe every atom in the cooler, but that is impractical. Instead, we use a “lumped model.” We assume that the temperature within each “lump” (like the air volume or the heater coils) is uniform, which lets us describe the entire system with just a few key numbers.

System Variables (What changes)  

System Constants (What stays the same)  

Think of thermal capacitance as a battery for heat; it tells us how much energy we need to dump into the cooler to raise its temperature by 1°C. Thermal resistance is the insulation; it tells us how hard it is for that energy to escape.

We can visualize the entire system like this:

Investigating the Cooler  

If we know how the cooler works, it is much easier to control it. I want to know exactly how much energy it takes to warm up and how well it holds onto heat.

Measuring Thermal Resistance ( $R_{ea}$ )  

The rate of heat loss through the walls is proportional to the temperature difference between the inside and outside. At steady state, when the temperature has stopped changing, the power we put in exactly matches the power leaking out.

I used a smart socket to measure the power. Dough133 required 20W of heater power to maintain 36.2°C in an 18.5°C kitchen.

This number tells us that for every 1°C we want to be above the kitchen temperature, we need about 1.14 Watts of continuous power.

Finding the Time Constant ( $\tau$ )  

What happens if we turn the heater off? The enclosure will cool down following an exponential decay. The speed of this decay depends on the “time constant” ( $\tau = R_{ea} C_e$ ). The greater the time constant, the better the insulation.

I performed an experiment: I heated the cooler and logged the temperature as it returned to room temperature.

The fit is excellent, and the results show a time constant of about 1540 seconds (25:40 minutes): the time for a 63% decay.

Since we already knew the thermal resistance ( $R_{ea}$ ), we can now find the thermal capacitance ( $C_e$ ):

This is much higher than the value for just air, which tells us that the inner walls of the cooler are absorbing and holding a lot of heat.

The Control Strategy: The Plan and the Correction  

Now that we have a model, we can build the controller. I chose the traditional two-part strategy: Feedforward³ (The Plan) and Feedback⁴ (The Correction).

1. Feedforward: Predictive Control  

The model tells us exactly how much power is theoretically required to stay at the target temperature. If the kitchen gets 5°C colder, the feedforward component immediately bumps up the power without waiting for the internal sensor to detect a drop.

By collecting data for steady-state power at different PWM commands, I found a nicely linear relationship. This allows the controller to command the necessary power.

2. Feedback: Corrective Control (PID)  

Since the world isn’t perfect, we use PID control⁵ to fix the errors. PID stands for:

• Proportional (P): If we’re 2°C too cold, turn up the heat.
• Integral (I): If we’ve been 0.5°C too cold for ten minutes, slowly increase the power until the error finally vanishes.
• Derivative (D): If the temperature is rising too fast, back off the power to prevent an overshoot.

Handling Actuator Saturation  

A common pitfall in control is Integral Windup. Our heater can’t go below 0% or above 100% power. If the lid is left open, the Integral term will see a massive error and try to command 500% power. When the lid finally closes, the controller would stay at full power for way too long, potentially baking the dough. My og3 library’s PID logic includes anti-windup to prevent this.

Trajectory control: Being Nice to the Hardware  

Another way to help the controller is to avoid asking it to do things it physically can’t. We know our heater has a limit (60W) and the cooler has a capacitance (1750 J/°C). So the fastest we can heat up is about 0.03°C per second. Dough133 limits the target temperature’s rate of change to this value, ensuring the controller stays in its comfortable operating range.

The Final Result: Extreme Control, Happy Yeast  

I tuned the gains ( $K_p, K_i, K_d$ ) by hand while watching the live telemetry from the ESP32. The result is a system that handles most of the load with feedforward, while the feedback loop quietly cleans up the noise.

The controller sends a status update every second via MQTT. Here is an example at steady state:

{
  "temp":    26.97,
  "error":   0.03,
  "command": 0.134,
  "ff_cmd":  0.108,
  "p_cmd":   0.009,
  "d_cmd":   0.025,
  "i_cmd":  -0.008
}

Conclusion  

By combining a simple thermal model with a PID controller, I transformed a cheap plastic cooler into a precision instrument for proofing sourdough. Could we have gotten by with a constant power heater or even a small lightbulb? Probably. But that would just be boring.

References