BENEMÉRITA UNIVERSIDAD AUTÓNOMA DE PUEBLA

FACULTAD DE CIENCIAS DE LA ELECTRÓNICA

PROGRAMA EDUCATIVO

LIC. INGENIERÍA MECATRÓNICA

MATERIA APLICACIONES DE CONTROL POR IA

PROYECTO: SISTEMA DE CONTROL POR BURSHLESS

DOCENTE GUSTAVO TORRES MENDOZA

ALUMNOS:

PEDRO SEBASTIAN LANDIN MARTINEZ

JOSÉ LUIS OREA HERNÁNDEZ

LUIS JESUS ROJAS RIVERA

PERIODO PRIMAVERA 2022

07 DE MAYO DEL 2022

Introducción

Hoy en día podemos ver que hay acontecimientos que son originados por algún
factor en específico la mayoría de estos pueden ser por factores externos o del
propio sistema, así podemos decir que hay ciertos comportamientos para casos
particulares generan el comportamiento de dichos acontecimientos sin embargo
dependiendo del enfoque que le demos a estos eventos se busca saber su origen
su desarrollo y cómo culmina lo que nos genera
A lo largo de nuestro entendimiento dentro de nuestra carrera podemos enfocarnos
a fines tecnológicos procesos industriales todo esto se puede reducir a sistemas de
control o sistemas automáticos los cuales podemos llevar a cabo con un origen un
desarrollo y un desenlace. aquí podemos partir de que el origen nos presenta
variables físicas o reales de un dicho sistema que podemos esta detectando para
así interpretarlo en un sistema de estructura física como de diseño el fin sería la
respuesta ofrecida por el sistema una vez que se hayan logrado una o varias
decisiones para el correcto funcionamiento de dichas entradas en el sistema
Entonces, al tener correctamente interpretado este funcionamiento podemos darnos
cuenta de que al momento de Tomar en nuestras entradas podemos interpretarlas
como un sistema de magnitudes físicas Que nos presentan dichas entradas como
cuantificables y medibles haciendo la transducción del parámetro físico a su
respectiva conversión eléctrica aquí mismo podemos interpretar qué es lo que
intentamos lograr con nuestro proyecto
por eso mismo recapitulando lo anterior intentamos llevar un sistema de control que
toma en cuenta la cantidad de valores posibles de dicha entrada que puedan tomar
efectos en conjuntos que puedan servir de referencia para así obtener un
funcionamiento en nuestro sistema de control qué va a servir para una toma de
decisiones en base al grupo que se haya detectado en la entrada
Es por eso que mediante lo comprendido en clase se toma el control mediante lógica
difusa, con esto se pueden tomar o agrupar varios conjuntos y se clasifican según
la magnitud de dicha variable es posible determinar una o varias decisiones gracias
a las herramientas proporcionadas por la lógica difusa y así obtener como respuesta
final un sistema de control diseñado para ser capaces de responder en función de
la entrada para obtener una regulación o nivelación en la variable a medir con estará
abierto el sistema esto ayudamos a que el sistema de control difuso sea ajustado
dependiendo a lo que el usuario pretenda regular o nivelar dependiendo de sus
variables tomadas como referencia para dicho sistema.
Descripción del proyecto

En este proyecto se plantea una propuesta para la cual su aplicación consiste en un

