Referencia de la clase PID

Controlador PID con anti-windup, derivative-on-measurement y limitación de cambio de salida (slew-rate limit). Más...

#include <pid.h>

Métodos públicos
	PID (float Kp, float Ki, float Kd, float outputMin, float outputMax, float dt, float outputMaxChanged)
	Constructor del controlador PID.
float	calculoPID (float setpoint, float feedback, bool debugMSG=false)
	Calcula la salida del controlador PID.
void	setKPID (float Kp, float Ki, float Kd)
	Establece nuevas ganancias PID.
void	setOutputLimits (float outputMin, float outputMax)
	Establece los límites de salida del PID.
void	setDt (float dt)
	Establece un nuevo tiempo de muestreo.
void	resetPID ()
	Reinicia el estado interno del PID.
float	statedt (float dt)
	Valida y corrige el tiempo de muestreo.
void	printDebugPID (float setpoint, float feedback)
	Imprime información de depuración del PID.

Atributos privados
float	Kp
	Ganancia proporcional.
float	Ki
	Ganancia integral.
float	Kd
	Ganancia derivativa.
float	outputMin
	Límite mínimo de salida.
float	outputMax
	Límite máximo de salida.
float	dt
	Tiempo de muestreo.
float	error
	Error actual.
float	prevError
	Error previo.
float	proportional
	Término proporcional.
float	integral
	Acumulador integral.
float	pidNoIntegral
	PID sin término integral.
bool	saturated
	Indica si el PID está saturado.
float	derivative
	Término derivativo.
float	output
	Salida final del PID.
float	rawOutput
	Salida sin limitación de cambio.
float	prevOutput
	Salida previa.
float	deltaOutput
	Cambio entre salidas.
float	prevFeedback
	Feedback previo para derivative-on-measurement.
float	outputMaxChanged
	Máximo cambio permitido por ciclo.

Descripción detallada

Controlador PID con anti-windup, derivative-on-measurement y limitación de cambio de salida (slew-rate limit).

Este controlador está diseñado para sistemas sensibles como motores paso a paso, actuadores lentos o sistemas donde se requiere suavidad y estabilidad.

Definición en la línea 14 del archivo pid.h.

Documentación de constructores y destructores

PID()

PID::PID	(	float	Kp,
		float	Ki,
		float	Kd,
		float	outputMin,
		float	outputMax,
		float	dt,
		float	outputMaxChanged )

Constructor del controlador PID.

Parámetros

Kp	Ganancia proporcional.
Ki	Ganancia integral.
Kd	Ganancia derivativa.
outputMin	Límite mínimo de salida.
outputMax	Límite máximo de salida.
dt	Tiempo de muestreo en segundos.
outputMaxChanged	Máximo cambio permitido por ciclo (slew-rate).

Definición en la línea 20 del archivo pid.cpp.

{
    this->Kp = Kp;
    this->Ki = Ki;
    this->Kd = Kd;
 
    this->outputMin = outputMin;
    this->outputMax = outputMax;
 
    this->dt = statedt(dt);
    this->outputMaxChanged = outputMaxChanged;
 
    this->error = 0.0f;
    this->prevError = 0.0f;
    this->integral = 0.0f;
    this->derivative = 0.0f;
    this->output = 0.0f;
 
    this->prevFeedback = 0.0f;
    this->prevOutput = 0.0f;
}

Gráfico de llamadas de esta función:

Documentación de funciones miembro

calculoPID()

float PID::calculoPID	(	float	setpoint,
		float	feedback,
		bool	debugMSG = false )

Calcula la salida del controlador PID.

Parámetros

setpoint	Valor deseado.
feedback	Valor medido.
debugMSG	Si es true, imprime información de depuración del PID.

Devuelve

Salida del PID.

Implementa:

• Proporcional
• Integral con anti-windup condicional
• Derivative-on-measurement (evita derivative kick)
• Slew-rate limit (limitación de cambio por ciclo)
• Saturación final

