Objetivo. Basado en este proyecto construir prototipo de regulación de velocidad de motor empleando encoder óptico como sensor de velocidad, y realizar su




descargar 192.97 Kb.
títuloObjetivo. Basado en este proyecto construir prototipo de regulación de velocidad de motor empleando encoder óptico como sensor de velocidad, y realizar su
página1/4
fecha de publicación20.12.2015
tamaño192.97 Kb.
tipoDocumentos
med.se-todo.com > Derecho > Documentos
  1   2   3   4
Proyecto Control P+I+D

Objetivo.- Basado en este proyecto construir prototipo de regulación de velocidad de motor empleando encoder óptico como sensor de velocidad, y realizar su calibración de parámetros de los modos de control (Sintonización).
« Arduino Uno Keeps Header Offset

Improving the Beginner’s PID – Sample Time »

Improving the Beginner’s PID – Introduction

In conjunction with the release of the new Arduino PID Library I’ve decided to release this series of posts. The last library, while solid, didn’t really come with any code explanation. This time around the plan is to explain in great detail why the code is the way it is. I’m hoping this will be of use to two groups of people:

  • People directly interested in what’s going on inside the Arduino PID library will get a detailed explanation.

  • Anyone writing their own PID algorithm can take a look at how I did things and borrow whatever they like.

It’s going to be a tough slog, but I think I found a not-too-painful way to explain my code.  I’m going to start with what I call “The Beginner’s PID.”  I’ll then improve it step-by-step until we’re left with an efficient, robust pid algorithm.

The Beginner’s PID

Here’s the PID equation as everyone first learns it:



This leads pretty much everyone to write the following PID controller:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

/*working variables*/

unsigned long lastTime;

double Input, Output, Setpoint;

double errSum, lastErr;

double kp, ki, kd;

void Compute()

{

   /*How long since we last calculated*/

   unsigned long now = millis();

   double timeChange = (double)(now - lastTime);

  

   /*Compute all the working error variables*/

   double error = Setpoint - Input;

   errSum += (error * timeChange);

   double dErr = (error - lastErr) / timeChange;

  

   /*Compute PID Output*/

   Output = kp * error + ki * errSum + kd * dErr;

  

   /*Remember some variables for next time*/

   lastErr = error;

   lastTime = now;

}

  

void SetTunings(double Kp, double Ki, double Kd)

{

   kp = Kp;

   ki = Ki;

   kd = Kd;

}

Compute() is called either regularly or irregularly, and it works pretty well. This series isn’t about “works pretty well” though. If we’re going to turn this code into something on par with industrial PID controllers, we’ll have to address a few things:

  1. Sample Time - The PID algorithm functions best if it is evaluated at a regular interval. If the algorithm is aware of this interval, we can also simplify some of the internal math.

  2. Derivative Kick - Not the biggest deal, but easy to get rid of, so we’re going to do just that.

  3. On-The-Fly Tuning Changes - A good PID algorithm is one where tuning parameters can be changed without jolting the internal workings.

  4. Reset Windup Mitigation -We’ll go into what Reset Windup is, and implement a solution with side benefits

  5. On/Off (Auto/Manual) - In most applications, there is a desire to sometimes turn off the PID controller and adjust the output by hand, without the controller interfering

  6. Initialization - When the controller first turns on, we want a “bumpless transfer.” That is, we don’t want the output to suddenly jerk to some new value

  7. Controller Direction - This last one isn’t a change in the name of robustness per se. it’s designed to ensure that the user enters tuning parameters with the correct sign.

Once we’ve addressed all these issues, we’ll have a solid PID algorithm. We’ll also, not coincidentally, have the code that’s being used in the lastest version of the Arduino PID Library. So whether you’re trying to write your own algorithm, or trying to understand what’s going on inside the PID library, I hope this helps you out. Let’s get started.
Next >>

UPDATE: In all the code examples I’m using doubles. On the Arduino, a double is the same as a float (single precision.) True double precision is WAY overkill for PID. If the language you’re using does true double precision, I’d recommend changing all doubles to floats.

…………………….

http://www.arduino.cc/playground/Code/PIDLibrary

PID Library

/********************************************************

* PID Basic Example

* Reading analog input 0 to control analog PWM output 3

********************************************************/
#include