sistema de control que funcione mediante un mecanismo a base de el sensado de
una inclinación para el accionamiento de un motor que ayudará a que se mantenga
el mecanismo en equilibrio de esta manera también podemos impartir una breve
explicación sobre es el funcionamiento de un sistema de control difuso.
Ahora en primer lugar se busca como entrada que nuestro sensor sea capaz de leer
dicha inclinación para así lograr la rotación de nuestro motor y dependiendo de esta
variable nos ayudará a lograr la frecuencia que logrará mantener a nuestro sistema
en equilibrio.
Una vez comprendiendo esto tenemos que considerar que nuestro sistema va a
oscilar los valores de entrada en un cierto parámetro por lo tanto para que sea
menos complejo de entender lo llevamos a la siguiente representación.
Ahora una vez tomando en cuenta nuestros valores de entrada se procede a realizar
los conjuntos con los cuales se va a considerar el sistema para posteriormente llevar
a la parte de control y denominarlos.
Entonces con nuestro sistema tenemos que tener en cuenta que es fundamental
considerar también los valores que puede tomar nuestra salida por lo tanto nuestro
motor tiene cierta frecuencia de giro El cual logrará que nuestro sistema funcione
correctamente por eso mediante conjuntos difusos en la entrada, la salida del
sistema se procede a crear un conjunto de reglas que nos ayude a llevar a cabo el
correcto funcionamiento de nuestro sistema esto con el objetivo de establecer una
serie de referencias con las cual es nuestro sistema de control puede llegar a la
interpretación de sus variables y obtener una salida como respuesta del
comportamiento de la medición.
Después de haber construido nuestro sistema de reglas se puede llevar a la
representación de estos conjuntos con el objetivo de apreciar gráficamente tomar
de ellos los valores necesarios para los cálculos posteriores.

Marco teórico

Descripción de componentes
A continuación, se explicara de manera detallada los componentes a utilizar para la
aplicación de este proyecto:
MPU6050
EL MPU6050 es una unidad de medición inercial o IMU (Inertial Measurment Units)
de 6 grados de libertad (DoF) pues combina un acelerómetro de 3 ejes y un
giroscopio de 3 ejes. Este sensor es muy utilizado en navegación, goniometría,
estabilización, etc.

En este tutorial revisaremos los principios generales de acelerómetros y

giroscopios, luego estudiaremos el sensor MPU6050 con mayor detalle y finalmente
implementaremos ejemplos del MPU6050 con Arduino.

Aceleración y acelerómetros
La aceleración es la variación de la velocidad por unidad de tiempo es decir razón
de cambio en la velocidad respecto al tiempo:

a=dV/dt

Así mismo la segunda ley de Newton indica que en un cuerpo con masa constante,
la aceleración del cuerpo es proporcional a la fuerza que actúa sobre él mismo:

a=F/m

Este segundo concepto es utilizado por los acelerómetros para medir la

aceleración. Los acelerómetros internamente tienen un MEMS
(MicroElectroMechanical Systems) que de forma similar a un sistema masa resorte
permite medir la aceleración.

Con un acelerómetro podemos medir esta aceleración, teniendo en cuenta que a

pesar de que no exista movimiento, siempre el acelerómetro estará sensando la
aceleración de la gravedad.

Con el acelerómetro podemos hacer mediciones indirectas como por ejemplo si

integramos la aceleración en el tiempo tenemos la velocidad y si la integramos
nuevamente tenemos el desplazamiento, necesitando en ambos casos la velocidad
y la posición inicial respectivamente.
Velocidad Angular y giroscopio
La velocidad angular es la tasa de cambio del desplazamiento angular por unidad
de tiempo, es decir que tan rápido gira un cuerpo alrededor de su eje:

Los giroscopios utilizan un MEMS (MicroElectroMechanical Systems) para medir la

velocidad angular usando el efecto Coriolis

Con un giroscopio podemos medir la velocidad angular, y si se integra la velocidad

angular con respecto al tiempo se obtiene el desplazamiento angular (posición
angular si se sabe dónde se inició el giro).

Módulo Acelerómetro y giroscopio MPU6050

EL módulo Acelerómetro MPU tiene un giroscopio de tres ejes con el que podemos
medir velocidad angular y un acelerómetro también de 3 ejes con el que medimos
los componentes X, Y y Z de la aceleración.

La dirección de los ejes está indicada en el módulo el cual hay que tener en cuenta
para no equivocarnos en el signo de las aceleraciones.
 La comunicación del módulo es por I2C, esto le permite trabajar con la mayoría de
