UNIVERSIDAD NACIONAL DEL CALLAO

FACULTAD DE ELECTRICA Y ELECTRONICA

LABORATORIO DE CONTROL DIGITAL

PROYECTO: CONTROL PID –AVANCE FINAL DEL PROYECTO

BALANCÍN

EVALUACION
CODIGO NOMBRE SUST
PREVIO FINAL NOTA
.

ACARLEY LEYVA HANDERLEY

1413220175

ALVINO COYCA HENRY

1413220083

1413220339 RIOS MOLINA MICHAEL EDWIN

Horario Grupo Fecha

_______________________
90G 11/09/2017
Docente

Observaciones:

P á g i n a 1 | 22
Contenido
UNIVERSIDAD NACIONAL DEL CALLAO .......................................................................... 1
FACULTAD DE ELECTRICA Y ELECTRONICA ................................................................. 1
LABORATORIO DE CONTROL DIGITAL............................................................................. 1
PROYECTO: CONTROL PID – TERCER AVANCE DEL PROYECTO ........................... 1
BALANCÍN .................................................................................................................................. 1
....................................................................................................................................................... 1
Observaciones: ........................................................................................................................... 1
I. Resumen: .......................................................................................................................... 3
II. Objetivos: .......................................................................................................................... 3
III. Materiales: .................................................................................................................... 3
IV. Reglas para sintonizar controladores PID de Ziegler-Nichols ..................................... 4
V. Descripción del problema.............................................................................................. 5-5
VI. Modelo Matemático .................................................................................................. 6-6
VII. ensamblado del proyecto ......................................................................................... 9-8
VIII. diagrama de conexion .............................................................................................. 133
VIII. Programación en Arduino ................................................................................... 133-20
IX. Programación en Processing ................................................................................... 221
X. Bibliografía ...................................................................................................................... 22

P á g i n a 2 | 22
I. Resumen:

En el presente proyecto se pretende controlar la posición de un sistema mediante

el uso de la herramienta simulink de Matlab. El sistema consta de dos motores
instalados a modo de balancín, los cuales serán responsables de los cambios de
posición de nuestro sistema. Para controlar el motor y visualizar un circuito se
utilizará un montaje que incluirá una tarjeta de Arduino Uno.
II. Objetivos:

 Conocer el funcionamiento de las tarjetas arduino y su entorno.

 Conocer las posibilidades de manejo de nuestro sistema mediante la herramienta
simulink.
 Conocer los pasos a seguir para la instalación del software necesario para el
funcionamiento del sistema en cualquier equipo.
 Obtención del modelo matemático del sistema a través de las leyes físicas y con datos
extraídos de ensayos.
 Elaboración de un sistema en lazo cerrado con un controlador PID, que controle de
una forma correcta la posición del balancín ante posibles perturbaciones ajenas al
sistema.
 Identificar los parámetros de un controlador PID a través del método Ziegler-Nicholls.
 Introducción de mejoras que haga nuestro sistema más estable y fiable.

III. Materiales:
Producto Cantidad Precio Vista de materiales
Arduino UNO 1 S/. 35

Driver l298 1 S/. 14

Baterías 9v 2 S/. 8

Chasis de 1 S/. 10
robot

Motores 2 S/. 20
llantas 2 S/. 10

P á g i n a 3 | 22
 MPU6050 1 S/. 16
(acelerómetro y
giroscopio)

IV. Reglas para sintonizar controladores PID de Ziegler-Nichols

Ziegler y Nichols propusieron unas reglas para determinar los valores de
ganancia proporcional 𝐾𝑝, del tiempo integral 𝑇𝑖 y del tiempo derivativo Td.
Existen dos métodos denominados reglas de sintonización de Ziegler-
Nichols. En ambas se pretende obtener un 25% de sobrepaso máximo en
la respuesta escalón.

Primer método

La respuesta de la planta a una entrada escalón unitario se obtiene de

manera experimental. Si la planta no contiene integradores ni polos
dominantes complejos conjugados, la curva de respuesta escalón unitario
puede tener forma de 𝑆 (si la respuesta no exhibe una curva con forma de
𝑆, este método no es pertinente). Tales curvas de respuesta escalón se
generan experimentalmente o a partir de una simulación dinámica de la
planta.