//Define Variables we'll be connecting to

double Setpoint, Input, Output;
//Specify the links and initial tuning parameters

PID myPID(&Input, &Output, &Setpoint,2,5,1, DIRECT);
void setup()

{

//initialize the variables we're linked to

Input = analogRead(0);

Setpoint = 100;
//turn the PID on

myPID.SetMode(AUTOMATIC);

}
void loop()

{

Input = analogRead(0);

myPID.Compute();

analogWrite(3,Output);

}

…………………

PID Library

/********************************************************

* PID Adaptive Tuning Example

* One of the benefits of the PID library is that you can

* change the tuning parameters at any time. this can be

* helpful if we want the controller to be agressive at some

* times, and conservative at others. in the example below

* we set the controller to use Conservative Tuning Parameters

* when we're near setpoint and more agressive Tuning

* Parameters when we're farther away.

********************************************************/
#include

//Define Variables we'll be connecting to

double Setpoint, Input, Output;
//Define the aggressive and conservative Tuning Parameters

double aggKp=4, aggKi=0.2, aggKd=1;

double consKp=1, consKi=0.05, consKd=0.25;
//Specify the links and initial tuning parameters

PID myPID(&Input, &Output, &Setpoint, consKp, consKi, consKd, DIRECT);
void setup()

{

//initialize the variables we're linked to

Input = analogRead(0);

Setpoint = 100;
//turn the PID on

myPID.SetMode(AUTOMATIC);

}
void loop()

{

Input = analogRead(0);
double gap = abs(Setpoint-Input); //distance away from setpoint

if(gap<10)

{ //we're close to setpoint, use conservative tuning parameters

myPID.SetTunings(consKp, consKi, consKd);

}

else

{

//we're far from setpoint, use aggressive tuning parameters

myPID.SetTunings(aggKp, aggKi, aggKd);

}
myPID.Compute();

analogWrite(3,Output);

}



Como ya sabrán la mayoría de los que leen este blog a diario, el algoritmo PID (o Proporcional Integral Derivativo), es un elemento bastante usado en sistemas autómatas (de una manera u otra), en los cuales este algoritmo cobra bastante importancia en las funciones de re-alimentación, además de provocar que la curva de respuesta sea mucho mas suave que si usamos un sistema alternativo.

La idea es haceros un poco de resumen sobre el panorama de librerías ya diseñadas que nos permitan crear un control PID sencillo (relativamente), sin tener que programarlo desde 0.

Arduino no se queda atrás!

El PID tiene una fórmula, ecuación, expresión, que nos permite calcular los parámetros de salida, a partir de unos dados, básicamente es esta:



Y ahora, vayámonos con la lib de arduino!

ARDUINO PID LIBRARY

Cita de wikipedia

"Un PID (Proporcional Integral Derivativo) es un mecanismo de control por realimentación que calcula la desviación o error entre un valor medido y el valor que se quiere obtener, para aplicar una acción correctora que ajuste el proceso."

Funciones

PID()

Compute()

SetMode()

SetOutputLimits()

SetTunings()

SetSampleTime()

SetControllerDirection()

Ejemplo básico:

view plaincopy to clipboardprint?

  1. /********************************************************  

  2.  * PID Basic Example  

  3.  * Reading analog input 0 to control analog PWM output 3  

  4.  ********************************************************/  

  5.   

  6. #include    

  7.   

  8. //Define Variables we'll be connecting to   

  9. double Setpoint, Input, Output;   

  10.   

  11. //Specify the links and initial tuning parameters   

  12. PID myPID(&Input, &Output, &Setpoint,2,5,1, DIRECT);   

  13.   

  14. void setup()   

  15. {   

  16.   //initialize the variables we're linked to   

  17.   Input = analogRead(0);   

  18.   Setpoint = 100;   

  19.   

  20.   //turn the PID on   

  21.   myPID.SetMode(AUTOMATIC);   

  22. }   

  23.   

  24. void loop()   

  25. {   

  26.   Input = analogRead(0);   

  27.   myPID.Compute();   

  28.   analogWrite(3,Output);   

  29. }  

/********************************************************

* PID Basic Example

* Reading analog input 0 to control analog PWM output 3

********************************************************/
#include
//Define Variables we'll be connecting to

