UNIVERSIDAD NACIONA DEL CALLAO

FACULTAD DE INGENIERIA ELECTRICA Y ELECTRONICA

ESCUELA PROFESIONAL DE INGENIERIA ELECTRONICA

TEMA:
CONTROL POR REALIMENTACION DE ESTADOS

CURSO:
SISTEMAS DE CONTROL DIGITAL

DOCENTE:
ASTOCONDOR VILLAR JACOB

INTEGRANTES:
BASTIDAS SANCHEZ ANGEL ISAAC
HURTADO CHIROQUR DENNIS
VARGAS ALVAREZ ERICKA DE LOS A.
VILCA AGUILAR LIMBER

2023-II

1
CONTROL POR REALIMENTACION DE ESTADOS

Objetivo:
Implementar controladores y observadores lineales mediante la plataforma Arduino.

Descripcion de Sistema
El algoritmo de control/observación se realiza en la plataforma Arduino UNO R3 y una
planta RC-RC, con R1=R2=1 Mohm, y C1=C2=1 uf.

Una descripción del hardware usado es mostrada en la Figura siguiente.

En adición a la planta RC-RC, se usa un potenciómetro para generar la referencia

externa, un par de switches para iniciar y detener el algoritmo de control, y un par de
Leds para mostrar el estado del sistema

La lista de partes es la siguiente:

• Una placa de desarrollo Arduino UNO R3
• Un breadboard o un shield LCFIME-PCB 1.0-RC3.
• 2 resistencias de 1 Mohm.
• 2 capacitores de 1 uf.
• 1 Potenciometro 100 Kohm
• 2 resistencias 330 ohms
• 2 resistencias 4.7 kohms
• 2 Leds
• 2 Switches
Todos los componentes pueden ser montados en un breadboard de acuerdo a la
figurapresentada, o pueden ser soldados en el shield sugerido.

Descripción de IO

2
Las entradas y salidas del sistema están conectadas a los siguientes pines.
Entradas analógicas
• Pin A0. Referencia a seguir, denotado por R en el software y por r(t) en
ladescripción del algoritmo.
• Pin A1. Voltaje en el capacitor 1, denotado por X1 en el software y por x1(t)
enla descripción del algoritmo.
• Pin A2. Voltaje en el capacitor 2, denotado por X2 en el software y por x2(t)
enla descripción del algoritmo.
Salidas analógicas (PWM)
• Pin 10. Señal de control, denotado por U en el software y por ui(t) en
ladescripción del algoritmo.
Entradas discretas
• Pin 2. Entrada de arranque, denotado por SW2 en el software.
• Pin 3. Entrada de paro, denotado por SW3 en el software.
Salidas discretas
• Pin 8. Indicador LED sistema activado, denotado por LED8 en el software.
• Pin 9. Indicador LED sistema desactivado, denotado por LED9 en el software.

I. Modelado
Consideramos al voltajeui (t) que alimenta a la primer malla como la entrada de la
planta RC-RC, y al voltaje en el segundo capacitor Vc2(t) como salida. La descripción
delcircuito es mostrada a continuación.

u
y(t) PROCESO y(t)
RC-C

El modelo dinámico del circuito RC-RC es un sistema de segundo orden que puede
ser representado en espacio de estados de la manera siguiente. Primeramente, se usa
la leyde mallas de Kirchhoff:

junto con las relaciones a ser cumplidas por los capacitores:

por lo tanto

Re escribiendo las ecuaciones de malla en función de los voltajes en los

capacitores y sus derivadas:

3
y acomodando en forma matricial, se tiene

Considerando la inversa:

el sistema queda representado por

Definiendo las variables de estado como sigue;

el modelo en espacio de estados es:

donde x1(t) es el voltaje en el primer capacitor (conectado al pin A1), x2(t) el voltaje en
el segundo (conectado al pin A2), u(t) es la entrada a la planta (conectado al pin 10),
y y(t) la salida de la planta (conectado al pin A2).

De manera abreviada, el sistema se describirá de aquí en adelante en formato

matricialpor:

Donde

II. Diseño del controlador por realimentación de polos

En todos los algoritmos descritos, los cálculos de las ganancias se realizan de
manerasimbólica, quedando expresadas las ganancias de controladores y
observadores en

4
función de los parámetros del sistema, y las posiciones deseadas para los
valorespropios.
Regulador por retroalimentación de estado
Se considera la ley de control

Donde K=[k1 k2] es tal que (A−B*K) cumple con cierto polinomio característico
deseado. Iniciamos resolviendo el problema de regulación considerando K=△[k1 k2].

El polinomio característico de lazo cerrado (obtenido de manera simbólica) para

elsistema RC-RC queda descrito por:

Considerando que los valores propios deseados de lazo cerrado

como −a1,−a2 y a1>0, a2>0. El polinomio característico deseado queda descrito por:

Los valores de k1 y k2 se obtienen de igualar ambos polinomios coeficiente por

coeficiente. Para el término lineal se tiene:

mientras que para el término independeinte se tiene

Por lo tanto, las siguientes expresiones para el par k1,k2 pueden ser obtenidas:

5
 III. PROGRAMACION

Se realiza el programa para realizar pruebas en lazo abierto de la

plantaCódigo:
/ Entrada-Salida de circuito RC-RC
// Ley de control U = R
// ******************************************************** //
//---------- Muestreo --------// //
// ******************************************************** // unsigned long
TS = 50; // Muestreo TS miliseg //
float Tseg = 0.05; // Muestreo en Tseg segundos //
// ******************************************************** //

//---------- Definición Pines IO analógicos //

#define pR 0 // pin de referencia
#define pX1 1 // pin de estado 1
#define pX2 2 // pin de estado 2
#define pU 10 // pin de salida de control (entrada a planta)