Parámetros

setpoint	Valor deseado.
feedback	Valor medido.

Devuelve

Salida del controlador PID.

Definición en la línea 58 del archivo pid.cpp.

{
    // 1) Error actual
    this->error = setpoint - feedback;
 
    // 2) Proporcional
    this->proportional = this->Kp * this->error;
 
    // Protección dt
    if (this->dt <= 0.0f)
        return this->output;
 
    // 3) Derivada (derivative-on-measurement)
    this->derivative = -(feedback - this->prevFeedback) / this->dt;
 
    // 4) Anti-windup condicional
    this->pidNoIntegral = this->proportional + this->Kd * this->derivative;
    this->saturated = (this->pidNoIntegral > this->outputMax) || (this->pidNoIntegral < this->outputMin);
 
    if (!this->saturated)
    {
        this->integral += this->error * this->dt;
 
        if (this->integral > this->outputMax) this->integral = this->outputMax;
        if (this->integral < this->outputMin) this->integral = this->outputMin;
    }
 
    // 5) PID completo sin limitación de cambio
    this->rawOutput = this->proportional +
                      (this->Ki * this->integral) +
                      (this->Kd * this->derivative);
 
    // 6) Slew-rate limit
    this->deltaOutput = this->rawOutput - this->prevOutput;
 
    if (this->deltaOutput > this->outputMaxChanged)
        this->output = this->prevOutput + this->outputMaxChanged;
    else if (this->deltaOutput < -this->outputMaxChanged)
        this->output = this->prevOutput - this->outputMaxChanged;
    else
        this->output = this->rawOutput;
 
    // 7) Saturación final
    if (this->output > this->outputMax) this->output = this->outputMax;
    if (this->output < this->outputMin) this->output = this->outputMin;
 
    // 8) Guardar estado
    this->prevError = this->error;
    this->prevFeedback = feedback;
    this->prevOutput = this->output;
 
 
    // 9) Debug
    if (debugMSG) printDebugPID(setpoint, feedback);
 
    return this->output;
 
};

Gráfico de llamadas de esta función:

Gráfico de llamadas a esta función:

printDebugPID()

void PID::printDebugPID	(	float	setpoint,
		float	feedback )

Imprime información de depuración del PID.

Muestra en consola el estado interno del PID en formato tabla.

Parámetros

setpoint	Valor deseado.
feedback	Valor medido.

Definición en la línea 188 del archivo pid.cpp.

{
    Serial.println(F("--------------------------------------------------------------------------"));
    Serial.println(F("|  SP  |  FB  | Error |    P     |    I     |    D     | RawOut |  Out  |"));
    Serial.println(F("--------------------------------------------------------------------------"));
 
    Serial.print(F("| "));
    Serial.print(setpoint, 3);
    Serial.print(F(" | "));
 
    Serial.print(feedback, 3);
    Serial.print(F(" | "));
 
    Serial.print(this->error, 3);
    Serial.print(F(" | "));
 
    Serial.print(this->proportional, 3);
    Serial.print(F(" | "));
 
    Serial.print(this->integral, 3);
    Serial.print(F(" | "));
 
    Serial.print(this->derivative, 3);
    Serial.print(F(" | "));
 
    Serial.print(this->rawOutput, 3);
    Serial.print(F(" | "));
 
    Serial.print(this->output, 3);
    Serial.println(F(" |"));
 
    Serial.println(F("--------------------------------------------------------------------------"));
}

Gráfico de llamadas a esta función:

resetPID()

void PID::resetPID

(

)

Reinicia el estado interno del PID.

Definición en la línea 156 del archivo pid.cpp.

{
    this->error = 0.0f;
    this->prevError = 0.0f;
    this->integral = 0.0f;
    this->derivative = 0.0f;
    this->output = 0.0f;
    this->prevFeedback = 0.0f;
    this->prevOutput = 0.0f;
}

