Академический Документы
Профессиональный Документы
Культура Документы
DE HUAUCHINANGO
MODELADO Y CONSTRUCCIN DE UN
AEROPNDULO
INGENIERA
MECATRNICA
P
BRENDA SHANTAL
BARRAZA ACOSTA
J11312005
MODELADO Y CONSTRUCCIN DE UN
AEROPNDULO
INGENIERA
MECATRNICA
P
BRENDA SHANTAL
BARRAZA ACOSTA
J11312001
Resumen
Abstract
This work presents the procedure realized for the design and construction of a
portable aeropendulum model for laboratory use based on Matlab, Simulink and
Arduino. The purpose of building this module is to provide a device which is low
cost and easy to construct, this is for probe and simulation of controllers in real time,
based on sending PWM signals to the motor. Is described the general function of the
aeropendulum and its different parts. Also is shown the connection of the module for
a closed loop control system. Using an Arduino UNO board as data aquisition board
with connection to Matlab and Simulink.
Dedicatoria
Dedico el presente trabajo a mis padres los cuales a lo largo de mi vida han
sido mis mejores amigos, a mis hermanos por todo el apoyo y cario que me han
brindaron a lo largo de mi carrera y mi vida.
Agradecimientos
En primer lugar le agradezco a Dios por permitirme llegar hasta aqu y poder
cumplir una meta ms en mi vida.
A mis padres por todo el amor, apoyo y confianza que en mi depositaron para
poder lograr este gran reto que es terminar mi carrera profesional.
A mis hermanos por estar siempre a mi lado cuando ms los necesito.
A mi mejor amigo que siempre estuvo a mi lado en las buenas y en las malas,
apoyndome hasta el final.
A mi asesor el Dr. Gregorio por brindarme su confianza que en mi depsito y
por compartirme parte de su conocimiento en cada clase y asesora.
ndice de contenido
5
Pgina
Resumen
Abstract
Dedicatoria
Agradecimientos
Antecedentes
i
ii
iii
iv
ix
Captulo I. Introduccin
1.1 Problema a resolver
1.2 Justificacin
1.3 Objetivo general
1.4 Objetivos especficos
1.5 Aportaciones del trabajo
1.6 Estructura del trabajo
1
2
2
3
3
3
4
5
5
6
6
7
8
12
16
18
19
20
21
29
33
34
35
36
6
Conclusiones
43
Recomendaciones
44
Referencias
45
Anexos
Anexo A: Imgenes de prueba
Anexo B: Cdigo de arranque del Motor Multistar Drone
Anexo C: Cdigo del funcionamiento del Aeropndulo con control
47
48
en Arduino
Anexo D: Cdigo de limpieza de la memoria eeprom
Anexo E: Cdigo del funcionamiento del Aeropndulo Arduino-
56
Simulink
50
57
ndice de figuras
Pgina
Figura 1 Galileo Galilei
Figura 2 El fenmeno del pndulo simple
Figura 1.1 Problema a resolver
Figura 2.1 Pndulo
Figura 2.1.1 Pndulo simple
Figura 2.1.3 Pndulo fsico
ix
xi
2
4
5
6
7
7
8
9
10
10
11
11
12
14
15
17
18
19
20
31
32
32
33
34
34
35
35
36
37
37
38
39
40
40
41
42
47
47
Antecedentes
contrario,
depende
de
la
longitud
del
hilo
(Figura
1).
10
11
Captulo I. Introduccin
El pndulo fsico es un sistema que demanda un modelado preciso y
sofisticadas estrategias de control. Dentro de la teora de control, el pndulo demanda
robustez, estabilidad y eficiencia para ser controlado. Un aeropndulo basa sus
movimientos angulares en un motor, montado en la parte superior del eje de un
pndulo, el cual cuenta con una hlice para generar un impulso al eje rotario del
pndulo. El objetivo de construir un dispositivo de control en lazo cerrado, basado en
Matlab, Simulink y Arduino, de laboratorio para el aeropndulo. Es proporcionar un
dispositivo fcil de construir y de bajo costo, para prueba y simulacin de
controladores en tiempo real. Basando el control del aeropndulo, en l envi de
seales PWM, generados por Arduino hacia el motor, para posicionar el aeropndulo
al Angulo deseado por el usuario. Mediante la descripcin del funcionamiento
general del aeropndulo, son detalladas las piezas que lo conforman. De igual
manera se muestra la forma de la conexin del aeropndulo, para un sistema de
control en lazo cerrado. Haciendo uso de Arduino Uno, como tarjeta de adquisicin
de datos con conexin al software Matlab y Simulink.
1.2 Justificacin
En nuestra carrera de Ingeniera Mecatrnica carece de prcticas de control, como
son: PID, PD, P, LQR, FUZZY, es por eso se ha construido un sistema macatrnico
con la finalidad de llevar a cabo prcticas de laboratorio para controladores. El
mtodo utilizado, se implement por medio de simulaciones realizadas bajo los
ambientes de MatLab, Simulink y Arduino. Con el deseo de probar la efectividad de
los controladores en el sistema mecatrnico en tiempo real. El aeropndulo es una
opcin de fcil diseo y construccin.
Prototipo portable.
Desarrollar en Simulink un diagrama de bloques para el control del
aeropndulo.
Realizar la comunicacin entre MatLab y Arduino para la manipulacin del
aeropndulo.
(1)
(2)
obtenemos finalmente la ecuacin diferencial (3) del movimiento plano del pndulo
simple [5].
gsin=0
l +
(3)
2.2 PWM
Pulso modulacin de ancho, o PWM, es una tcnica para obtener resultados
anlogos con medios digitales. Control digital se utiliza para crear una onda
cuadrada, una seal cambia entre encendido y apagado. Este patrn de encendido y
apagado puede simular tensiones en el medio completo en (5 voltios) y desactivacin
(0 Volts) cambiando la parte de las veces la seal pasa en comparacin con el tiempo
que la seal pasa fuera. La duracin de "a tiempo" se llama el ancho de pulso. Para
obtener variando valores analgicos, se cambia, o modular, que el ancho de pulso. Si
repite este patrn de encendido y apagado suficientemente rpido con un LED por
ejemplo, el resultado es como si la seal es una tensin constante entre 0 y 5v
controlar el brillo del LED [6].
En el siguiente grfico, las lneas verdes representan un perodo de tiempo
regular. Esta duracin o perodo es la inversa de la frecuencia PWM. En otras
palabras, con frecuencia PWM de Arduino en alrededor de 500 Hz, las lneas verdes
mediran 2 milisegundos cada uno. Una llamada a analogWrite () es en una escala de
0 a 255, de tal manera que analogWrite (255) solicita un ciclo de trabajo del 100%
(siempre encendido), y analogWrite (127) es un ciclo de trabajo del 50% (en la mitad
del tiempo) para ejemplo (Figura 2.2).
2.3 MatLab
El nombre de MatLab es una abreviatura de Matrix Laboratory (Laboratorio
Matricial), desde su aparicin en los aos 70, ha ido introducindose con fuerza en el
mbito cientfico y universitario; en la actualidad es una de las principales
herramientas para el clculo matemtico, anlisis de datos, simulacin y
visualizacin de resultados. Una ventaja importante que presenta MatLab es el
entorno grfico de trabajo, la claridad en la presentacin de resultados y la
versatilidad que presenta para la creacin de funciones [7].
Todas las operaciones que realiza MatLab se basan en una estructura de datos
matriciales; todas las funciones o comandos de MatLab se agrupan en las llamadas
toolbox, y abarcan diferentes campos, como son el anlisis y adquisicin de datos,
procesamiento de imgenes y de seales, anlisis y diseo de sistemas de control,
10
11
2.4 Arduino
12
(LOW).
Analgicos. Tienen una resolucin de 10 bits, retornando valores desde 0 a
14
en el programa.
Loop(). Incluye el cdigo a ser ejecutado continuamente, leyendo las entradas
de la placa, salidas, etc.
15
variables, etc.).
Serialprintln(dato). Imprime datos al puerto serie seguido por un retorno de
lnea automtico.
Serial.read(). Lee o captura un carcter desde el puerto serie.
Serial.available(). Devuelve el nmero de caracteres disponibles para leer
desde el puerto serie.
el
archivo
ArduinoIO.zip
de
la
pgina
http://www.mathworks.com/matlabcentral/fileexchange/27843-arduino-iopackage--slides-and-examples.
2. Descomprima el archivo en la carpeta deseada en el equipo, preferiblemente
16
IDE ARDUINO, para que Matlab pueda acceder al puerto serial que se abre
cuando se conecta la tarjeta.
6. Abra MatLab y en la ventana Current Directory abra la carpeta que se
17
a.digitalRead(10), que permite leer el estado alto 1 o bajo 0 del pin 10.
Si un pin ha sido configurado como salida, para colocar un estado alto 1 o
bajo 0 en dicha salida, se usa el comando: a.digitalWrite(13, 1) o
a.digitalWrite(13, 0).
Las entradas anlogas, son pines de la tarjeta Arduino, que pueden recibir
voltajes en un rango de 0 a 5 voltios; tiles cuando se requiere un sensor que
represente el valor de una variable anloga, como por ejemplo: la temperatura.
18
[12].
2.7 SolidWorks
SolidWorks es un software CAD (diseo asistido por computadora) para
modelado mecnico en 3D, desarrollado en la actualidad por SolidWorks Corp., una
filial de Dassault Systmes, S.A. (Suresnes, Francia), para el sistema operativo
Microsoft Windows. Su primera versin fue lanzada al mercado en 1995 con el
propsito de hacer la tecnologa CAD ms accesible.
19
20
1.
2.
3.
4.
5.
el ngulo
21
entre la lnea de reposo y la barra del pndulo, y como en este modelo se considera la
traccin, se denota por C esa constante [15].
(4)
[]
x
Lsin ( )
=f ( L , )=
y
L cos ( )
(5)
v=
d x
d
L cos ( )
= f ( L , )=
dt y dt
L sin ( )
[]
]
22
(6)
Lcos ( )
2
v =
Lsin ( )
2
v =L2 2 +
2
v =L2 2
(7)
23
u ( )=mgh
donde
h=0
=0 , en la
ecuacin (8):
(8)
()
1cos ()
LL cos =mgL
u ( )=mgh
(9)
( 1 )=k ( 1 )u ()
(10)
=
][
( 1 )
d ( 1 )
+c
dt
Donde
G 1
se tienen las ecuaciones (11), (12) y (13):
(11)
] [
( 1 )
1
=
m L2 2 mgL ( 1cos ( ) ) =m L2
(12)
d ( 1 )
d
2
2
= [ m L ] =m L
dt
dt
(13)
] [
( 1 )
1
=
m L2 mgL
( 1cos ( )) =mgLsin ( )
=m L +mgLsin ( ) +c
(14)
Como
25
2
( ) +c
TL=m L +mgLsin
(15)
(16)
T =ku
( ) +c
kLu=m L +mgLsin
(17)
kLu
( )c +
m L =mgLsin
(18)
26
(19)
k + ( uu0 )
T=
u>u0
0
u [u0 ,u 0 ]
k( u +u0 )
u<u0
y mayor que
27
acute {u}
La seal
(20)
u=
u +u 0 u > 0
u u0 u < 0
kL u
( )c +
m L =mgLsin
(21)
(22)
mg
u =
sin ( )+ ~
u
K
28
(23)
kL mg sin ( ) + ~
m L =mgLsin
( )c +
u
k
mgLsin ( )+ kL u
( )c +
m L2 =mgLsin
m L2 =c
+kL
u
(24)
{ m L }= {c }+ { kL ~
u}
2
m L2 s 2 ( s )=cs ( s ) +kL ~
u(s)
( s ) ( m L2 s 2+ cs ) =kL ~
u(s)
(25)
G ( s )=
kL
m L s + cs
2 2
29
(26)
1
kL
m L2
G ( s )=
.
m L2 s2 + cs 1
m L2
(27)
k
mL
G ( s )=
c
s 2+
s
m L2
(28)
2 2
m L s + cs+ 0
30
(29)
2 2
m L s + cs=0
s ( m L2 s+ c )=0
s 1=0 s2=
c
m L2
(30)
G Lc ( s )=
kcG ( s )
1+kcG(s) M (s)
(31)
k
c
/(s +
s)
(
)
mL
mL
=
k
c
1+ kc (
/(s +
s)(1)
)
mL
mL
kc
GLc
31
(32)
kck
mL
c
s2 +
m L2 s
GLc =
c
kck
s2 +
s+
2
mL
mL
c
s2 +
s
2
mL
(33)
2 2
m L s +cs +kckL
m L2
kckL
m L2
G Lc=
(34)
GLc =
kckL
m L s +cs +kckL
2 2
(35)
2 2
m L s + cs+ kckL=0
(36)
2
s m L kckL
s1 c
0
s kckL
33
(37)
kc >0
Controlabilidad
De la ecuacin (28) se despeja
}
:
kL ~
+
u
c
1
m L2
(38)
=x 1 , entonces
Si se hace
x 1
=
, y si se hace ahora se obtiene la ecuacin
(39):
x 1=x 2
Entonces
(39)
x 2
=
. Por lo que la ecuacin (39) puede escribirse como la ecuacin
(40):
x 2=
1
(c x 2 +kL ~u )
m L2
(40)
[][
0
x 1
=
0
x 2
][ ]
1
0
c x+ kL u
m L2
m L2
(41)
34
[][
][ ]
0
x 1
=
0
x 2
1
0
c x+ k u
mL
m L2
(42)
[ ]
(43)
[ ]
(44)
0
0
1
c = A
m L2
0
k =B
mL
[ ]
(45)
k
mL
AB=
ck
2 3
m L
[ ]
0
[ B AB ] =
k
mL
k
mL
ck
m 2 L3
(46)
[ B AB ] = k
( mL )
(47)
El dispositivo completo puede ser construido por menos de $1500.00 pesos. Este
estimado considera el uso de un Arduino Mega, un integrado para manipulacin del
motor, un teclado matricial 4x4 y una LCD 16x2.
36
Estructura de madera
La placa que sirve como base es un cuadro que mide 40x60. Se puede adquirir la
estructura en cualquier empresa de maquila de acrlicos o comprar los materiales
para fabricarla uno mismo.
37
Caractersticas:
39
Almacenamiento de
datos (Almacena
hasta 5 paquetes en
la
memoria)
Especificaciones:
mximo
de descarga: 5W
-
Ni-MH/NiCd clulas: 1 ~ 15
40
Li-ion/Poly clulas: 1 ~ 6
Peso: 277g
Dimensiones: 133x87x33mm
3.4 Adaptacin del sensor
Se coloc el sensor MPU-6050 el cual es un girscopo, se puso en la parte
superior del tubo para que este pueda medir el ngulo al cual se va a posicionar,
como se muestra en la Figura 3.4.
41
42
44
45
Figura 4.2.d Ventana Funtion Block Parameters: PIC Controller del controlador P.
46
47
Figura 4.2.f Ventana Funtion Block Parameters: PIC Controller del controlador PD.
48
Figura 4.2.g Ventana Funtion Block Parameters: PIC Controller del control PID.
49
Conclusiones
-
50
Recomendaciones
51
Referencias
[1] Kumar Saha, Subir (2010), Introduccin a la robtica, Mc Graw Hill, Mxico,
D.F.
[2] Dorf, R.C. (1988), International Encyclopedia of Robotics, John Wiley & Sons,
Nueva York,
[3] Fuller, J.L. (1999), Robotics: Introduction, Programming, and Proyect, Prentice
Hall, Nueva Jersey.
[4] P. J. Escamilla, and N. Mort, A Novel Desing and Tuning Procedure for PID
Type Fuzzy Logic Controllers, submitted for publication, Proceedings of the IFAC
World Congress, Barcelona, Spain, 2002
52
el
16
de
septiembre
de
2013,
de:
http://rua.ua.es/dspace/bitstream/10045/11833/1/arduino.pdf.
[7] Moore, Holly (2007), MatLab para Ingenieros, Pearson, Mxico.
[8] General MATLAB product documentation. www.mathworks.com Data
Acquisition
Toolbox
Product
Documentation
http://www.mathworks.com/access/helpdesk/help/toolbox/daq/daq.shtml
[9] Arduino UNO R3, Consultado el 14 de septiembre de 2014, en:
http://5hertz.com/index.php?main_page=product_info&products_id=390
[10]
Arduino,
Consultado
el
13
de
septiembre
de
2014,
en:
http://www.arduino.cc/es/pmwiki.php?n=.
[11] Pinto Bermdez, Enrique, Mata Espada, Fernando (2010), Fundamentos de
Control con MatLab, Pearson, Madrid, Espaa.
[12] Carrillo Lpez, David (2008), Adquisicin de seales usando MatLab. Empleo
de un convertidor externo.
[13] Torrente Artero, scar (2013), Arduino, Curso prctico de formacin,
Alfaomega, Mxico.
[14]
(1997),
Fundamentos
53
Toolbox
Product
Documentation
http://www.mathworks.com/access/helpdesk/help/toolbox/daq/daq.shtml
Anexos
Anexo A: Imgenes de prueba
54
Controlador P
P
Entrada
0
2
ngulo (rad)
ngulo (rad)
1.5
0.5
1
2
Tiempo (s)
Controlador PI
PI
Entrada
0
1
2
Tiempo (s)
1
0.5
PD
Entrada
0
1.5
1.5
0.5
Controlador PD
ngulo (rad)
ngulo (rad)
1
2
Tiempo (s)
Controlador PID
1.5
1
0.5
0
PID
Entrada
0
1
2
Tiempo (s)
55
/
********************************************************************
******************************
*
22/12/2011
www.dieBotReise.blogspot.com
alblopgas@gmail.com
*
Descripcin: Programa que controla la velocidad de un control Brushless a
travs del
*
*
********************************************************************
******************************/
#include <Servo.h>
#define PINMOTOR 3
no arranca hasta 65
#define PASO 10
confirmacin");
while ( iniciado==false ){
myservo.write(0); // Aramado
recibiendoByte = Serial.read(); // Leemos el Byte recibido
if (recibiendoByte == 65 || recibiendoByte ==97) {
// A o a Mayusculas o
minusculas
iniciado=true;
}
}
Serial.println("inicio del loop principal \n Para subir controlar velocidad pulse \n
'A' para subir \n
}
void loop(){
ordenTeclado =OrdenSubirBajar ();
if (ordenTeclado != 0) {
// Distinto de Cero
se
57
// A o A Mayusculas o
minusculas
Serial.println( " SUBIR");
orden = PASO;
}
if (recibiendoByte == 90 || recibiendoByte ==122) { // Z o z
Mayusculas o
minisculas
Serial.println( " BAJAR");
orden = -PASO;
}
if (recibiendoByte == 83 || recibiendoByte == 115){ // t o T
Mayusculas o
minisculas
Serial.println( " Stop!!");
orden = -(pulsoMotor- MINIMOPWM); // Deja el pulso en MINIMOPWM
}
}
return (orden);
}
Anexo C: Cdigo del funcionamiento del Aeropndulo con control en Arduino
/////////////////////////////////////
// programa PID desde cero
int TiempoMuestreo=10;
58
muestreo
unsigned long ahora;
float Ref=45;
grados
int Y;
// Salida
int M=0;
int N=0;
double error;
// error
double errorPass=0;
double errorAnt=0;
double U;
// Seal control
59
atan(-1*(AcX/A_R)/sqrt(pow((AcY/A_R),2)
pow((AcZ/A_R),2)))*RAD_TO_DEG;
Acc[0]
atan((AcY/A_R)/sqrt(pow((AcX/A_R),2)
pow((AcZ/A_R),2)))*RAD_TO_DEG;
//Leer los valores del Giroscopio
Wire.beginTransmission(MPU);
Wire.write(0x43);
Wire.endTransmission(false);
Wire.requestFrom(MPU,4,true); //A diferencia del Acelerometro, solo se piden 4
registros
GyX=Wire.read()<<8|Wire.read();
GyY=Wire.read()<<8|Wire.read();
//Calculo del angulo del Giroscopio
Gy[0] = GyX/G_R;
Gy[1] = GyY/G_R;
61
//MEDICION DE LA PLANTA
M = Y-83;
N = M * (-1);
/////////////////////////////////////////////////////////////
////////ASEGURAR TIEMPO DE MUESTREO
ahora=millis();
// tiempo actual
pasado
if(CambioTiempo >= TiempoMuestreo)
// si se supera el tiempo de
muestreo
{
error = Ref - N;
errorPass=(error*(TiempoMuestreo))+errorPass;
// clculo de aproximacin
del area
double errorD =(error-errorAnt)/(TiempoMuestreo); // clculo derivativo
float P=Kp*error;
float I=Ki*errorPass;
// control proporcional
// control Integral
float D=Kd*errorD;
U=P+I+D;
// actualizar tiempo
62
errorAnt=error;
// actualizar el error
}
/* if(U < 40)
{
U = 40;
}
if(U > 180)
{
U = 180;
}
*/
Serial.println(U);//visualizar en monitor serial la seal de control U en valores 0 ->
255
//visualizar en LCD el Angulo leido por el sensor
lcd.setCursor (0,0);
lcd.print("Angulo: ");
lcd.setCursor (8,0);
lcd.print(N);
//visualizar en LCD el error
lcd.setCursor (0,1);
lcd.print("e: ");
lcd.setCursor (4,1);
lcd.print(error);
//visualizar en LCD la seal de Control en 0 -> 255
lcd.setCursor (0,2);
lcd.print("Control: ");
lcd.setCursor (10,2);
lcd.print(U);
motor.write(U);
63
Serial.println(N);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
Rather than hard-coding the length, you should use the pre-provided length
function.
64
muestreo
unsigned long ahora;
int Y;
int M=0;
int N=0;
double control;
///////////////////////////////////////////////////////////////////
#include <LiquidCrystal_I2C.h>
#include <Wire.h>
//Configuracion LCD I2C
65
LiquidCrystal_I2C lcd(0x27,2,1,0,4,5,6,7,3,POSITIVE);
//////////////////////////////////////////////////////
//Direccion I2C de la IMU
#define MPU 0x68
//Ratios de conversion
#define A_R 16384.0
#define G_R 131.0
//Conversion de radianes a grados 180/PI
#define RAD_A_DEG = 57.295779
//MPU-6050 da los valores en enteros de 16 bits
//Valores sin refinar
int16_t AcX, AcY, AcZ, GyX, GyY, GyZ;
//Angulos
float Acc[2];
float Gy[2];
float Angle[2];
//////////////////////////////////////////////////////////////////////
//PINES
#include <Servo.h>
Servo motor;
void setup()
{
Wire.begin();
Wire.beginTransmission(MPU);
Wire.write(0x6B);
Wire.write(0);
Wire.endTransmission(true);
66
motor.attach(3);
Serial.begin(9600);
}
void loop()
{
///////////////////////////////////////////
///////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////
//1 - leer sensor y almacenar la lectura en una variable
//2 - asegurar el tiempo de muestreo
//3 - una vez que se cumpla el tiempo de muestreo, enviar la lectura por puerto serie
//4 - recibir la seal de control de simulink
//5 - teniendo la seal de control podemos manipular el sistema a nuestro antojo
//Leer los valores del sensor
//Leer los valores del Acelerometro de la IMU
Wire.beginTransmission(MPU);
Wire.write(0x3B); //Pedir el registro 0x3B - corresponde al AcX
Wire.endTransmission(false);
Wire.requestFrom(MPU,6,true); //A partir del 0x3B, se piden 6 registros
AcX=Wire.read()<<8|Wire.read(); //Cada valor ocupa 2 registros
AcY=Wire.read()<<8|Wire.read();
AcZ=Wire.read()<<8|Wire.read();
//Se calculan los angulos Y, X respectivamente.
Acc[1]
atan(-1*(AcX/A_R)/sqrt(pow((AcY/A_R),2)
pow((AcZ/A_R),2)))*RAD_TO_DEG;
67
Acc[0]
atan((AcY/A_R)/sqrt(pow((AcX/A_R),2)
pow((AcZ/A_R),2)))*RAD_TO_DEG;
//Leer los valores del Giroscopio
Wire.beginTransmission(MPU);
Wire.write(0x43);
Wire.endTransmission(false);
Wire.requestFrom(MPU,4,true); //A diferencia del Acelerometro, solo se piden 4
registros
GyX=Wire.read()<<8|Wire.read();
GyY=Wire.read()<<8|Wire.read();
//Calculo del angulo del Giroscopio
Gy[0] = GyX/G_R;
Gy[1] = GyY/G_R;
//Aplicar el Filtro Complementario
Angle[0] = 0.98 *(Angle[0]+Gy[0]*0.010) + 0.02*Acc[0];
Angle[1] = 0.98 *(Angle[1]+Gy[1]*0.010) + 0.02*Acc[1];
//COMO SOLO USAREMOS 1 EJE ENTONCES DAMOS EL VALOR A LA
VARIABLE
Y = Angle[1]*(-1);
//MEDICION DE LA PLANTA
M = Y-85;
N = M * (-1);
N = map(N, 0, 90, 0,90); //pasar a 10 bits
Serial.write(N);//enviamos la llectura a simulink
if(Serial.available())
{
control = Serial.read();
control = map(control, 0, 180, 40, 180); //pasar a 8 bits
motor.write(control);
68
}
delay(10);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
69