los microcontroladores. Los pines SCL y SDA tienen una resistencia pull-up en placa
para una conexión directa al microcontrolador o Arduino.

Componentes del programa

Primeramente, fue necesario realizar pruebas de funcionamiento sin el control del

sistema para determinar los rangos de operación tanto del sensor de posición
como del motor brushless.
Los rangos de operación de acuerdo con la construcción del modelo son los
siguientes.
Inclinación [-31,27].
Tomando en cuenta la entrada de error del sistema, y que la inclinación horizontal
no era en cero, dadas las condiciones del prototipo el valor deseado K es 8.
Por lo tanto se tiene: Error [-39, 39].
Y por último la salida PWM [24, 64].
Prosiguiendo con el desarrollo del presente trabajo, una vez que ya se tienen
establecidos los rangos de los conjuntos difusos tanto para la entrada como para
la salida y, adicional a eso, se ha establecido adecuadamente la base de reglas
para el sistema.
Para ello se construye en el software de Arduino un programa con los parámetros
de entrada y salida, que sea capaz de lograr lo requerido que se muestra a
continuación.
Programa

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

#include "I2Cdev.h"
#include "MPU6050.h"
#include "Wire.h"
#include "fis_header.h"
#include <Servo.h>

MPU6050 sensor;
Servo ESC;

// Valores RAW (sin procesar) del acelerómetro en los ejes x,y,z

int ax, ay, az;

// Número de entradas
const int fis_gcI = 2;
// Número de salidas
const int fis_gcO = 1;
// Número de reglas
const int fis_gcR = 13;

FIS_TYPE g_fisInput[fis_gcI];
FIS_TYPE g_fisOutput[fis_gcO];

