¡Hola a todos los entusiastas de la programación y la automatización! Hoy tengo algo realmente emocionante que compartir con vosotros. Ya sabéis que tengo una especie de obsesión (¡pero de las buenas!) con el algoritmo PID. Es esa maravilla de la ingeniería que mantiene todo en equilibrio, desde nuestros termostatos hasta los drones. Bueno, pues cada vez que encuentro un momento libre, me zambullo de cabeza en el mundo de PID, experimentando con pequeñas maquetas y desarrollos para ver qué puedo crear.

Pero esta vez, he decidido llevar mi pasión un paso más allá. ¿Habéis oído hablar del ranking PYPL (PopularitY of Programming Language Index)? Es como la lista de éxitos para los lenguajes de programación, mostrándonos cuáles son los más utilizados en este loco mundo de la tecnología. Así que, ¿qué mejor manera de celebrar mi amor por el PID y la programación que combinándolos?

He preparado algo especial: una implementación básica del algoritmo PID en los diez primeros lenguajes de programación del ranking PYPL. ¡Sí, habéis leído bien! Desde Python hasta JavaScript, pasando por Swift y muchos más. Voy a desglosar cómo se puede implementar este algoritmo en cada uno de estos lenguajes populares, mostrando sus peculiaridades y sus puntos fuertes.

Así que, si eres un fanático del control automático o simplemente un curioso de la programación, te invito a seguirme en esta aventura. Vamos a explorar juntos cómo el algoritmo PID puede cobrar vida de formas nuevas y emocionantes. ¡Prepárate para una mezcla de código, creatividad y, por supuesto, un poco de diversión técnica!

Python

PIDController <- setRefClass(
  "PIDController",
  fields = list(
    kp = "numeric",
    ki = "numeric",
    kd = "numeric",
    sample_time = "numeric",
    integral_limit = "numeric",
    last_error = "numeric",
    integral = "numeric",
    last_update_time = "numeric"
  ),
  methods = list(
    initialize = function(kp, ki, kd, sample_time, integral_limit) {
      kp <<- kp
      ki <<- ki
      kd <<- kd
      sample_time <<- sample_time
      integral_limit <<- integral_limit
      last_error <<- 0
      integral <<- 0
      last_update_time <<- Sys.time()
    },
    update = function(setpoint, current_value) {
      now <- Sys.time()
      delta_time <- difftime(now, last_update_time, units = "secs")

      if (as.numeric(delta_time) >= sample_time) {
        last_update_time <<- now
        error <- setpoint - current_value
        # Término proporcional
        P <- kp * error
        # Término integral
        integral <<- integral + error * as.numeric(delta_time)
        integral <<- min(max(integral, -integral_limit), integral_limit)
        I <- ki * integral
        # Término derivativo
        derivative <- (error - last_error) / as.numeric(delta_time)
        D <- kd * derivative
        # Actualizar último error
        last_error <<- error
        return(P + I + D)
      } else {
        return(0)  # No hay cambio en la salida si no ha pasado el tiempo de muestreo
      }
    }
  )
)

# Ejemplo de uso del controlador PID
pid <- PIDController$new(kp = 0.1, ki = 0.01, kd = 0.1, sample_time = 1, integral_limit = 10)
setpoint <- 100
current_value <- 90
# Función de bucle para simular el control
loop <- function() {
  control <- pid$update(setpoint, current_value)
  print(paste("Control output:", control))
  Sys.sleep(1)  # Espera un segundo antes de la próxima actualización
}
# Ejecutar el bucle (detenerlo manualmente)
while(TRUE) {
  loop()
}

Java

public class PIDController {

    private double kp; // Coeficiente proporcional
    private double ki; // Coeficiente integral
    private double kd; // Coeficiente derivativo
    private long sampleTime; // Tiempo de muestreo en milisegundos
    private double integralLimit; // Límite para prevenir el windup
    private double lastError;
    private double integral;
    private long lastUpdateTime;

    public PIDController(double kp, double ki, double kd, long sampleTime, double integralLimit) {
        this.kp = kp;
        this.ki = ki;
        this.kd = kd;
        this.sampleTime = sampleTime;
        this.integralLimit = integralLimit;
        this.lastError = 0;
        this.integral = 0;
        this.lastUpdateTime = System.currentTimeMillis();
    }

