PID Controller - Now Working!

[jazzmonger]

After seeing another project (PiFire) successfully use a PID controller on a pellet fire system with only auger on/off control, I'm "kindling" this discussion to see if we can use it on these pellet stoves. ESPHome has a PID module, but it requires a proportional input to make adjustments. We have only one input - Auger on/off. PiFire uses on/off.

PID control may allow the fire to burn at a much lower temp w/out going out. Very useful when there's a chill in the air and P5 (the new low setting) causes too much heat to be thrown out of the pellet stove.

So, I asked ChatGPT to produce code to implement this and was surprised that it spit out something that looks useful....

Prompt: "Write an ESPHome PID routine to control a single speed auger motor knowing the temperature of a pellet fire pot and target temperature of the room"

ChatGPT said:
To control a single-speed auger motor in an ESPHome setup based on the temperature of a pellet fire pot and the target room temperature, we can implement a PID routine that adjusts the motor's duty cycle (ON/OFF periods) to maintain the desired room temperature.

Key Points:
Input 1: Room temperature from a room sensor (e.g., DHT22, BME280).
Input 2: Pellet fire pot temperature to ensure safe operation and avoid overheating.
Output: Auger motor control (ON/OFF via a relay).
Logic: The PID controller adjusts the ON duration of the auger motor based on the room temperature error (difference between the target room temperature and the actual room temperature).
ESPHome YAML Configuration

esphome:
  name: pellet_fire_control
  platform: ESP8266  # or your specific ESP device
  board: nodemcuv2   # replace with your board

# Wi-Fi Configuration
wifi:
  ssid: "your-SSID"
  password: "your-password"

# Enable Web Server for debugging
web_server:
  port: 80

# Enable API and OTA for control and updates
api:
ota:

# Room Temperature Sensor (e.g., DHT22 or BME280)
sensor:
  - platform: dht
    pin: D2
    model: DHT22
    temperature:
      name: "Room Temperature"
      id: room_temperature
    update_interval: 5s

# Fire Pot Temperature Sensor
  - platform: dallas
    address: 0x2A0000031A2D
    name: "Fire Pot Temperature"
    id: fire_pot_temperature
    update_interval: 5s

# PID Output (For monitoring and debugging)
  - platform: template
    name: "PID Output"
    id: pid_output
    unit_of_measurement: "%"
    accuracy_decimals: 1
    update_interval: 1s

# Globals for PID and control variables
globals:
  - id: target_room_temp
    type: float
    restore_value: no
    initial_value: '22.0'  # Target room temperature in °C
  - id: current_room_temp
    type: float
    restore_value: no
    initial_value: '0.0'
  - id: current_fire_pot_temp
    type: float
    restore_value: no
    initial_value: '0.0'
  - id: integral
    type: float
    restore_value: no
    initial_value: '0.0'
  - id: previous_error
    type: float
    restore_value: no
    initial_value: '0.0'

# Auger Motor Control
output:
  - platform: gpio
    pin: D1  # Pin connected to the auger motor relay
    id: auger_motor

switch:
  - platform: output
    name: "Auger Motor"
    output: auger_motor
    id: auger_motor_switch

# PID Routine and Auger Motor Duty Cycle Control
interval:
  - interval: 1s
    then:
      - lambda: |-
          // PID Parameters
          float kp = 2.0;   // Proportional gain
          float ki = 0.1;   // Integral gain
          float kd = 0.05;  // Derivative gain

          // Update current values
          id(current_room_temp) = id(room_temperature).state;
          id(current_fire_pot_temp) = id(fire_pot_temperature).state;

          // Calculate PID error based on room temperature
          float error = id(target_room_temp) - id(current_room_temp);

          // Avoid overheating: Reduce error if fire pot temperature is too high
          if (id(current_fire_pot_temp) > 250.0) {  // Adjust threshold as needed
            error = error / 2.0;  // Reduce PID response to avoid overshooting
          }

          // PID Calculations
          id.integral += error * 1.0;  // 1 second interval
          float derivative = (error - id.previous_error) / 1.0;
          id.previous_error = error;

          // PID output
          float pid_output = (kp * error) + (ki * id.integral) + (kd * derivative);

          // Constrain PID output to a duty cycle percentage
          pid_output = constrain(pid_output, 0.0, 100.0);

          // Publish PID output for debugging
          id(pid_output).publish_state(pid_output);

          // Control auger motor duty cycle based on PID output
          if (pid_output > 0) {
            int on_time = (pid_output / 100.0) * 10;  // Scale ON time (e.g., max 10 seconds)
            int off_time = 10 - on_time;             // OFF time is complementary
            id(auger_motor_switch).turn_on();
            delay(on_time * 1000);  // ON duration
            id(auger_motor_switch).turn_off();
            delay(off_time * 1000); // OFF duration
          } else {
            id(auger_motor_switch).turn_off();
          }