setDt()

void PID::setDt

(

float

dt

)

Establece un nuevo tiempo de muestreo.

Parámetros

dt

Nuevo dt.

Definición en la línea 148 del archivo pid.cpp.

{
    this->dt = statedt(dt);
}

Gráfico de llamadas de esta función:

setKPID()

void PID::setKPID	(	float	Kp,
		float	Ki,
		float	Kd )

Establece nuevas ganancias PID.

Parámetros

Kp	Nueva ganancia proporcional.
Ki	Nueva ganancia integral.
Kd	Nueva ganancia derivativa.

Definición en la línea 124 del archivo pid.cpp.

{
    this->Kp = Kp;
    this->Ki = Ki;
    this->Kd = Kd;
}

setOutputLimits()

void PID::setOutputLimits	(	float	outputMin,
		float	outputMax )

Establece los límites de salida del PID.

Parámetros

outputMin	Nuevo límite mínimo.
outputMax	Nuevo límite máximo.

Definición en la línea 137 del archivo pid.cpp.

{
    this->outputMin = outputMin;
    this->outputMax = outputMax;
}

statedt()

float PID::statedt

(

float

dt

)

Valida y corrige el tiempo de muestreo.

Valida el tiempo de muestreo.

Parámetros

dt	Tiempo de muestreo solicitado.

Devuelve

dt válido (mínimo 0.1f).

Definición en la línea 173 del archivo pid.cpp.

{
    if (dt <= 0.0f)
        return 0.1f;
 
    return dt;
}

Gráfico de llamadas a esta función:

Documentación de datos miembro

deltaOutput

float PID::deltaOutput

private

Cambio entre salidas.

Definición en la línea 113 del archivo pid.h.

derivative

float PID::derivative

private

Término derivativo.

Definición en la línea 109 del archivo pid.h.

dt

float PID::dt

private

Tiempo de muestreo.

Definición en la línea 100 del archivo pid.h.

error

float PID::error

private

Error actual.

Definición en la línea 103 del archivo pid.h.

integral

float PID::integral

private

Acumulador integral.

Definición en la línea 106 del archivo pid.h.

Kd

float PID::Kd

private

Ganancia derivativa.

Definición en la línea 93 del archivo pid.h.

Ki

float PID::Ki

private

Ganancia integral.

Definición en la línea 92 del archivo pid.h.

Kp

float PID::Kp

private

Ganancia proporcional.

Definición en la línea 91 del archivo pid.h.

output

float PID::output

private

Salida final del PID.

Definición en la línea 110 del archivo pid.h.

outputMax

float PID::outputMax

private

Límite máximo de salida.

Definición en la línea 97 del archivo pid.h.

outputMaxChanged

float PID::outputMaxChanged

private

Máximo cambio permitido por ciclo.

Definición en la línea 117 del archivo pid.h.

outputMin

float PID::outputMin

private

Límite mínimo de salida.

Definición en la línea 96 del archivo pid.h.

pidNoIntegral

float PID::pidNoIntegral

private

PID sin término integral.

Definición en la línea 107 del archivo pid.h.

prevError

float PID::prevError

private

Error previo.

Definición en la línea 104 del archivo pid.h.

prevFeedback

float PID::prevFeedback

private

Feedback previo para derivative-on-measurement.

Definición en la línea 114 del archivo pid.h.

prevOutput

float PID::prevOutput

private

Salida previa.

Definición en la línea 112 del archivo pid.h.

proportional

float PID::proportional

private

Término proporcional.

Definición en la línea 105 del archivo pid.h.

rawOutput

float PID::rawOutput

private

Salida sin limitación de cambio.

Definición en la línea 111 del archivo pid.h.

saturated

bool PID::saturated

private

Indica si el PID está saturado.

Definición en la línea 108 del archivo pid.h.

---

La documentación de esta clase está generada de los siguientes archivos:

• pid.h
• pid.cpp