La curva con forma de 𝑆 se caracteriza por dos parámetros: el tiempo de

retardo 𝐿 y la constante de tiempo 𝑇. El tiempo de retardo y la constante de
tiempo se determinan dibujando una recta tangente en el punto de inflexión
de la curva con forma de 𝑆 y determinando las intersecciones de esta
tangente con el eje del tiempo y la línea 𝑐 (𝑡) = 𝐾, como se aprecia a
continuación.

Fig2. Línea tangente al punto de inflexión.

En este caso, la función de transferencia 𝐶(𝑠)/𝑈(𝑠) se aproxima mediante

un sistema de primer orden con un retardo de transporte del modo
siguiente:

𝐶(𝑠) 𝐾𝑒 −𝐿𝑠
=
𝑈(𝑠) 𝑇𝑠 + 1

Ziegler y Nichols establecieron los valores de Kp, Ti y Td de acuerdo con la siguiente

tabla.

P á g i n a 4 | 22
 Segundo método

Este método se realiza con sistema en lazo cerrado.

Primero establecemos 𝑇𝑖 = ∞ y 𝑇𝑑 = 0. Usando sólo la acción de control
proporcional, se incrementa Kp de 0 a un valor crítico 𝐾𝑐 en donde la salida
exhiba oscilaciones sostenidas (si la salida no presenta oscilaciones
sostenidas para cualquier valor que pueda tomar 𝐾𝑝, no se aplica este
método).

Fig3. Oscilaciones sostenidas.

Por tanto, la ganancia crítica 𝐾𝑐 y el periodo 𝑃𝑐 , que es el periodo de estas

oscilaciones, se determinan experimentalmente. Ziegler-Nichols sugirieron
que se establecieran los valores de los parámetros 𝐾𝑝, 𝑇𝑖 y 𝑇𝑑 de acuerdo
con la fórmula que aparece en la tabla.

V. Descripción del problema

El péndulo invertido es conocido por ser uno de los problemas más importantes
y clásicos de la teoría de control. El sistema se compone de un carro sobre el
cual se monta un péndulo que puede girar libremente. El carro deberá moverse
para compensar el desplazamiento del péndulo y mantenerlo, así, en equilibrio.

P á g i n a 5 | 22
 A B
Fig7. A) Esquema péndulo invertido. B) Ejemplo Sedway.

VI. Modelo Matemático

Fig8. Análisis de las fuerzas del sistema.

En la figura 16 se encuentra la descomposición de fuerzas del sistema, de aquí

podemos extraer las ecuaciones del sistema. La primera ecuación la obtenemos
de la suma de fuerzas horizontales de la base, que en nuestro caso corresponde
solo a las ruedas, es la siguiente:
𝑚𝑥 + 𝑏𝑥 + 𝑁 = 𝑢 … … … … … … … … (1)
La segunda ecuación la obtenemos de la suma de fuerzas horizontales del
péndulo o cuerpo, donde obtenemos la ecuación de la fuerza N:
𝑁 = 𝑀𝑥̈ + 𝑀𝐿𝜃̈ cos(𝜃) − 𝑀𝐿𝜃̇ 𝑠𝑒𝑛(𝜃) … … … … … … … … (2)
Si sustituimos la ecuación (1) en (2), obtenemos la primera ecuación del
movimiento del sistema:
(𝑀 + 𝑚)𝑥̈ + 𝑏𝑥̇ + 𝑀𝐿𝜃̈ − 𝑀𝐿𝜃̇ 2 𝑠𝑒𝑛(𝜃) = 𝑢 … … … … … … … … (3)
La tercera ecuación se obtiene de la suma de fuerzas perpendiculares al péndulo
𝑃𝐿𝑠𝑒𝑛(𝜃) + 𝑁𝐿𝑐𝑜𝑠(𝜃) − 𝑀𝑔𝐿𝑠𝑒𝑛(𝜃) = 𝑀𝐿𝜃̈ + 𝑀𝐿𝑥̈ cos(𝜃) … … … … … … … … (4)
La suma de momentos del centro de masas del péndulo es la siguiente:
−𝑃𝐿𝑠𝑒𝑛(𝜃) − 𝑁𝐿𝑐𝑜𝑠(𝜃) = 𝐼𝜃̈ … … … … … … … … (5)
Combinando las ecuaciones (4) y (5) obtenemos la segunda ecuación dinámica
del sistema:
(𝐼 + 𝑀𝐿2 )𝜃̈ + 𝑀𝑔𝐿𝑠𝑒𝑛(𝜃) = −𝑀𝐿𝑥̈ 𝑐𝑜𝑠(𝜃) … … … … … … … … (6)
Las ecuaciones del sistema (3) y (6) son no lineales, dado que para que el robot
se mantenga en equilibrio el ángulo 𝜃 se debe mantener cercano a cero,
podemos linealizar las ecuaciones en este punto para facilitar el diseño del
control.
Dado que tendremos pequeñas variaciones de 𝜃, podemos asumir que:
P á g i n a 6 | 22
 𝑠𝑒𝑛(𝜃) ≈ 𝜃 … … … … … … … … (7)