void setup()
{
Serial.begin(57600); //Iniciando puerto serial
Wire.begin(); //Iniciando I2C
sensor.initialize(); //Iniciando el sensor

if (sensor.testConnection()) Serial.println("Sensor iniciado

correctamente");
else Serial.println("Error al iniciar el sensor");

ESC.attach(3,1000,2000);
ESC.write(0);
delay(5000);

void loop()
{
// Leer las aceleraciones
sensor.getAcceleration(&ax, &ay, &az);
//Calcular los angulos de inclinacion:
float accel_ang_x=atan(ax/sqrt(pow(ay,2) + pow(az,2)))*(180.0/3.14);
float accel_ang_y=atan(ay/sqrt(pow(ax,2) + pow(az,2)))*(180.0/3.14);

// Inclinación(grados)
 g_fisInput[0] = accel_ang_x;
// Error
g_fisInput[1] = 8-accel_ang_x;

g_fisOutput[0] = 0;

fis_evaluate();

// PWM
analogWrite(3 , g_fisOutput[0]);
ESC.write(g_fisOutput[0]);
//delay(20);

Serial.print("Grados :");
Serial.println(g_fisInput[0]);
Serial.print("Error :");
Serial.println(g_fisInput[1]);
Serial.print("PWM:");
Serial.println(g_fisOutput[0]);
delay(100);

//***********************************************************************
// Función de membresía forma Pi
FIS_TYPE fis_pimf(FIS_TYPE x, FIS_TYPE* p)
{
return (fis_smf(x, p) * fis_zmf(x, p + 2));
}

// Función de membresía forma S

FIS_TYPE fis_smf(FIS_TYPE x, FIS_TYPE* p)
{
FIS_TYPE a = p[0], b = p[1];
FIS_TYPE m = ((a + b) / 2.0);
FIS_TYPE t = (b - a);
if (a >= b) return (FIS_TYPE) (x >= m);
if (x <= a) return (FIS_TYPE) 0;
if (x <= m)
{
t = (x - a) / t;
return (FIS_TYPE) (2.0 * t * t);
}
if (x <= b)
{
t = (b - x) / t;
return (FIS_TYPE) (1.0 - (2.0 * t * t));
}
return (FIS_TYPE) 1;
}

// Función de membresía forma Z

FIS_TYPE fis_zmf(FIS_TYPE x, FIS_TYPE* p)
{
FIS_TYPE a = p[0], b = p[1];
FIS_TYPE m = ((a + b) / 2.0);
FIS_TYPE t = (b - a);
 if (x <= a) return (FIS_TYPE) 1;
if (x <= m)
{
t = (x - a) / t;
return (FIS_TYPE) (1.0 - (2.0 * t * t));
}
if (x <= b)
{
t = (b - x) / t;
return (FIS_TYPE) (1.0 - (2.0 * t * t));
}
return (FIS_TYPE) 0;
}

// Función de membresía Gaussiana

FIS_TYPE fis_gaussmf(FIS_TYPE x, FIS_TYPE* p)
{
FIS_TYPE s = p[0], c = p[1];
FIS_TYPE t = (x - c) / s;
return exp(-(t * t) / 2);
}

FIS_TYPE fis_min(FIS_TYPE a, FIS_TYPE b)

{
return min(a, b);
}

FIS_TYPE fis_max(FIS_TYPE a, FIS_TYPE b)

{
return max(a, b);
}

FIS_TYPE fis_array_operation(FIS_TYPE *array, int size, _FIS_ARR_OP

pfnOp)
{
int i;
FIS_TYPE ret = 0;

if (size == 0) return ret;

if (size == 1) return array[0];

ret = array[0];
for (i = 1; i < size; i++)
{
ret = (*pfnOp)(ret, array[i]);
}

return ret;
}

//***********************************************************************
// Datos para el sistema difuso
//***********************************************************************
// Punteros para la implementación de funciones de membresía
_FIS_MF fis_gMF[] =
{
fis_pimf, fis_smf, fis_zmf, fis_gaussmf
};

// Funciones de membresía para cada entrada

int fis_gIMFCount[] = { 5, 5 };

// Funciones de membresía para cada salida

int fis_gOMFCount[] = { 5 };

// Parámetros para las funciones de membresía de cada entrada

FIS_TYPE fis_gMFI0Coeff1[] = { -46.24, -31.69, -28.42, -11.22 };

FIS_TYPE fis_gMFI0Coeff2[] = { 6.192, -11.78 };
FIS_TYPE fis_gMFI0Coeff3[] = { 6.109, 8 };
FIS_TYPE fis_gMFI0Coeff4[] = { 5.85, 31.6762367864694 };
FIS_TYPE fis_gMFI0Coeff5[] = { 34.73, 46.31, 50.16, 65.81 };
FIS_TYPE* fis_gMFI0Coeff[] = { fis_gMFI0Coeff1, fis_gMFI0Coeff2,
fis_gMFI0Coeff3, fis_gMFI0Coeff4, fis_gMFI0Coeff5 };
FIS_TYPE fis_gMFI1Coeff1[] = { -56.55, -40.95, -37.05, -21.45 };
FIS_TYPE fis_gMFI1Coeff2[] = { 5.258, -19.5 };
FIS_TYPE fis_gMFI1Coeff3[] = { 5.233, 0 };
FIS_TYPE fis_gMFI1Coeff4[] = { 4.7, 17.7192389006342 };
FIS_TYPE fis_gMFI1Coeff5[] = { 21.45, 37.05, 40.95, 56.55 };
FIS_TYPE* fis_gMFI1Coeff[] = { fis_gMFI1Coeff1, fis_gMFI1Coeff2,
fis_gMFI1Coeff3, fis_gMFI1Coeff4, fis_gMFI1Coeff5 };
FIS_TYPE** fis_gMFICoeff[] = { fis_gMFI0Coeff, fis_gMFI1Coeff };

// Parámetros para las funciones de membresía de la salida

FIS_TYPE fis_gMFO0Coeff1[] = {2.94, 44.1};//Vm
FIS_TYPE fis_gMFO0Coeff2[] = {24.8, 22.8, 23.8, 32.2};//Vb
FIS_TYPE fis_gMFO0Coeff3[] = {2.57, 31.87};//Vmb
FIS_TYPE fis_gMFO0Coeff4[] = {2.39, 52.86};//Vma
FIS_TYPE fis_gMFO0Coeff5[] = {57.7 ,63.7, 65.3 ,73.3};//Va
FIS_TYPE* fis_gMFO0Coeff[] = { fis_gMFO0Coeff1, fis_gMFO0Coeff2,
fis_gMFO0Coeff3, fis_gMFO0Coeff4, fis_gMFO0Coeff5 };
FIS_TYPE** fis_gMFOCoeff[] = { fis_gMFO0Coeff };

// Conjunto de funciones de membresía de entrada

int fis_gMFI0[] = { 0, 3, 3, 3, 0 };
int fis_gMFI1[] = { 0, 3, 3, 3, 0 };
int* fis_gMFI[] = { fis_gMFI0, fis_gMFI1};

// Conjunto de funciones de membresía de salida

int fis_gMFO0[] = { 3, 0, 3, 3, 0 };
int* fis_gMFO[] = { fis_gMFO0};

// Pesos de las reglas

FIS_TYPE fis_gRWeight[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };

// Tipo de regla
int fis_gRType[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };

// Entradas de las reglas

int fis_gRI0[] = { 1, 5 };
int fis_gRI1[] = { 1, 5 };
int fis_gRI2[] = { 2, 4 };
int fis_gRI3[] = { 2, 4 };
int fis_gRI4[] = { 2, 4 };
int fis_gRI5[] = { 3, 3 };
int fis_gRI6[] = { 3, 3 };
int fis_gRI7[] = { 3, 3 };
int fis_gRI8[] = { 4, 2 };
int fis_gRI9[] = { 4, 2 };
int fis_gRI10[] = { 4, 2 };
int fis_gRI11[] = { 5, 1 };
int fis_gRI12[] = { 5, 1 };
int* fis_gRI[] = { fis_gRI0, fis_gRI1, fis_gRI2, fis_gRI3, fis_gRI4,
fis_gRI5, fis_gRI6, fis_gRI7, fis_gRI8, fis_gRI9, fis_gRI10, fis_gRI11,
fis_gRI12 };

// Salidas de las reglas

int fis_gRO0[] = { 5 };
int fis_gRO1[] = { 4 };
int fis_gRO2[] = { 1 };
int fis_gRO3[] = { 4 };
int fis_gRO4[] = { 5 };
int fis_gRO5[] = { 3 };
int fis_gRO6[] = { 1 };
int fis_gRO7[] = { 4 };
int fis_gRO8[] = { 2 };
int fis_gRO9[] = { 3 };
int fis_gRO10[] = { 1 };
int fis_gRO11[] = { 2 };
int fis_gRO12[] = { 3 };
int* fis_gRO[] = { fis_gRO0, fis_gRO1, fis_gRO2, fis_gRO3, fis_gRO4,
fis_gRO5, fis_gRO6, fis_gRO7, fis_gRO8, fis_gRO9, fis_gRO10, fis_gRO11,
fis_gRO12 };

// Rango de entrada min

FIS_TYPE fis_gIMin[] = { -31, -39 };

// Rango de entrada max

FIS_TYPE fis_gIMax[] = { 47, 39 };

// Rango de salida min

FIS_TYPE fis_gOMin[] = {20};

// Rango de salida max

FIS_TYPE fis_gOMax[] = { 60};

//***********************************************************************
// Defusificación
//***********************************************************************
FIS_TYPE fis_MF_out(FIS_TYPE** fuzzyRuleSet, FIS_TYPE x, int o)
{
FIS_TYPE mfOut;
int r;

for (r = 0; r < fis_gcR; ++r)

{
int index = fis_gRO[r][o];
if (index > 0)
{
 index = index - 1;
mfOut = (fis_gMF[fis_gMFO[o][index]])(x,
fis_gMFOCoeff[o][index]);
}
else if (index < 0)
{
index = -index - 1;
mfOut = 1 - (fis_gMF[fis_gMFO[o][index]])(x,
fis_gMFOCoeff[o][index]);
}
else
{
mfOut = 0;
}

fuzzyRuleSet[0][r] = fis_min(mfOut, fuzzyRuleSet[1][r]);

}
return fis_array_operation(fuzzyRuleSet[0], fis_gcR, fis_max);
}

FIS_TYPE fis_defuzz_centroid(FIS_TYPE** fuzzyRuleSet, int o)

{
FIS_TYPE step = (fis_gOMax[o] - fis_gOMin[o]) / (FIS_RESOLUSION - 1);
FIS_TYPE area = 0;
FIS_TYPE momentum = 0;
FIS_TYPE dist, slice;
int i;

// calculate the area under the curve formed by the MF outputs

for (i = 0; i < FIS_RESOLUSION; ++i){
dist = fis_gOMin[o] + (step * i);
slice = step * fis_MF_out(fuzzyRuleSet, dist, o);
area += slice;
momentum += slice*dist;
}

return ((area == 0) ? ((fis_gOMax[o] + fis_gOMin[o]) / 2) : (momentum

/ area));
}

//***********************************************************************
// Sistema de inferencia difusa
//***********************************************************************
void fis_evaluate()
{
FIS_TYPE fuzzyInput0[] = { 0, 0, 0, 0, 0 };
FIS_TYPE fuzzyInput1[] = { 0, 0, 0, 0, 0 };
FIS_TYPE* fuzzyInput[fis_gcI] = { fuzzyInput0, fuzzyInput1, };
FIS_TYPE fuzzyOutput0[] = { 0, 0, 0, 0, 0 };
FIS_TYPE* fuzzyOutput[fis_gcO] = { fuzzyOutput0, };
FIS_TYPE fuzzyRules[fis_gcR] = { 0 };
FIS_TYPE fuzzyFires[fis_gcR] = { 0 };
FIS_TYPE* fuzzyRuleSet[] = { fuzzyRules, fuzzyFires };
FIS_TYPE sW = 0;

// Transforming input to fuzzy Input

int i, j, r, o;
 for (i = 0; i < fis_gcI; ++i)
{
for (j = 0; j < fis_gIMFCount[i]; ++j)
{
fuzzyInput[i][j] =
(fis_gMF[fis_gMFI[i][j]])(g_fisInput[i],
fis_gMFICoeff[i][j]);
}
}

int index = 0;
for (r = 0; r < fis_gcR; ++r)
{
if (fis_gRType[r] == 1)
{
fuzzyFires[r] = FIS_MAX;
for (i = 0; i < fis_gcI; ++i)
{
index = fis_gRI[r][i];
if (index > 0)
fuzzyFires[r] = fis_min(fuzzyFires[r],
fuzzyInput[i][index - 1]);
else if (index < 0)
fuzzyFires[r] = fis_min(fuzzyFires[r], 1 -
fuzzyInput[i][-index - 1]);
else
fuzzyFires[r] = fis_min(fuzzyFires[r], 1);
}
}
else
{
fuzzyFires[r] = FIS_MIN;
for (i = 0; i < fis_gcI; ++i)
{
index = fis_gRI[r][i];
if (index > 0)
fuzzyFires[r] = fis_max(fuzzyFires[r],
fuzzyInput[i][index - 1]);
else if (index < 0)
fuzzyFires[r] = fis_max(fuzzyFires[r], 1 -
fuzzyInput[i][-index - 1]);
else
fuzzyFires[r] = fis_max(fuzzyFires[r], 0);
}
}

fuzzyFires[r] = fis_gRWeight[r] * fuzzyFires[r];

sW += fuzzyFires[r];
}

if (sW == 0)
{
for (o = 0; o < fis_gcO; ++o)
{
g_fisOutput[o] = ((fis_gOMax[o] + fis_gOMin[o]) / 2);
}
}
 else
{
for (o = 0; o < fis_gcO; ++o)
{
g_fisOutput[o] = fis_defuzz_centroid(fuzzyRuleSet, o);
}
}
}

Después de haber llevado a cabo la construcción del programa en Arduino y tener

las respuestas de salida del sistema con respecto a las variables de entrada se
procede a realizar lo mismo, pero con el simulador que nos proporciona Matlab que
nos sirve como una herramienta que nos ayuda a visualizar de una forma gráfica y
dinámica el funcionamiento de este mismo

Simulación fuzzy

Para comenzar se muestra la construcción de nuestros conjuntos difusos de entrada

Fig 1. Entrada del conjunto que muestra la inclinación

 Fig 2. Entrada del conjunto que muestra el error

Igualmente, la construcción de los conjuntos difusos correspondientes a la salida

del sistema en el mismo en el simulador de Matlab.

Fig 3. Salida del conjunto que muestra el PWM

Posteriormente llevamos a cabo la construcción de las reglas para llevar a cabo
nuestro sistema que nos ayudará a su correcto funcionamiento para esto se muestra
en la siguiente imagen cómo son estructuradas.

Fig 4. Construcción de reglas para el sistema de control

Fig 5. Sistema de control implementado en el simulador

Finalmente procedemos a la simulación del sistema de control y la obtención de las

respuestas ahora en función del control ejercido por el simulador mencionado, para
ello, se expone a continuación el funcionamiento con ciertas entradas y su
respectiva salida
Resultados

En esta imagen podemos observar que nuestra inclinación de nuestro bambú, se

encuentra posicionada en -27° , y obtenemos el PWM máximo de nuestro motor
para poder elevar el bambú el cual es de 53 aproximadamente, recordando que el
PWM utilizado en Arduino se puede usar en un rango de 0 a 255.

Fig 6. Resultado físico con una inclinación baja

En la siguiente imagen podemos observar que llegamos a nuestro error 0, y para

poder estabilizarse de esa forma se necesita un PWM de aproximadamente 42 a
43. Hay que recordar que nuestro valor de referencia es de 8 °, ya que el bambú y
el MPU no están en paralelo.

Fig 7. Resultado físico con una inclinación media

Por último, al estar muy inclinado se necesita de un PWM para poder bajar nuestro
bambú, y así disminuir nuestro error.

Fig 8. Resultado físico con una inclinación alta

Conclusión
Tuvimos diversos problemas con el controlador de velocidad del motor brushless ya que por momento el
motor perdía potencia y cambiaba de velocidad , otro de los problemas fue que los datos enviados del MPU
tienen un poco de delay entonces tardaba un poco en reaccionar el motor, las vibraciones que ocasionaba el
motor perjudicaba al MPU y enviaba datos erróneos por momentos con una diferencia de PWM de 10, más
adelante en un futuro esperamos corregir esos problemas cambiando nuestro controlador y como optativa
cambiar nuestro sensor con uno de mayor de velocidad en el envío de datos .
Todo lo aprendido en esta asignatura las herramientas tecnológicas en matemáticas nos ayudarán a lograr
cumplir los objetivos planteados inicialmente por este proyecto por lo cual podemos resaltar la importancia
que nos brinda el uso de estas herramientas como la de fuzzy de Matlab , pues ya que sin necesidad de muchas
matemáticas fue posible la construcción de un sistema de control difuso en el cual como antes mencionado
podemos resaltar que el uso de establecer rangos en la entrada como en la salida conforman las partes de un
sistema de control.
Como pudimos apreciar el desarrollo de este proyecto nos ayudará apreciar la posible implementación de una
aplicación de control propuesta mediante la lógica difusa.