ESPHome  2021.11.3
pid_climate.cpp
Go to the documentation of this file.
1 #include "pid_climate.h"
2 #include "esphome/core/log.h"
3 
4 namespace esphome {
5 namespace pid {
6 
7 static const char *const TAG = "pid.climate";
8 
10  this->sensor_->add_on_state_callback([this](float state) {
11  // only publish if state/current temperature has changed in two digits of precision
12  this->do_publish_ = roundf(state * 100) != roundf(this->current_temperature * 100);
13  this->current_temperature = state;
14  this->update_pid_();
15  });
16  this->current_temperature = this->sensor_->state;
17  // restore set points
18  auto restore = this->restore_state_();
19  if (restore.has_value()) {
20  restore->to_call(this).perform();
21  } else {
22  // restore from defaults, change_away handles those for us
23  if (supports_heat_() && supports_cool_())
25  else if (supports_cool_())
27  else if (supports_heat_())
30  }
31 }
33  if (call.get_mode().has_value())
34  this->mode = *call.get_mode();
35  if (call.get_target_temperature().has_value())
37 
38  // If switching to off mode, set output immediately
39  if (this->mode == climate::CLIMATE_MODE_OFF)
40  this->write_output_(0.0f);
41 
42  this->publish_state();
43 }
48 
50  if (supports_cool_())
52  if (supports_heat_())
54  if (supports_heat_() && supports_cool_())
56 
58  return traits;
59 }
61  LOG_CLIMATE("", "PID Climate", this);
62  ESP_LOGCONFIG(TAG, " Control Parameters:");
63  ESP_LOGCONFIG(TAG, " kp: %.5f, ki: %.5f, kd: %.5f", controller_.kp, controller_.ki, controller_.kd);
64 
65  if (this->autotuner_ != nullptr) {
66  this->autotuner_->dump_config();
67  }
68 }
69 void PIDClimate::write_output_(float value) {
70  this->output_value_ = value;
71 
72  // first ensure outputs are off (both outputs not active at the same time)
73  if (this->supports_cool_() && value >= 0)
74  this->cool_output_->set_level(0.0f);
75  if (this->supports_heat_() && value <= 0)
76  this->heat_output_->set_level(0.0f);
77 
78  // value < 0 means cool, > 0 means heat
79  if (this->supports_cool_() && value < 0)
80  this->cool_output_->set_level(std::min(1.0f, -value));
81  if (this->supports_heat_() && value > 0)
82  this->heat_output_->set_level(std::min(1.0f, value));
83 
84  // Update action variable for user feedback what's happening
85  climate::ClimateAction new_action;
86  if (this->supports_cool_() && value < 0)
88  else if (this->supports_heat_() && value > 0)
90  else if (this->mode == climate::CLIMATE_MODE_OFF)
91  new_action = climate::CLIMATE_ACTION_OFF;
92  else
93  new_action = climate::CLIMATE_ACTION_IDLE;
94 
95  if (new_action != this->action) {
96  this->action = new_action;
97  this->do_publish_ = true;
98  }
99  this->pid_computed_callback_.call();
100 }
102  float value;
103  if (std::isnan(this->current_temperature) || std::isnan(this->target_temperature)) {
104  // if any control parameters are nan, turn off all outputs
105  value = 0.0;
106  } else {
107  // Update PID controller irrespective of current mode, to not mess up D/I terms
108  // In non-auto mode, we just discard the output value
109  value = this->controller_.update(this->target_temperature, this->current_temperature);
110 
111  // Check autotuner
112  if (this->autotuner_ != nullptr && !this->autotuner_->is_finished()) {
113  auto res = this->autotuner_->update(this->target_temperature, this->current_temperature);
114  if (res.result_params.has_value()) {
115  this->controller_.kp = res.result_params->kp;
116  this->controller_.ki = res.result_params->ki;
117  this->controller_.kd = res.result_params->kd;
118  // keep autotuner instance so that subsequent dump_configs will print the long result message.
119  } else {
120  value = res.output;
122  ESP_LOGW(TAG, "For PID autotuner you need to set AUTO (also called heat/cool) mode!");
123  }
124  }
125  }
126  }
127 
128  if (this->mode == climate::CLIMATE_MODE_OFF) {
129  this->write_output_(0.0);
130  } else {
131  this->write_output_(value);
132  }
133 
134  if (this->do_publish_)
135  this->publish_state();
136 }
137 void PIDClimate::start_autotune(std::unique_ptr<PIDAutotuner> &&autotune) {
138  this->autotuner_ = std::move(autotune);
139  float min_value = this->supports_cool_() ? -1.0f : 0.0f;
140  float max_value = this->supports_heat_() ? 1.0f : 0.0f;
141  this->autotuner_->config(min_value, max_value);
142  this->set_interval("autotune-progress", 10000, [this]() {
143  if (this->autotuner_ != nullptr && !this->autotuner_->is_finished())
144  this->autotuner_->dump_config();
145  });
146 }
147 
149 
150 } // namespace pid
151 } // namespace esphome
This class is used to encode all control actions on a climate device.
Definition: climate.h:33
The climate device is off (inactive or no power)
Definition: climate_mode.h:33
output::FloatOutput * cool_output_
Definition: pid_climate.h:62
bool supports_cool_() const
Definition: pid_climate.h:55
void add_on_state_callback(std::function< void(float)> &&callback)
Add a callback that will be called every time a filtered value arrives.
Definition: sensor.cpp:71
void set_interval(const std::string &name, uint32_t interval, std::function< void()> &&f)
Set an interval function with a unique name.
Definition: component.cpp:50
void write_output_(float value)
Definition: pid_climate.cpp:69
float target_temperature
The target temperature of the climate device.
Definition: climate.h:183
const optional< ClimateMode > & get_mode() const
Definition: climate.cpp:259
void setup() override
Definition: pid_climate.cpp:9
This class contains all static data for climate devices.
The climate device is set to heat to reach the target temperature.
Definition: climate_mode.h:18
ClimateMode mode
The active mode of the climate device.
Definition: climate.h:175
float current_temperature
The current temperature of the climate device, as reported from the integration.
Definition: climate.h:179
bool has_value() const
Definition: optional.h:87
void start_autotune(std::unique_ptr< PIDAutotuner > &&autotune)
std::unique_ptr< PIDAutotuner > autotuner_
Definition: pid_climate.h:69
void set_level(float state)
Set the level of this float output, this is called from the front-end.
The climate device is set to cool to reach the target temperature.
Definition: climate_mode.h:16
float state
This member variable stores the last state that has passed through all filters.
Definition: sensor.h:132
float ki
Integral gain K_i.
float kp
Proportional gain K_p.
void set_supported_modes(std::set< ClimateMode > modes)
ClimateAction
Enum for the current action of the climate device. Values match those of ClimateMode.
Definition: climate_mode.h:31
float update(float setpoint, float process_value)
Definition: pid_controller.h:9
The climate device is set to heat/cool to reach the target temperature.
Definition: climate_mode.h:14
void control(const climate::ClimateCall &call) override
Override control to change settings of the climate device.
Definition: pid_climate.cpp:32
The climate device is actively heating.
Definition: climate_mode.h:37
const optional< float > & get_target_temperature() const
Definition: climate.cpp:260
float kd
Differential gain K_d.
void publish_state()
Publish the state of the climate device, to be called from integrations.
Definition: climate.cpp:380
The climate device is off.
Definition: climate_mode.h:12
climate::ClimateTraits traits() override
Return the traits of this controller.
Definition: pid_climate.cpp:44
void set_supports_action(bool supports_action)
sensor::Sensor * sensor_
The sensor used for getting the current temperature.
Definition: pid_climate.h:61
bool supports_heat_() const
Definition: pid_climate.h:56
void dump_config() override
Definition: pid_climate.cpp:60
output::FloatOutput * heat_output_
Definition: pid_climate.h:63
Library based on https://github.com/miguelbalboa/rfid and adapted to ESPHome by . ...
Definition: a4988.cpp:4
PIDController controller_
Definition: pid_climate.h:64
The climate device is idle (monitoring climate but no action needed)
Definition: climate_mode.h:39
void set_supports_two_point_target_temperature(bool supports_two_point_target_temperature)
optional< ClimateDeviceRestoreState > restore_state_()
Restore the state of the climate device, call this from your setup() method.
Definition: climate.cpp:320
void set_supports_current_temperature(bool supports_current_temperature)
float output_value_
Output value as reported by the PID controller, for PIDClimateSensor.
Definition: pid_climate.h:66
The climate device is actively cooling.
Definition: climate_mode.h:35
void add_supported_mode(ClimateMode mode)
CallbackManager< void()> pid_computed_callback_
Definition: pid_climate.h:67
ClimateAction action
The active state of the climate device.
Definition: climate.h:177