cos(𝜃) ≈ 1 … … … … … … … … (8)
𝜃̇ 2 ≈ 0 … … … … … … … … (9)
Las ecuaciones linealizadas que se obtienen son las siguientes

(𝑀 + 𝑚)𝑥̈ + 𝑏𝑥̇ + 𝑀𝐿𝜃̈ = 𝑢 … … … … … … … … (10)

(𝐼 + 𝑀𝐿)𝜃̈ − 𝑀𝑔𝐿𝜃 = −𝑀𝐿𝑥̈ … … … … … … … … (11)

Despejando 𝑥̈ y 𝜃̈ obtenemos:

−𝑀𝐿 𝑏 1
𝑥̈ = 𝜃̈ − 𝑥̇ + 𝑢 … … … … … … … … (12)
(𝑀 + 𝑚) (𝑀 + 𝑚) (𝑀 + 𝑚)

𝑀𝐿 𝑀𝑔𝐿
𝜃̈ = − 2
𝑥̈ + 𝜃 … … … … … … … … (13)
(𝐼 + 𝑀𝐿 ) (𝐼 + 𝑀𝐿2 )

Sustituyendo (12) en (11) y (13) en (10) se obtienen las siguientes ecuaciones:

𝑀𝑔𝐿(𝑀 + 𝑚) 𝑀𝐿𝑏 𝑀𝐿
𝜃̈ = 𝜃 + 𝑥̇ − 𝑢 … … (14)
𝐼(𝑀 + 𝑚) + 𝑀𝑚𝐿2 𝐼(𝑀 + 𝑚) + 𝑀𝑚𝐿2 𝐼(𝑀 + 𝑚) + 𝑀𝑚𝐿2

𝑔𝑀2 𝐿2 𝑏(𝐼 + 𝑀𝐿2 ) 𝐼 + 𝑀𝐿2

𝑥̈ = − 𝜃 − 𝑥̇ + 𝑢 … … (15)
𝐼(𝑀 + 𝑚) + 𝑀𝑚𝐿2 𝐼(𝑀 + 𝑚) + 𝑀𝑚𝐿2 𝐼(𝑀 + 𝑚) + 𝑀𝑚𝐿2

Aplicando la transformada de Laplace:

𝑀𝑔𝐿(𝑀 + 𝑚) 𝑀𝐿𝑏
𝑠 2 𝜃(𝑠) = 2
𝜃(𝑠) + 𝑠𝑋(𝑠)
𝐼(𝑀 + 𝑚) + 𝑀𝑚𝐿 𝐼(𝑀 + 𝑚) + 𝑀𝑚𝐿2
𝑀𝐿
− 𝑈(𝑠) … … (16)
𝐼(𝑀 + 𝑚) + 𝑀𝑚𝐿2

𝑔𝑀2 𝐿2 𝑏(𝐼 + 𝑀𝐿2 )