Explanation of Key Components:

Gradually adjust these parameters to achieve a stable response.

Very Interesting stuff. We'd need to bound the on/off cycle so that the fire doesn't actually go out when the thermostat is set for, say 61 and the room temp is 65. We want a very gradual decrease so the fire pot remains stable.

Anyway I thought I'd put this out there. I'll come back to it when I have more time.

[jazzmonger]

I'm calling this a win...
After several iterations of different PID implementations, I settled on a fixed 0.9 auger on time and then vary the auger off time from 3s-20s. The result is impressive. The temp control band went from approx 160-250F to 160-190F. So what? Well this means that the lower & more consistent temperature band doesn't heat the stove up as much and the result is if you set the temp for 65, the stove will maintain 65 and not go up to 75.

here's a graph. The white line is the controller varying the off time from 3S-20s (axis label on right side) to adjust the exhaust temp to be as close to 150F (axis label on left) as possible. You can see the result in the bottom graph of auger pulses.

The big variable here is the automatic cleaning cycle setting. It was set for 20s @ 1min intervals. I increased it to 20s at 10 min intervals. The feature blows ash out of the fire pot and must be done. The net result is a spike in temp, but that only happens once every 10 min now.

I'll post updated firmware source code soon along with the PID settings I'm using if others want to try it out.
Who knows... one of you might figure out a way to get it controlled even more so. I haven't pushed the limits yet, so I really don't yet know what the lowest temp setting I can use is.

[jazzmonger]

Uploaded PID controller firmware here

Start w/ these values:
desired_pipe_temp=150 - keep lowering this as long as the stove stays lit. 150 is about as low as I can get it so far.
PB = 15
Td=75
Ti=50
stoking temp == 131F - lowered so stoking doesnt happen as often.
automatic cleaning cycle setting. increase it to 20s at 10 min intervals

PID Controllers are like Rubix Cubes. In all my research, everyone goes thru exhaustive math and comes to exactly the same conclusions... The best tuning is accomplished through TRIAL AND ERROR. If you come up with better values and can stabilize it better, by all means, post your results here!

ChatGP says:
In a PID (Proportional-Integral-Derivative) controller that regulates the off-time of a pellet stove auger, the PB (Proportional Band), Ti (Integral Time), and Td (Derivative Time) parameters influence how the system responds to temperature deviations. Here’s how each parameter affects the control:

1. PB (Proportional Band) – This determines how much the off-time of the auger changes in response to the difference between the setpoint and the actual temperature.
   • A narrower PB means more aggressive control, so the auger off-time will change more significantly for small errors.
   • A wider PB results in a more gradual response, reducing sudden changes in auger operation.
2. Ti (Integral Time) – This corrects long-term errors by adjusting the off-time to eliminate steady-state errors.
   • A shorter Ti increases the effect of past errors more quickly, reducing steady-state deviations but potentially leading to overshoot.
   • A longer Ti slows down the correction, which helps avoid excessive oscillation but may leave residual errors for longer.
3. Td (Derivative Time) – This anticipates changes by reacting to the rate of temperature change.
   • A higher Td makes the controller more sensitive to rapid changes in temperature, which can help prevent overshoot by adjusting the auger off-time preemptively.
   • A lower Td results in less anticipation, making the response slower but more stable.
     Effect on Pellet Stove Auger Control:

• If PB is too small, the auger might oscillate between running too much or too little, leading to unstable temperature control.
• If Ti is too short, the auger off-time will change too aggressively, causing overcorrection and oscillations.
• If Td is too long, the system may react too strongly to minor fluctuations, making the auger operate erratically.