    public double update(double setpoint, double currentValue) {
        long now = System.currentTimeMillis();
        long timeChange = now - lastUpdateTime;
        if (timeChange >= sampleTime) {
            lastUpdateTime = now;
            double error = setpoint - currentValue;
            // Término proporcional
            double P = kp * error;
            // Término integral
            integral += error * (timeChange / 1000.0); // Convertir a segundos
            integral = Math.max(Math.min(integral, integralLimit), -integralLimit);
            double I = ki * integral;
            // Término derivativo
            double derivative = (error - lastError) / (timeChange / 1000.0);
            double D = kd * derivative;
            // Actualizar último error
            lastError = error;
            return P + I + D;
        } else {
            return 0; // No hay cambio en la salida si no ha pasado el tiempo de muestreo
        }
    }
    // Métodos getters y setters para kp, ki, kd, etc., si son necesarios
}

public class Main {
    public static void main(String[] args) {
        PIDController pid = new PIDController(0.1, 0.01, 0.1, 1000, 10.0); // Ejemplo de parámetros
        double setpoint = 100;
        double currentValue = 90;
        while (true) {
            double control = pid.update(setpoint, currentValue);
            System.out.println("Control output: " + control);
            // Aquí iría la lógica para actualizar el 'currentValue' basado en la salida del controlador
            try {
                Thread.sleep(100); // Espera un poco antes de la próxima actualización
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Javascript

class PIDController {
    constructor(kp, ki, kd, sampleTime, integralLimit) {
        this.kp = kp; // Coeficiente proporcional
        this.ki = ki; // Coeficiente integral
        this.kd = kd; // Coeficiente derivativo
        this.sampleTime = sampleTime; // Tiempo de muestreo en segundos
        this.integralLimit = integralLimit; // Límite para prevenir el windup
        this.currentValue = 0;
        this.lastError = 0;
        this.integral = 0;
        this.lastUpdateTime = Date.now();
    }

    update(setpoint, currentValue) {
        const now = Date.now();
        const deltaTime = (now - this.lastUpdateTime) / 1000; // Convertir a segundos
        this.lastUpdateTime = now;
        // Asegurarse de que estamos actualizando en el tiempo de muestreo establecido
        if (deltaTime >= this.sampleTime) {
            const error = setpoint - currentValue;
            // Término proporcional
            const P = this.kp * error;
            // Término integral
            this.integral += error * deltaTime;
            this.integral = Math.max(Math.min(this.integral, this.integralLimit), -this.integralLimit); // Limitar el término integral
            const I = this.ki * this.integral;
            // Término derivativo
            const derivative = (error - this.lastError) / deltaTime;
            const D = this.kd * derivative;
            // Actualizar último error
            this.lastError = error;
            return P + I + D;
        } else {
            return 0; // No hay cambio en la salida si no ha pasado el tiempo de muestreo
        }
    }
}

// Ejemplo de uso del controlador PID
const pid = new PIDController(0.1, 0.01, 0.1, 1, 10); // Ejemplo de parámetros
const setpoint = 100;
let currentValue = 90;

// Suponer que esta función se llama repetidamente, por ejemplo, en un bucle o con setInterval
function loop() {
    const control = pid.update(setpoint, currentValue);
    console.log("Control output:", control);
    // Aquí iría la lógica para actualizar el 'currentValue' basado en la salida del controlador
}
// Suponiendo un bucle de control que se actualiza cada segundo
setInterval(loop, 1000);

C++

#include <iostream>
#include <chrono>
#include <thread>

class PIDController {
private:
    double kp; // Coeficiente proporcional
    double ki; // Coeficiente integral
    double kd; // Coeficiente derivativo
    double sampleTime; // Tiempo de muestreo en segundos
    double integralLimit; // Límite para prevenir el windup
    double lastError;
    double integral;
    std::chrono::steady_clock::time_point lastUpdateTime;

public:
    PIDController(double kp, double ki, double kd, double sampleTime, double integralLimit)
        : kp(kp), ki(ki), kd(kd), sampleTime(sampleTime), integralLimit(integralLimit),
          lastError(0), integral(0) {
        lastUpdateTime = std::chrono::steady_clock::now();
    }
    double update(double setpoint, double currentValue) {
        auto now = std::chrono::steady_clock::now();
        std::chrono::duration<double> elapsed = now - lastUpdateTime;
        if (elapsed.count() >= sampleTime) {
            lastUpdateTime = now;
            double error = setpoint - currentValue;
            // Término proporcional
            double P = kp * error;
            // Término integral
            integral += error * elapsed.count();
            integral = std::max(std::min(integral, integralLimit), -integralLimit);
            double I = ki * integral;
            // Término derivativo
            double derivative = (error - lastError) / elapsed.count();
            double D = kd * derivative;
            // Actualizar último error
            lastError = error;
            return P + I + D;
        } else {
            return 0; // No hay cambio en la salida si no ha pasado el tiempo de muestreo
        }
    }
};

int main() {
    PIDController pid(0.1, 0.01, 0.1, 1.0, 10.0); // Ejemplo de parámetros
    double setpoint = 100;
    double currentValue = 90;

    while (true) {
        double control = pid.update(setpoint, currentValue);
        std::cout << "Control output: " << control << std::endl;
        // Aquí iría la lógica para actualizar el 'currentValue' basado en la salida del controlador
        std::this_thread::sleep_for(std::chrono::seconds(1)); // Espera un segundo antes de la próxima actualización
    }

    return 0;
}

C#

using System;
using System.Threading;

public class PIDController
{
    private double kp; // Coeficiente proporcional
    private double ki; // Coeficiente integral
    private double kd; // Coeficiente derivativo
    private int sampleTime; // Tiempo de muestreo en milisegundos
    private double integralLimit; // Límite para prevenir el windup
    private double lastError;
    private double integral;
    private DateTime lastUpdateTime;

    public PIDController(double kp, double ki, double kd, int sampleTime, double integralLimit)
    {
        this.kp = kp;
        this.ki = ki;
        this.kd = kd;
        this.sampleTime = sampleTime;
        this.integralLimit = integralLimit;
        this.lastError = 0;
        this.integral = 0;
        this.lastUpdateTime = DateTime.Now;
    }

    public double Update(double setpoint, double currentValue)
    {
        var now = DateTime.Now;
        var timeChange = (now - lastUpdateTime).TotalMilliseconds;
        if (timeChange >= sampleTime)
        {
            lastUpdateTime = now;
            double error = setpoint - currentValue;
            // Término proporcional
            double P = kp * error;
            // Término integral
            integral += error * (timeChange / 1000.0); // Convertir a segundos
            integral = Math.Max(Math.Min(integral, integralLimit), -integralLimit);
            double I = ki * integral;
            // Término derivativo
            double derivative = (error - lastError) / (timeChange / 1000.0);
            double D = kd * derivative;
            // Actualizar último error
            lastError = error;
            return P + I + D;
        }
        else
        {
            return 0; // No hay cambio en la salida si no ha pasado el tiempo de muestreo
        }
    }
}

class Program
{
    static void Main()
    {
        PIDController pid = new PIDController(0.1, 0.01, 0.1, 1000, 10.0); // Ejemplo de parámetros
        double setpoint = 100;
        double currentValue = 90;
        while (true)
        {
            double control = pid.Update(setpoint, currentValue);
            Console.WriteLine("Control output: " + control);
            // Aquí iría la lógica para actualizar el 'currentValue' basado en la salida del controlador
            Thread.Sleep(100); // Espera un poco antes de la próxima actualización
        }
    }
}

PHP

<?php

class PIDController {
    private $kp; // Coeficiente proporcional
    private $ki; // Coeficiente integral
    private $kd; // Coeficiente derivativo
    private $sampleTime; // Tiempo de muestreo en segundos
    private $integralLimit; // Límite para prevenir el windup
    private $lastError;
    private $integral;
    private $lastUpdateTime;

    public function __construct($kp, $ki, $kd, $sampleTime, $integralLimit) {
        $this->kp = $kp;
        $this->ki = $ki;
        $this->kd = $kd;
        $this->sampleTime = $sampleTime;
        $this->integralLimit = $integralLimit;
        $this->lastError = 0;
        $this->integral = 0;
        $this->lastUpdateTime = microtime(true);
    }

    public function update($setpoint, $currentValue) {
        $now = microtime(true);
        $timeChange = $now - $this->lastUpdateTime;

        if ($timeChange >= $this->sampleTime) {
            $this->lastUpdateTime = $now;
            $error = $setpoint - $currentValue;
            // Término proporcional
            $P = $this->kp * $error;
            // Término integral
            $this->integral += $error * $timeChange;
            $this->integral = max(min($this->integral, $this->integralLimit), -$this->integralLimit);
            $I = $this->ki * $this->integral;
            // Término derivativo
            $derivative = ($error - $this->lastError) / $timeChange;
            $D = $this->kd * $derivative;
            // Actualizar último error
            $this->lastError = $error;
            return $P + $I + $D;
        } else {
            return 0; // No hay cambio en la salida si no ha pasado el tiempo de muestreo
        }
    }
}

// Ejemplo de uso del controlador PID
$pid = new PIDController(0.1, 0.01, 0.1, 1, 10);
$setpoint = 100;
$currentValue = 90;
// En un entorno de script PHP, el siguiente bucle no sería práctico.
// En un entorno de servidor web, la lógica de actualización debería ser gestionada de manera diferente.
while (true) {
    $control = $pid->update($setpoint, $currentValue);
    echo "Control output: " . $control . "\n";
    usleep(100000); // Espera 0.1 segundos (100000 microsegundos)
}

R

#include <iostream>
#include <chrono>
#include <thread>

class PIDController {
private:
    double kp; // Coeficiente proporcional
    double ki; // Coeficiente integral
    double kd; // Coeficiente derivativo
    double sampleTime; // Tiempo de muestreo en segundos
    double integralLimit; // Límite para prevenir el windup
    double lastError;
    double integral;
    std::chrono::steady_clock::time_point lastUpdateTime;

public:
    PIDController(double kp, double ki, double kd, double sampleTime, double integralLimit)
        : kp(kp), ki(ki), kd(kd), sampleTime(sampleTime), integralLimit(integralLimit),
          lastError(0), integral(0) {
        lastUpdateTime = std::chrono::steady_clock::now();
    }

    double update(double setpoint, double currentValue) {
        auto now = std::chrono::steady_clock::now();
        std::chrono::duration<double> elapsed = now - lastUpdateTime;
        if (elapsed.count() >= sampleTime) {
            lastUpdateTime = now;
            double error = setpoint - currentValue;
            // Término proporcional
            double P = kp * error;
            // Término integral
            integral += error * elapsed.count();
            integral = std::max(std::min(integral, integralLimit), -integralLimit);
            double I = ki * integral;
            // Término derivativo
            double derivative = (error - lastError) / elapsed.count();
            double D = kd * derivative;
            // Actualizar último error
            lastError = error;
            return P + I + D;
        } else {
            return 0; // No hay cambio en la salida si no ha pasado el tiempo de muestreo
        }
    }
};

int main() {
    PIDController pid(0.1, 0.01, 0.1, 1.0, 10.0); // Ejemplo de parámetros
    double setpoint = 100;
    double currentValue = 90;

    while (true) {
        double control = pid.update(setpoint, currentValue);
        std::cout << "Control output: " << control << std::endl;
        // Aquí iría la lógica para actualizar el 'currentValue' basado en la salida del controlador
        std::this_thread::sleep_for(std::chrono::seconds(1)); // Espera un segundo antes de la próxima actualización
    }
    return 0;
}

Typescript

class PIDController {
    private kp: number; // Coeficiente proporcional
    private ki: number; // Coeficiente integral
    private kd: number; // Coeficiente derivativo
    private sampleTime: number; // Tiempo de muestreo en milisegundos
    private integralLimit: number; // Límite para prevenir el windup
    private lastError: number;
    private integral: number;
    private lastUpdateTime: number;

    constructor(kp: number, ki: number, kd: number, sampleTime: number, integralLimit: number) {
        this.kp = kp;
        this.ki = ki;
        this.kd = kd;
        this.sampleTime = sampleTime;
        this.integralLimit = integralLimit;
        this.lastError = 0;
        this.integral = 0;
        this.lastUpdateTime = Date.now();
    }

    public update(setpoint: number, currentValue: number): number {
        const now = Date.now();
        const deltaTime = now - this.lastUpdateTime;
        if (deltaTime >= this.sampleTime) {
            this.lastUpdateTime = now;
            const error = setpoint - currentValue;
            // Término proporcional
            const P = this.kp * error;
            // Término integral
            this.integral += error * (deltaTime / 1000); // Convertir a segundos
            this.integral = Math.max(Math.min(this.integral, this.integralLimit), -this.integralLimit);
            const I = this.ki * this.integral;
            // Término derivativo
            const derivative = (error - this.lastError) / (deltaTime / 1000);
            const D = this.kd * derivative;
            // Actualizar último error
            this.lastError = error;
            return P + I + D;
        } else {
            return 0; // No hay cambio en la salida si no ha pasado el tiempo de muestreo
        }
    }
}

// Ejemplo de uso
const pid = new PIDController(0.1, 0.01, 0.1, 1000, 10.0);
const setpoint = 100;
let currentValue = 90;

// Simulación de un bucle de control
setInterval(() => {
    const control = pid.update(setpoint, currentValue);
    console.log("Control output:", control);
    // Aquí iría la lógica para actualizar el 'currentValue' basado en la salida del controlador
}, 100);

Swift

import Foundation

class PIDController {
    private var kp: Double // Coeficiente proporcional
    private var ki: Double // Coeficiente integral
    private var kd: Double // Coeficiente derivativo
    private var sampleTime: TimeInterval // Tiempo de muestreo en segundos
    private var integralLimit: Double // Límite para prevenir el windup
    private var lastError: Double
    private var integral: Double
    private var lastUpdateTime: Date

    init(kp: Double, ki: Double, kd: Double, sampleTime: TimeInterval, integralLimit: Double) {
        self.kp = kp
        self.ki = ki
        self.kd = kd
        self.sampleTime = sampleTime
        self.integralLimit = integralLimit
        self.lastError = 0
        self.integral = 0
        self.lastUpdateTime = Date()
    }

    func update(setpoint: Double, currentValue: Double) -> Double {
        let now = Date()
        let timeChange = now.timeIntervalSince(lastUpdateTime)
        if timeChange >= sampleTime {
            lastUpdateTime = now
            let error = setpoint - currentValue
            // Término proporcional
            let P = kp * error
            // Término integral
            integral += error * timeChange
            integral = max(min(integral, integralLimit), -integralLimit)
            let I = ki * integral
            // Término derivativo
            let derivative = (error - lastError) / timeChange
            let D = kd * derivative
            // Actualizar último error
            lastError = error
            return P + I + D
        } else {
            return 0 // No hay cambio en la salida si no ha pasado el tiempo de muestreo
        }
    }
}

// Ejemplo de uso
let pid = PIDController(kp: 0.1, ki: 0.01, kd: 0.1, sampleTime: 1.0, integralLimit: 10.0)
let setpoint = 100.0
var currentValue = 90.0

// Bucle de control (simulación)
Timer.scheduledTimer(withTimeInterval: 0.1, repeats: true) { timer in
    let control = pid.update(setpoint: setpoint, currentValue: currentValue)
    print("Control output: \(control)")
    // Aquí iría la lógica para actualizar el 'currentValue' basado en la salida del controlador
}

Objetive-C

#import <Foundation/Foundation.h>

@interface PIDController : NSObject {
    double kp; // Coeficiente proporcional
    double ki; // Coeficiente integral
    double kd; // Coeficiente derivativo
    NSTimeInterval sampleTime; // Tiempo de muestreo en segundos
    double integralLimit; // Límite para prevenir el windup
    double lastError;
    double integral;
    NSDate *lastUpdateTime;
}

- (id)initWithKp:(double)kp ki:(double)ki kd:(double)kd sampleTime:(NSTimeInterval)sampleTime integralLimit:(double)integralLimit;
- (double)updateWithSetpoint:(double)setpoint currentValue:(double)currentValue;
@end
@implementation PIDController

- (id)initWithKp:(double)kpValue ki:(double)kiValue kd:(double)kdValue sampleTime:(NSTimeInterval)sampleTimeValue integralLimit:(double)integralLimitValue {
    self = [super init];
    if (self) {
        kp = kpValue;
        ki = kiValue;
        kd = kdValue;
        sampleTime = sampleTimeValue;
        integralLimit = integralLimitValue;
        lastError = 0;
        integral = 0;
        lastUpdateTime = [NSDate date];
    }
    return self;
}

- (double)updateWithSetpoint:(double)setpoint currentValue:(double)currentValue {
    NSDate *now = [NSDate date];
    NSTimeInterval timeChange = [now timeIntervalSinceDate:lastUpdateTime];
    if (timeChange >= sampleTime) {
        lastUpdateTime = now;
        double error = setpoint - currentValue;
        // Término proporcional
        double P = kp * error;
        // Término integral
        integral += error * timeChange;
        integral = MAX(MIN(integral, integralLimit), -integralLimit);
        double I = ki * integral;
        // Término derivativo
        double derivative = (error - lastError) / timeChange;
        double D = kd * derivative;
        // Actualizar último error
        lastError = error;
        return P + I + D;
    } else {
        return 0; // No hay cambio en la salida si no ha pasado el tiempo de muestreo
    }
}

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        PIDController *pid = [[PIDController alloc] initWithKp:0.1 ki:0.01 kd:0.1 sampleTime:1.0 integralLimit:10.0];
        double setpoint = 100.0;
        double currentValue = 90.0;
        // Bucle de control (simulación)
        while (true) {
            double control = [pid updateWithSetpoint:setpoint currentValue:currentValue];
            NSLog(@"Control output: %f", control);
            [NSThread sleepForTimeInterval:0.1]; // Espera un poco antes de la próxima actualización
            // Aquí iría la lógica para actualizar el 'currentValue' basado en la salida del controlador
        }
    }
    return 0;
}