//---------- Definición Pines IO discretos //

#define pLED8 8 // LED 8 en
tarjeta #define pLED9 9 // LED
9 en tarjeta #define pSW2 2 // SW 2
en tarjeta #define pSW3 3 // SW 3
en tarjeta

//---------- Escalamientos para analogicas de 0 a 5 V //

#define mX 0.004882813 // Pendiente 0 1023 -> 0 - 5
#define bX 0 // Ajuste cero para 0 1023 -> 0 - 5
#define mU 51 // Pendiente 0- 5 -> 0 - 255
#define bU 0 // Ajuste cero 0 - 5 -> 0 - 1023

// ******************************************************** //
// ---------- Variables globales
// ******************************************************** //

// Tiempo //
unsigned long TS_code = 0; // Tiempo que tarda
programa unsigned long TIC = 0; // Estampa de
tiempo inicio ciclos unsigned long TC = 0; // Faltante
para TS

// ---------- Señales //
float R = 0; // Referencia
float Y = 0; // Salida
float X1 = 0; // Estado 1
float X2 = 0; // Estado 2
float U = 0; // Salida control
int Ui = 0; // Salida control tarjeta

// Otros //
bool Habilitado = 0; // Señal {0,1} para entradas escalón

//---------- Librerias ------ //

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

6
 #include <SoftwareSerial.h>
// ******************************************************** //
//---------- Rutinia de inicio----- //
// ******************************************************** //

void setup() {
//--Inicia serial--//
Serial.begin(9600);

//--Configura pines digitales-

-// pinMode(2, INPUT);
pinMode(3, INPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
}

// ******************************************************** //
//---------- Rutinia principal --------// //
// ******************************************************** //

void loop() {
proc_entradas(); // Procesamiento de
Entradas control(); // Control
proc_salidas(); // Procesado de
Salidas coms_arduino_ide(); //
Comunicaciones
//coms_python(&R,&Y,&U);
espera();
}

//-- Control --//

void control()
{
// Ley de control
U = R; // La referencia se aplica a la entrada de la planta
// Saturacion
if(U >= 5.0) U = 5.0; // Saturacion de control en rango 0 a
5V else if(U < 0) U = 0;
}

// ******************************************************** //
//---------- Rutinias de IO y control de tiempo ---- //
// ******************************************************** //
//-- Procesado de entradas --//
void proc_entradas(){
// No se ocupa leer X1 (Vc1) porque se estima con observador
X1 = analogRead(pX1)*mX+bX; // Lectura de salida de planta en pin
pX3 X2 = analogRead(pX2)*mX+bX; // Lectura de salida de planta en
pin pX2 R = Habilitado*(analogRead(pR)*mX+bX); // Lectura de
referencia en pin pR, Y = X2;
}
//-- Procesado de salidas --//
void proc_salidas(){
Ui = int(U*mU+bU); // Escalamiento
analogWrite(pU, Ui); // Salida PWM en pin
pU botonesyleds(); // Manejo de IO
discretas
}

7
//-- Memoria {0,1} para entrada escalón --//
void botonesyleds(){

static int n = 0;
if(n >= 1000/TS) n=0; // Señal cuadrada para led
blink else n = n+1;

if(digitalRead(pSW2) == 1) Habilitado = 1; // Memoria on/off en

Habilitado else if(digitalRead(pSW3) == 1) Habilitado = 0; // Set con
SW2. Reset con SW3

if(n >= 500/TS && Habilitado == 1) digitalWrite(pLED8,HIGH); // Led blink

en LED8 else digitalWrite(pLED8, LOW); // Cuando Habilitado = 1

if(Habilitado == 0) digitalWrite(pLED9,HIGH); // LED9 = 1

else digitalWrite(pLED9, LOW); // Cuando Habilitado = 0
}

//-- Para muestreo uniforme --//

void espera(){
TS_code = millis()- TIC; // Tiempo de ciclo
TC = TS - TS_code; // Calcula altante para TS
if (TS_code < TS) delay(TC); // Espera para completar ciclo de
TS TIC = millis();
}

//-- Comunicación con monitor --//

void coms_arduino_ide(){
Serial.print("y_d(t):"); //
Referencia Serial.print(R); //
Referencia
Serial.print(","); // Separador
Serial.print("y(t):"); // Salida
Serial.println(Y); // Salida (terminar con "serial.println")
}

void coms_python(float* Rp, float* Yp, float* Up)

{
byte* byteData1 =
(byte*)(Rp); byte* byteData2
= (byte*)(Yp); byte*
byteData3 = (byte*)(Up);
byte buf[12] = {byteData1[0], byteData1[1], byteData1[2],
byteData1[3], byteData2[0], byteData2[1], byteData2[2],
byteData2[3], byteData3[0], byteData3[1], byteData3[2],
byteData3[3]};
Serial.write(buf, 12);
}

IV. PRUEBAS

8
REALIZAR LAS PRUEBAS DEL SISTEMAS

Angulo  con ganancia k

9
 CONCLUSIONES
• El control óptimo con el algoritmo específicamente funciona mejor que el vector de
retroalimentación de estados por reubicación de polos, sin embargo, no puede llevarlo al
punto de equilibrio total donde todas las variables son nulas, esto se debe básicamente
a que controla óptimamente solo al ángulo θ y no al ángulo φ
por lo que

• será necesario la implementación adicional de una etapa de seguimiento de trayectoria;

por ejemplo un controlador adaptivo difuso, para conseguir un sistema seguidor-
controlador, donde la variable a seguir sea el ángulo φ y a controlar sea la variable θ.
Para obtener un óptimo desempeño del controlador difuso es necesario conocer a fondo
los valores que tiene la planta al igual que las variables de estado,

10