3DPrinting/MarlinFirmware
1
0
Fork 0
mirror of https://github.com/MarlinFirmware/Marlin.git synced 2024-11-26 21:36:21 +00:00
Code Issues Releases Wiki Activity

🎨 Indent temp structs

Browse Source
This commit is contained in:
Scott Lahteine 2023-06-27 20:33:57 -05:00
parent a5ac50fcbf
commit 46b5753f56
1 changed files with 162 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

324
Marlin/src/module/temperature.h
View File

@ -177,68 +177,68 @@ typedef struct { float p, i, d, c, f; } raw_pidcf_t;
/// PID classes that implement these features are expected to override these methods /// PID classes that implement these features are expected to override these methods
/// Since the finally used PID class is typedef-d, there is no need to use virtual functions /// Since the finally used PID class is typedef-d, there is no need to use virtual functions
template<int MIN_POW, int MAX_POW> template<int MIN_POW, int MAX_POW>
struct PID_t{ struct PID_t {
protected: protected:
bool pid_reset = true; bool pid_reset = true;
float temp_iState = 0.0f, temp_dState = 0.0f; float temp_iState = 0.0f, temp_dState = 0.0f;
float work_p = 0, work_i = 0, work_d = 0; float work_p = 0, work_i = 0, work_d = 0;
public: public:
float Kp = 0, Ki = 0, Kd = 0; float Kp = 0, Ki = 0, Kd = 0;
float p() const { return Kp; } float p() const { return Kp; }
float i() const { return unscalePID_i(Ki); } float i() const { return unscalePID_i(Ki); }
float d() const { return unscalePID_d(Kd); } float d() const { return unscalePID_d(Kd); }
float c() const { return 1; } float c() const { return 1; }
float f() const { return 0; } float f() const { return 0; }
float pTerm() const { return work_p; } float pTerm() const { return work_p; }
float iTerm() const { return work_i; } float iTerm() const { return work_i; }
float dTerm() const { return work_d; } float dTerm() const { return work_d; }
float cTerm() const { return 0; } float cTerm() const { return 0; }
float fTerm() const { return 0; } float fTerm() const { return 0; }
void set_Kp(float p) { Kp = p; } void set_Kp(float p) { Kp = p; }
void set_Ki(float i) { Ki = scalePID_i(i); } void set_Ki(float i) { Ki = scalePID_i(i); }
void set_Kd(float d) { Kd = scalePID_d(d); } void set_Kd(float d) { Kd = scalePID_d(d); }
void set_Kc(float) {} void set_Kc(float) {}
void set_Kf(float) {} void set_Kf(float) {}
int low() const { return MIN_POW; } int low() const { return MIN_POW; }
int high() const { return MAX_POW; } int high() const { return MAX_POW; }
void reset() { pid_reset = true; } void reset() { pid_reset = true; }
void set(float p, float i, float d, float c=1, float f=0) { set_Kp(p); set_Ki(i); set_Kd(d); set_Kc(c); set_Kf(f); } void set(float p, float i, float d, float c=1, float f=0) { set_Kp(p); set_Ki(i); set_Kd(d); set_Kc(c); set_Kf(f); }
void set(const raw_pid_t &raw) { set(raw.p, raw.i, raw.d); } void set(const raw_pid_t &raw) { set(raw.p, raw.i, raw.d); }
void set(const raw_pidcf_t &raw) { set(raw.p, raw.i, raw.d, raw.c, raw.f); } void set(const raw_pidcf_t &raw) { set(raw.p, raw.i, raw.d, raw.c, raw.f); }
float get_fan_scale_output(const uint8_t) { return 0; } float get_fan_scale_output(const uint8_t) { return 0; }
float get_extrusion_scale_output(const bool, const int32_t, const float, const int16_t) { return 0; } float get_extrusion_scale_output(const bool, const int32_t, const float, const int16_t) { return 0; }
float get_pid_output(const float target, const float current) { float get_pid_output(const float target, const float current) {
const float pid_error = target - current; const float pid_error = target - current;
if (!target || pid_error < -(PID_FUNCTIONAL_RANGE)) { if (!target || pid_error < -(PID_FUNCTIONAL_RANGE)) {
pid_reset = true; pid_reset = true;
return 0; return 0;
}
else if (pid_error > PID_FUNCTIONAL_RANGE) {
pid_reset = true;
return MAX_POW;
}
if (pid_reset) {
pid_reset = false;
temp_iState = 0.0;
work_d = 0.0;
}
const float max_power_over_i_gain = float(MAX_POW) / Ki - float(MIN_POW);
temp_iState = constrain(temp_iState + pid_error, 0, max_power_over_i_gain);
work_p = Kp * pid_error;
work_i = Ki * temp_iState;
work_d = work_d + PID_K2 * (Kd * (temp_dState - current) - work_d);
temp_dState = current;
return constrain(work_p + work_i + work_d + float(MIN_POW), 0, MAX_POW);
} }
else if (pid_error > PID_FUNCTIONAL_RANGE) {
pid_reset = true;
return MAX_POW;
}
if (pid_reset) {
pid_reset = false;
temp_iState = 0.0;
work_d = 0.0;
}
const float max_power_over_i_gain = float(MAX_POW) / Ki - float(MIN_POW);
temp_iState = constrain(temp_iState + pid_error, 0, max_power_over_i_gain);
work_p = Kp * pid_error;
work_i = Ki * temp_iState;
work_d = work_d + PID_K2 * (Kd * (temp_dState - current) - work_d);
temp_dState = current;
return constrain(work_p + work_i + work_d + float(MIN_POW), 0, MAX_POW);
}
}; };
@ -249,53 +249,53 @@ typedef struct { float p, i, d, c, f; } raw_pidcf_t;
/// @brief Extrusion scaled PID class /// @brief Extrusion scaled PID class
template<int MIN_POW, int MAX_POW, int LPQ_ARR_SZ> template<int MIN_POW, int MAX_POW, int LPQ_ARR_SZ>
struct PIDC_t : public PID_t<MIN_POW, MAX_POW> { struct PIDC_t : public PID_t<MIN_POW, MAX_POW> {
private: private:
using base = PID_t<MIN_POW, MAX_POW>; using base = PID_t<MIN_POW, MAX_POW>;
float work_c = 0; float work_c = 0;
float prev_e_pos = 0; float prev_e_pos = 0;
int32_t lpq[LPQ_ARR_SZ] = {}; int32_t lpq[LPQ_ARR_SZ] = {};
int16_t lpq_ptr = 0; int16_t lpq_ptr = 0;
public: public:
float Kc = 0; float Kc = 0;
float c() const { return Kc; } float c() const { return Kc; }
void set_Kc(float c) { Kc = c; } void set_Kc(float c) { Kc = c; }
float cTerm() const { return work_c; } float cTerm() const { return work_c; }
void set(float p, float i, float d, float c=1, float f=0) { void set(float p, float i, float d, float c=1, float f=0) {
base::set_Kp(p); base::set_Kp(p);
base::set_Ki(i); base::set_Ki(i);
base::set_Kd(d); base::set_Kd(d);
set_Kc(c); set_Kc(c);
base::set_Kf(f); base::set_Kf(f);
}
void set(const raw_pid_t &raw) { set(raw.p, raw.i, raw.d); }
void set(const raw_pidcf_t &raw) { set(raw.p, raw.i, raw.d, raw.c, raw.f); }
void reset() {
base::reset();
prev_e_pos = 0;
lpq_ptr = 0;
for (uint8_t i = 0; i < LPQ_ARR_SZ; ++i) lpq[i] = 0;
}
float get_extrusion_scale_output(const bool is_active, const int32_t e_position, const float e_mm_per_step, const int16_t lpq_len) {
work_c = 0;
if (!is_active) return work_c;
if (e_position > prev_e_pos) {
lpq[lpq_ptr] = e_position - prev_e_pos;
prev_e_pos = e_position;
} }
else void set(const raw_pid_t &raw) { set(raw.p, raw.i, raw.d); }
lpq[lpq_ptr] = 0; void set(const raw_pidcf_t &raw) { set(raw.p, raw.i, raw.d, raw.c, raw.f); }
void reset() {
++lpq_ptr; base::reset();
prev_e_pos = 0;
if (lpq_ptr >= LPQ_ARR_SZ || lpq_ptr >= lpq_len)
lpq_ptr = 0; lpq_ptr = 0;
for (uint8_t i = 0; i < LPQ_ARR_SZ; ++i) lpq[i] = 0;
}
work_c = (lpq[lpq_ptr] * e_mm_per_step) * Kc; float get_extrusion_scale_output(const bool is_active, const int32_t e_position, const float e_mm_per_step, const int16_t lpq_len) {
work_c = 0;
if (!is_active) return work_c;
return work_c; if (e_position > prev_e_pos) {
} lpq[lpq_ptr] = e_position - prev_e_pos;
prev_e_pos = e_position;
}
else
lpq[lpq_ptr] = 0;
++lpq_ptr;
if (lpq_ptr >= LPQ_ARR_SZ || lpq_ptr >= lpq_len)
lpq_ptr = 0;
work_c = (lpq[lpq_ptr] * e_mm_per_step) * Kc;
return work_c;
}
}; };
/// @brief Fan scaled PID, this class implements the get_fan_scale_output() method /// @brief Fan scaled PID, this class implements the get_fan_scale_output() method
@ -305,67 +305,67 @@ typedef struct { float p, i, d, c, f; } raw_pidcf_t;
/// @tparam SCALE_LIN_FACTOR parameter from Configuration_adv.h /// @tparam SCALE_LIN_FACTOR parameter from Configuration_adv.h
template<int MIN_POW, int MAX_POW, int SCALE_MIN_SPEED, int SCALE_LIN_FACTOR> template<int MIN_POW, int MAX_POW, int SCALE_MIN_SPEED, int SCALE_LIN_FACTOR>
struct PIDF_t : public PID_t<MIN_POW, MAX_POW> { struct PIDF_t : public PID_t<MIN_POW, MAX_POW> {
private: private:
using base = PID_t<MIN_POW, MAX_POW>; using base = PID_t<MIN_POW, MAX_POW>;
float work_f = 0; float work_f = 0;
public: public:
float Kf = 0; float Kf = 0;
float f() const { return Kf; } float f() const { return Kf; }
void set_Kf(float f) { Kf = f; } void set_Kf(float f) { Kf = f; }
float fTerm() const { return work_f; } float fTerm() const { return work_f; }
void set(float p, float i, float d, float c=1, float f=0) { void set(float p, float i, float d, float c=1, float f=0) {
base::set_Kp(p); base::set_Kp(p);
base::set_Ki(i); base::set_Ki(i);
base::set_Kd(d); base::set_Kd(d);
base::set_Kc(c); base::set_Kc(c);
set_Kf(f); set_Kf(f);
} }
void set(const raw_pid_t &raw) { set(raw.p, raw.i, raw.d); } void set(const raw_pid_t &raw) { set(raw.p, raw.i, raw.d); }
void set(const raw_pidcf_t &raw) { set(raw.p, raw.i, raw.d, raw.c, raw.f); } void set(const raw_pidcf_t &raw) { set(raw.p, raw.i, raw.d, raw.c, raw.f); }
float get_fan_scale_output(const uint8_t fan_speed) { float get_fan_scale_output(const uint8_t fan_speed) {
work_f = 0; work_f = 0;
if (fan_speed > SCALE_MIN_SPEED) if (fan_speed > SCALE_MIN_SPEED)
work_f = Kf + (SCALE_LIN_FACTOR) * fan_speed; work_f = Kf + (SCALE_LIN_FACTOR) * fan_speed;
return work_f; return work_f;
} }
}; };
/// @brief Inherits PID and PIDC - can't use proper diamond inheritance w/o virtual /// @brief Inherits PID and PIDC - can't use proper diamond inheritance w/o virtual
template<int MIN_POW, int MAX_POW, int LPQ_ARR_SZ, int SCALE_MIN_SPEED, int SCALE_LIN_FACTOR> template<int MIN_POW, int MAX_POW, int LPQ_ARR_SZ, int SCALE_MIN_SPEED, int SCALE_LIN_FACTOR>
struct PIDCF_t : public PIDC_t<MIN_POW, MAX_POW, LPQ_ARR_SZ> { struct PIDCF_t : public PIDC_t<MIN_POW, MAX_POW, LPQ_ARR_SZ> {
private: private:
using base = PID_t<MIN_POW, MAX_POW>; using base = PID_t<MIN_POW, MAX_POW>;
using cPID = PIDC_t<MIN_POW, MAX_POW, LPQ_ARR_SZ>; using cPID = PIDC_t<MIN_POW, MAX_POW, LPQ_ARR_SZ>;
float work_f = 0; float work_f = 0;
public: public:
float Kf = 0; float Kf = 0;
float c() const { return cPID::c(); } float c() const { return cPID::c(); }
float f() const { return Kf; } float f() const { return Kf; }
void set_Kc(float c) { cPID::set_Kc(c); } void set_Kc(float c) { cPID::set_Kc(c); }
void set_Kf(float f) { Kf = f; } void set_Kf(float f) { Kf = f; }
float cTerm() const { return cPID::cTerm(); } float cTerm() const { return cPID::cTerm(); }
float fTerm() const { return work_f; } float fTerm() const { return work_f; }
void set(float p, float i, float d, float c=1, float f=0) { void set(float p, float i, float d, float c=1, float f=0) {
base::set_Kp(p); base::set_Kp(p);
base::set_Ki(i); base::set_Ki(i);
base::set_Kd(d); base::set_Kd(d);
cPID::set_Kc(c); cPID::set_Kc(c);
set_Kf(f); set_Kf(f);
} }
void set(const raw_pid_t &raw) { set(raw.p, raw.i, raw.d); } void set(const raw_pid_t &raw) { set(raw.p, raw.i, raw.d); }
void set(const raw_pidcf_t &raw) { set(raw.p, raw.i, raw.d, raw.c, raw.f); } void set(const raw_pidcf_t &raw) { set(raw.p, raw.i, raw.d, raw.c, raw.f); }
void reset() { cPID::reset(); } void reset() { cPID::reset(); }
float get_fan_scale_output(const uint8_t fan_speed) { float get_fan_scale_output(const uint8_t fan_speed) {
work_f = fan_speed > (SCALE_MIN_SPEED) ? Kf + (SCALE_LIN_FACTOR) * fan_speed : 0; work_f = fan_speed > (SCALE_MIN_SPEED) ? Kf + (SCALE_LIN_FACTOR) * fan_speed : 0;
return work_f; return work_f;
} }
float get_extrusion_scale_output(const bool is_active, const int32_t e_position, const float e_mm_per_step, const int16_t lpq_len) { float get_extrusion_scale_output(const bool is_active, const int32_t e_position, const float e_mm_per_step, const int16_t lpq_len) {
return cPID::get_extrusion_scale_output(is_active, e_position, e_mm_per_step, lpq_len); return cPID::get_extrusion_scale_output(is_active, e_position, e_mm_per_step, lpq_len);
} }
}; };
typedef typedef
@ -415,16 +415,16 @@ typedef struct { float p, i, d, c, f; } raw_pidcf_t;
// A temperature sensor // A temperature sensor
typedef struct TempInfo { typedef struct TempInfo {
private: private:
raw_adc_t acc; raw_adc_t acc;
raw_adc_t raw; raw_adc_t raw;
public: public:
celsius_float_t celsius; celsius_float_t celsius;
inline void reset() { acc = 0; } inline void reset() { acc = 0; }
inline void sample(const raw_adc_t s) { acc += s; } inline void sample(const raw_adc_t s) { acc += s; }
inline void update() { raw = acc; } inline void update() { raw = acc; }
void setraw(const raw_adc_t r) { raw = r; } void setraw(const raw_adc_t r) { raw = r; }
raw_adc_t getraw() const { return raw; } raw_adc_t getraw() const { return raw; }
} temp_info_t; } temp_info_t;
#if HAS_TEMP_REDUNDANT #if HAS_TEMP_REDUNDANT