double Setpoint, Input, Output;
//Specify the links and initial tuning parameters

PID myPID(&Input, &Output, &Setpoint,2,5,1, DIRECT);
void setup()

{

//initialize the variables we're linked to

Input = analogRead(0);

Setpoint = 100;
//turn the PID on

myPID.SetMode(AUTOMATIC);

}
void loop()

{

Input = analogRead(0);

myPID.Compute();

analogWrite(3,Output);

}
Enlaces

Descarga la última versión

Página de ejemplos

Página oficial en background de Arduino (Con 2 ejemplos mas!)

Explicacíon de la librería y el PID por el autor de dicha libreria


-----------------

Programa de ejemplo de control PID en VB6

Publicado por Oscar Gonzalez en Programación el 08/02/2011 (18:50)
Etiquetas: programa, ejemplo, pid, vb6, quadcopter
. 3 comentarios



Si estás desarrollando un quadcopter pero te encuentras ya con el "problema" de la calibración del control PID estás de suerte. He encontrado un interesante enlace al código fuente de un pequeño programa hecho en Visual Basic 6 que muestra en todo su esplendor cómo funciona un control PID.

Un PID (Proporcional Integral Derivativo) es un mecanismo de control por realimentación que calcula la desviación o error entre un valor medido y el valor que se quiere obtener. Es básicamente lo que se utiliza para la estabilización de quadcopters, hexacopters etc. Para entender cómo funciona y sobre todo cómo reacciona cambiando sus parámetros de control, la aplicación simula un tanque con una entrada de líquido, una salida y un nivel de líquido que queremos mantener. En función del calculo y modificación de las tres variables del PID (Proporcional, Integral y Derivada), podremos ver las distintas respuestas del algoritmo y entenderemos qué hace cada parámetro. Es interesante ver la respuesta del ciclo de llenado/vaciado según vamos modificando las variables y nos puede dar una idea de la respuesta que queremos para nuestro objeto volador.

No os perdais el enlace y ya me contareis qué tal! ;)



  1   2   3   4

similar:

Objetivo. Basado en este proyecto construir prototipo de regulación de velocidad de motor empleando encoder óptico como sensor de velocidad, y realizar su iconS: a V= K[A [B]; b mol/l s; l2/i aumenta el volumen, disminuyen las...

Objetivo. Basado en este proyecto construir prototipo de regulación de velocidad de motor empleando encoder óptico como sensor de velocidad, y realizar su icon1. Características del funcionamiento de un Variador de Velocidad de un motor C. C

Objetivo. Basado en este proyecto construir prototipo de regulación de velocidad de motor empleando encoder óptico como sensor de velocidad, y realizar su iconQ, que se desplaza a una velocidad, sufre los efectos de una fuerza...

Objetivo. Basado en este proyecto construir prototipo de regulación de velocidad de motor empleando encoder óptico como sensor de velocidad, y realizar su iconEl prototipo didáctico que diseñamos es para estudiar divertido y...

Objetivo. Basado en este proyecto construir prototipo de regulación de velocidad de motor empleando encoder óptico como sensor de velocidad, y realizar su iconTesis programacion de un prototipo de robot movil basado en pic’S

Objetivo. Basado en este proyecto construir prototipo de regulación de velocidad de motor empleando encoder óptico como sensor de velocidad, y realizar su iconArrhenius dedujo que la expresión de la velocidad puede escribirse...

Objetivo. Basado en este proyecto construir prototipo de regulación de velocidad de motor empleando encoder óptico como sensor de velocidad, y realizar su iconResumen El objetivo de este artículo es realizar un análisis conceptual...

Objetivo. Basado en este proyecto construir prototipo de regulación de velocidad de motor empleando encoder óptico como sensor de velocidad, y realizar su iconInvestigación. Velocidad

Objetivo. Basado en este proyecto construir prototipo de regulación de velocidad de motor empleando encoder óptico como sensor de velocidad, y realizar su iconResumen se sintetizó el complejo de ditizonato de mercurio (II) y...

Objetivo. Basado en este proyecto construir prototipo de regulación de velocidad de motor empleando encoder óptico como sensor de velocidad, y realizar su iconConcepto de velocidad de reacción


Medicina



Todos los derechos reservados. Copyright © 2015
contactos
med.se-todo.com