𝑠 2 𝑋(𝑠) = − 𝜃(𝑠) − 𝑠𝑋(𝑠)
𝐼(𝑀 + 𝑚) + 𝑀𝑚𝐿2 𝐼(𝑀 + 𝑚) + 𝑀𝑚𝐿2
𝐼 + 𝑀𝐿2
+ 𝑈(𝑠) … … (17)
𝐼(𝑀 + 𝑚) + 𝑀𝑚𝐿2
Sí:
ℎ1 ℎ2 ℎ3
𝑠 2 𝜃(𝑠) = 𝜃(𝑠) + 𝑠𝑋(𝑠) − 𝑈(𝑠) … … (18)
ℎ7 ℎ7 ℎ7

ℎ4 ℎ5 ℎ6
𝑠 2 𝑋(𝑠) = − 𝜃(𝑠) − 𝑠𝑋(𝑠) + 𝑈(𝑠) … … (19)
ℎ7 ℎ7 ℎ7
Donde:
ℎ1 = 𝑀𝑔𝐿(𝑀 + 𝑚) … … … … … … … … (20)
ℎ2 = 𝑀𝐿𝑏 … … … … … … … … (21)
ℎ3 = 𝑀𝐿 … … … … … … … … (22)
ℎ4 = 𝑔𝑀2 𝐿2 … … … … … … … … (23)
ℎ5 = 𝑏(𝐼 + 𝑀𝐿2 ) … … … … … … … … (24)
ℎ6 = 𝐼 + 𝑀𝐿2 … … … … … … … … (25)
ℎ7 = 𝐼(𝑀 + 𝑚) + 𝑀𝑚𝐿2 … … … … … … … … (26)

Entonces:

P á g i n a 7 | 22
 ℎ1 ℎ2 ℎ4 ℎ2 ℎ6 ℎ3
𝑠 2 𝜃(𝑠) = 𝜃(𝑠) − 2 𝜃(𝑠) + 2 𝑈(𝑠) − 𝑈(𝑠) … … … (27)
ℎ7 𝑠ℎ7 + ℎ5 ℎ7 𝑠ℎ7 + ℎ5 ℎ7 ℎ7

La función de transferencia es:

ℎ2 ℎ6 ℎ
− 3
𝜃(𝑠) 𝑠ℎ7 2 + ℎ5 ℎ7 ℎ7
𝐻(𝑠) = = … … … … … (28)
𝑈(𝑠) 𝑠 2 − ℎ1 + ℎ2 ℎ4
ℎ7 𝑠ℎ7 2 + ℎ5 ℎ7

ℎ2 ℎ6 ℎ (𝑠ℎ + ℎ5 )
− 3 7
𝜃(𝑠) 𝑠ℎ7 2 + ℎ5 ℎ7 𝑠ℎ7 2 + ℎ5 ℎ7
𝐻(𝑠) = = … … … … … (29)
𝑈(𝑠) 2 (𝑠ℎ7 + ℎ5 ) ℎ1 (𝑠ℎ7 + ℎ5 ) ℎ2 ℎ4
𝑠 − +
𝑠ℎ7 2 + ℎ5 ℎ7 𝑠ℎ7 2 + ℎ5 ℎ7 𝑠ℎ7 2 + ℎ5 ℎ7

𝜃(𝑠) ℎ2 ℎ6 − ℎ3 (𝑠ℎ7 + ℎ5 )
𝐻(𝑠) = = 2 … … … … … (30)
𝑈(𝑠) 𝑠 (𝑠ℎ7 + ℎ5 ) − ℎ1 (𝑠ℎ7 + ℎ5 ) + ℎ2 ℎ4

𝜃(𝑠) ℎ2 ℎ6 − ℎ3 (𝑠ℎ7 + ℎ5 )
𝐻(𝑠) = = 2 … … … … … (31)
𝑈(𝑠) 𝑠 (𝑠ℎ7 + ℎ5 ) − ℎ1 (𝑠ℎ7 + ℎ5 ) + ℎ2 ℎ4

𝜃(𝑠) −ℎ3 ℎ7 𝑠 + ℎ2 ℎ6 − ℎ3 ℎ5
𝐻(𝑠) = = 3 … … … … … (31)
𝑈(𝑠) 𝑠 ℎ7 + 𝑠 2 ℎ5 − 𝑠ℎ1 ℎ7 − ℎ1 ℎ5 + ℎ2 ℎ4

Reemplazando los valores se obtiene:

−2.818𝑒08𝑠 − 8.917𝑒09
𝐻(𝑠) =
𝑠^3 + 143.5 𝑠^2 + 9.29𝑒05 𝑠 + 7.261𝑒06

P á g i n a 8 | 22
VII. Ensamblado del proyecto
Paso 1: Comenzamos con las pequeñas piezas laterales que son los soportes de los motores.

PASO 1: Se coloca una tuerca para sujetar la varilla a la placa inferior y fijamos las baterías de 9v
en la base del chasis y también los tornillos de soporte.

Paso 1: colocamos los motores de las llantas debajo y a la altura de las baterías de 9v.

Paso 1: Fijamos los motores a dichas piezas con sus 2 tornillos de 1.5cm de largo y Observamos
que dicho tornillo no sobresale del lado opuesto al cual lo colocamos.

P á g i n a 9 | 22
PASO 1: Una vista más de cómo queda la rueda y las varillas montadas.

PASO 1: Procedemos a montar el arduino en la placa intermedia.

PASO 1: En la parte inferior de la placa intermedia colocamos el driver L298. También lo

sujetamos con los tornillos de 0,5 cm sin tuerca.

PASO 1: luego de colocar ambos componentes se empezara a colocar el acelerómetro.

P á g i n a 10 | 22
PASO 1: conectamos el driver ld298n y pegamos el acelerómetro encima del driver.

PASO 1: Observamos desde abajo como quedan las 3 placas montadas una vez ya instalado el
puente “h” junto con el acelerómetro MCU6050 y el microcontrolador arduino UNO.

PASO 1: cableamos todos los materiales a usar y pegamos algunos componentes extras.

P á g i n a 11 | 22
PASO 1: luego limpiamos las impurezas como residuos de pegamento y de soldadura.

PASO 1: resultado final del robot balancín con microcontrolador arduino.

P á g i n a 12 | 22
 VIII. DIAGRAMA DE CONEXIÓN

En esta imagen observamos el diagrama de conexión de los sensores.

Aclaración-1: La fuente de Alimentación puede ser una batería de 9v o un pack de

pilas x8 AA.

Aclaración-2: En caso de no estar funcionando o estar girando en sentido opuesto,

dar vuelta los cables del motor en conflicto.

Fig16. Fotografía del robot 1.

IX. Programación en Arduino

Se utilizó una programación libre para obtener los datos por los puertos analógicos del arduino
uno y mostrarlos en el monitor serial.

A continuación se mostrara las 4 etapas de control del robot balancín como es el control
P,PI,PD,PID.

Control P

P á g i n a 13 | 22
Control PD

P á g i n a 14 | 22
Control PI

P á g i n a 15 | 22
Control PID
#include "I2Cdev.h"

#include "MPU6050_6Axis_MotionApps20.h"
#if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
#include "Wire.h"
#endif

MPU6050 mpu;

#define OUTPUT_READABLE_YAWPITCHROLL
#define LED_PIN 13 // (Arduino is 13, Teensy is 11, Teensy++ is 6)
bool blinkState = false;

// MPU control/status vars

bool dmpReady = false; // set true if DMP init was successful
uint8_t mpuIntStatus; // holds actual interrupt status byte from MPU
uint8_t devStatus; // return status after each device operation (0 = success, !0 = error)
uint16_t packetSize; // expected DMP packet size (default is 42 bytes)
uint16_t fifoCount; // count of all bytes currently in FIFO
uint8_t fifoBuffer[64]; // FIFO storage buffer

// orientation/motion vars
Quaternion q; // [w, x, y, z] quaternion container
VectorInt16 aa; // [x, y, z] accel sensor measurements
VectorInt16 aaReal; // [x, y, z] gravity-free accel sensor measurements
VectorInt16 aaWorld; // [x, y, z] world-frame accel sensor measurements
VectorFloat gravity; // [x, y, z] gravity vector
float euler[3]; // [psi, theta, phi] Euler angle container
float ypr[3]; // [yaw, pitch, roll] yaw/pitch/roll container and gravity vector

// packet structure for InvenSense teapot demo

uint8_t teapotPacket[14] = { '$', 0x02, 0,0, 0,0, 0,0, 0,0, 0x00, 0x00, '\r', '\n' };
// ================================================================
// === INTERRUPT DETECTION ROUTINE ===
// ================================================================
volatile bool mpuInterrupt = false; // indicates whether MPU interrupt pin has gone high
void dmpDataReady() {
mpuInterrupt = true;
}
// ================================================================
// === INITIAL SETUP ===
// ================================================================
void setup() {
// join I2C bus (I2Cdev library doesn't do this automatically)
#if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
Wire.begin();
TWBR = 24; // 400kHz I2C clock (200kHz if CPU is 8MHz)
P á g i n a 16 | 22
 #elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE
Fastwire::setup(400, true);
#endif
Serial.begin(115200); //115200
while (!Serial); // wait for Leonardo enumeration, others continue immediately

devStatus = mpu.dmpInitialize();
mpu.setXGyroOffset(220);
mpu.setYGyroOffset(76);
mpu.setZGyroOffset(-85);
mpu.setZAccelOffset(1788); // 1688 factory default for my test chip

// make sure it worked (returns 0 if so)

if (devStatus == 0) {
// turn on the DMP, now that it's ready
Serial.println(F("Enabling DMP..."));
mpu.setDMPEnabled(true);

// enable Arduino interrupt detection

Serial.println(F("Enabling interrupt detection (Arduino external interrupt 0)..."));
attachInterrupt(0, dmpDataReady, RISING);
mpuIntStatus = mpu.getIntStatus();

// set our DMP Ready flag so the main loop() function knows it's okay to use it
Serial.println(F("DMP ready! Waiting for first interrupt..."));
dmpReady = true;

// get expected DMP packet size for later comparison

packetSize = mpu.dmpGetFIFOPacketSize();
} else {
// ERROR!
// 1 = initial memory load failed
// 2 = DMP configuration updates failed
// (if it's going to break, usually the code will be 1)
Serial.print(F("DMP Initialization failed (code "));
Serial.print(devStatus);
Serial.println(F(")"));
}

// configure LED for output

pinMode(LED_PIN, OUTPUT);
}
// ================================================================
// === MAIN PROGRAM LOOP ===
// ================================================================
void loop() {
// if programming failed, don't try to do anything
if (!dmpReady) return;

// wait for MPU interrupt or extra packet(s) available

while (!mpuInterrupt && fifoCount < packetSize) {
}

// reset interrupt flag and get INT_STATUS byte

mpuInterrupt = false;
mpuIntStatus = mpu.getIntStatus();

// get current FIFO count

fifoCount = mpu.getFIFOCount();

// check for overflow (this should never happen unless our code is too inefficient)
if ((mpuIntStatus & 0x10) || fifoCount == 1024) {
// reset so we can continue cleanly
mpu.resetFIFO();
Serial.println(F("FIFO overflow!"));

// otherwise, check for DMP data ready interrupt (this should happen frequently)
} else if (mpuIntStatus & 0x02) {

P á g i n a 17 | 22
 // wait for correct available data length, should be a VERY short wait
while (fifoCount < packetSize) fifoCount = mpu.getFIFOCount();

// read a packet from FIFO

mpu.getFIFOBytes(fifoBuffer, packetSize);

fifoCount -= packetSize;
#ifdef OUTPUT_READABLE_YAWPITCHROLL
// display Euler angles in degrees
mpu.dmpGetQuaternion(&q, fifoBuffer);
mpu.dmpGetGravity(&gravity, &q);
mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);
// Serial.print("ypr\t");
Serial.print(ypr[0] * 180/M_PI);
Serial.print(",");
Serial.print(ypr[1] * 180/M_PI);
Serial.print(",");
Serial.println(ypr[2] * 180/M_PI);
#endif

// blink LED to indicate activity

blinkState = !blinkState;
digitalWrite(LED_PIN, blinkState);
}
}

P á g i n a 18 | 22
Pasos en Matlab:

P á g i n a 19 | 22
P á g i n a 20 | 22
X. Programación en Processing
import processing.serial.*;
Serial myPort; // The serial port
float valor[];
float mx, my;

void setup () {

size(400, 400);
frameRate(200);
println(Serial.list());
valor=null;
myPort = new Serial(this,Serial.list()[0],115200);
myPort.bufferUntil('\n');
}
void draw () {
background(0);
textSize(50); //Tamaño del texto

if (valor!=null) {
//PROGRAMACION ADICIONAL PARA MOSTRAR LA TOMADA DE DATOS
/*
text('Y', 20, 100);
text(valor[0], 100, 100);
text('P', 20, 200); //Movimiento en Y
text(valor[1], 100, 200);
text('R', 20, 300); //Movimiento en X
text(valor[2], 100, 300); */

//AGREGAMOS UN OBJETO PARA VISUALIZAR EL MOVIMIENTO

my=map(valor[1],-60,60,0,400);
mx=map(valor[2],-60,60,0,400);
ellipse(mx,my,50,50); //Cambiamos el tamaño de la elipse
}
}
void serialEvent (Serial myPort) {
String inString = myPort.readStringUntil('\n');
if (inString != null) {
println(inString);
valor=float(split(inString, ','));
}
}

P á g i n a 21 | 22
XI. Bibliografía

[Anderson, 2003]
D. P. Anderson “Nbot Balancing Robot”, 2003. Disponible en
http://geology.heroy.smu.edu/~dpa-www/robo/nbot.
[Furuta, 1976]
K. Furuta, H. Nishihara and S. Mori. “Control of Unstable Mechanical Systems:
Control of Pendulum”. International Journal of Control, Vol. 23, pp. 673-692,
1976.
[Grasser, 2002]
F. Grasser, A. D’Arrigo, S. Colombi and A. Rufer. “Joe: A Mobile, Inverted
Pendulum”. Swiss Federal Institute of Technology, 2002.
http://leiwww.epfl.ch/publications/grasser_darrigo_colombi_rufer_mic_01.pdf
[Hassenplug, 2002]
S. Hassenplug. “Legway”, 2002. Disponible en
http://www.teamhassenplug.org/robots/legway.
[Hurbains, 2007]
P. Hurbain’s. “Nxtway”, 2007. http://www.philohome.com/nxtway/.
[Kosko, 1992]
Kosko B. Neural Networks and Fuzzy Systems: A Dynamical System S Approach
to Machine Intelligence Eaglewood. Prentice hall 1992
[Kuo, 1992]
Kuo, Benjamin. Digital Control Systems. Second edition. Oxford University
Press. New York. 1992
[Michigan Engineering]
http://www.engin.umich.edu/group/ctm/examples/pend/invSS.html Michigan
Engineering
[Novakowski, 2006]
N. Novakowski, "Equations os motion and control of an inverted pendulum",
Rensselaer al Harford, CT, Tech. Rep. 2006.
Control inteligente del péndulo invertido
73
[Ogata, 1997]
Ogata, Katsuhiko. Modern Control Engineering. 3º Edition. Prentice Hall. 1997
[Ooi, 2003]
R. Ooi. “Balancing a Two-Wheeled Autonomous Robot”. University of Western
Australia, 2003. Disponible en http://robotics.ee.uwa.edu.au/theses/2003-
Balance-Ooi.pdf
[Sherman, 2003]
B. Sherman. “Balibot, an Inverted Pendulum Robot”, 2003. Disponible en
http://home.comcast.net/~botronics/balibot.html.
[Stimac, 1999]
A. K. Stimac. (1999). Standup and stabilization of the inverted pendulum, B.S.
thesis, Dept. Metch. Eng., Massachusetts Inst.Technol. Cambridge, MA.

P á g i n a 22 | 22