UNIVERSIDAD TÉCNICA DE AMBATO

FACULTAD DE INGENIERÍA EN SISTEMAS, ELECTRÓNICA E INDUSTRIAL

CARRERA DE INGENIERÍA EN TELECOMUNICACIONES

Sistemas Embebidos 5to “A”

Proyecto final primer parcial.

Prototipo móvil autónomo con control por medio de un

giroscopio acelerómetro y sistema de monitoreo en Raspberry
PI

Burgasi Cushicagua Shirley Nahomy.

Carvajal Morales Christian Stalin.
Espín Silva Bryan Daniel.
Falcón Arévalo Jonathan Iván.
Freire Luisa Juan Carlos.
Páez Castro Cristina Estefanía.
Villarroel Carrillo Diego Vladimir.

Fecha de Entrega: 07/12/2022

Docente: Ing. Edgar Patricio Córdova Córdova

Octubre 2022 – Marzo 2023

AMBATO - ECUADOR.
1 TEMA
Comunicación inalámbrica.

2 OBJETIVOS
2.1 Objetivo General
 Investigar los diferentes tipos de comunicación inalámbrica que existen para el
diseño de prototipos autónomos logrando llevar dicha teoría a la práctica.
2.2 Objetivos Específicos
 Implementar un guante autónomo que controle un carrito móvil haciendo el uso
de un giroscopio acelerómetro para emplear una comunicación Bluetooth entre
los dos dispositivos.
 Contrastar con un sistema de monitoreo los datos obtenidos haciendo uso de la
Raspberry PI usando el protocolo MQTT para la visualización y
almacenamiento de estos mediante WIFI.

3 INTRODUCCIÓN

En el proyecto final del primer parcial hemos realizado un prototipo móvil autónomo
que se controla mediante de un giroscopio acelerómetro (MPU 6050), el Arduino mini,
la comunicación Bluetooth (HC-05) y una batería las cuales van conectadas en el
guante, en el carrito tenemos el otro sensor Bluetooth (HC-05), ESP 8266, el puente H,
baterías y los motores DC, la comunicación con el servidor lo hicimos mediante un
router y en el servidor podemos observar si el carrito va hacia delante, atrás, izquierda o
derecha, todo esto se va a poder observar en un marcador.

4 PALABRAS CLAVE

(Bluetooth, Arduino, batería, ESP)

5 INDICE GENERAL

1 TEMA..................................................................................................................................2
2 OBJETIVOS.......................................................................................................................2
2.1 Objetivo General........................................................................................................2
2.2 Objetivos Específicos..................................................................................................2
3 INTRODUCCIÓN..............................................................................................................2
4 PALABRAS CLAVE.........................................................................................................2
(Bluetooth, Arduino, batería, ESP)...............................................................................................2
5 INDICE GENERAL...........................................................................................................3
6 GLOSARIO DE TÉRMINOS...........................................................................................4
7 FUNDAMENTACIÓN TEORICA...................................................................................5
7.1 COMUNICACIÓN INALAMBRICA.......................................................................5
7.2 MICROCONTROLADORES...................................................................................5
7.2.1 PLACA ARDUINO............................................................................................5
7.2.2 MÓDULOS.........................................................................................................6
7.3 SENSORES.................................................................................................................8
7.3.1 Sensor MPU- 6050..............................................................................................8
8 Materiales y equipos...........................................................................................................9
8.1 Software......................................................................................................................9
8.2 Componentes...............................................................................................................9
9 METODOLOGÍA..............................................................................................................9
9.1 Función del componente de hardware......................................................................9
9.2 Movimientos..............................................................................................................10
9.3 CÓDIGO DEL CARRO INALÁMBRICO.............................................................11
9.3.1 GIROSCOPIOACELERÓMETRO................................................................15
9.4 Controlador de guante inalámbrico ensamblado...................................................21
9.5 Carro inalámbrico ensamblado...............................................................................21
10 Implementación............................................................................................................22
10.1 Visualización de datos..............................................................................................22
11 ANEXOS.......................................................................................................................23
12 Conclusiones.................................................................................................................24
6 GLOSARIO DE TÉRMINOS

COMUNICACIÓN: Es la accione que permite comunicar o comunicarse entre softwares.

[1]
INALÁMBRICO : Comunicación que no necesita cables para estar conectados o
comunicarse. [1]
BLUETOOTH: Sensor que contiene Método de comunicación inalámbrica para
interconectar dispositivos. [1]
MEDIO : Canal o forma de establecer o mencionar una línea de comunicación ya sea
alámbrica o inalámbrica. [1]
EMISOR: Un aparato que envía una señal para alguna activación de un sensor [1]
RECEPTOR: Un aparato que recibe una señal emitida por el emisor. [1]
MODULADOR: Es un aparto electrónico que permite variar la forma de onda. [1]
DEMODULADOR : Dispositivo que permite eliminar la forma de onda variada por el
Modulador. [1]
MICROCONTROLADOR : Es un ordenador en un chip que contiene procesador memoria
y periféricos de entrada y salida. [1]
ACTUADOR : Elemento electrónico capaz de transformar energía eléctrica en la
activación de un proceso automatizado. [1]
SERVOMOTOR: Actuador que al detectar señales permite girar su Angulo de acuerdo
con la versión. [1]
ARDUINO IDE: software libre de programación, para uso y contribución de la sociedad.
PLACA ARDUINO : Es una placa microcontrolador, con un lenguaje de programación en
un entorno de desarrollo que soporta la entrada y la salida de datos y señales [1]

7 FUNDAMENTACIÓN TEORICA

7.1 COMUNICACIÓN INALAMBRICA

La comunicación inalámbrica es el tipo de comunicación que se da sin tener alguna
necesidad de cables, en este tipo de comunicación interactúan un emisor y un receptor los
mismos que reciben un mensaje mediante ondas electromagnéticas sin la necesidad de usar un
conducto físico, por lo tanto, su medio de comunicación es el aire por medio de antenas que
captan a señal enviada de un lugar a otro y solo requieren de algún dispositivo físico que hacen
de emisor y receptor, demostrando como la siguiente ilustración 1 to proceso de comunicación.
 Ilustración 1 Proceso de comunicación inalámbrica Elaborado por: Burgasi, Carbajal, Espin, Falcon, Paéz,
Vollaroel

NOTA:
No se configura nada en el microcontrolador, solamente la comunicación serial

7.2 MICROCONTROLADORES
El Microcontrolador es un circuito integrado que es el componente principal de una
aplicación embebida. Es como una pequeña computadora que incluye sistemas para
controlar elementos de entrada/salida. También incluye a un procesador y por supuesto
memoria que puede guardar el programa y sus variables (flash y RAM).  Funciona
como una mini PC. Su función es la de automatizar procesos y procesar información.
El microcontrolador se aplica en toda clase de inventos y productos donde se requiere
seguir un proceso automático dependiendo de las condiciones de distintas entradas.
7.2.1 PLACA ARDUINO

ARDUINO PRO MINI CARACTERISTICAS

 Microcontrolador: ATmega 328P.
 Voltaje de operación: 3.3V ó 5 V.
 Pines de E/S digital: 14
 Pines de entrada analógica: 6.
 Memoria Flash: 32 KB y 2 KB son utilizados por el
gestor de arranque.
 Corriente CC por cada pin E/S: 40 mA.
 SRAM : 2 KB
 EEPROM: 1 KB
Tabla 1 Características del Arduino Pro Mini Elaborado por: Burgasi, Carbajal, Espín, Falcon, Paéz,
Villarroel
7.2.2 MÓDULOS

MÓDULO HC05 CARACTERISTICAS

 Voltaje de operación: 3.6V - 6V DC
 Consumo corriente: 50mA
 Bluetooth: V2.0+EDR
 Frecuencia: Banda ISM 2.4GHz
 Modulación: GFSK(Gaussian Frequency Shift Keying)
 Potencia de transmisión: 4dBm, Class 2
 Sensibilidad: -84dBm a 0.1% BER
 Alcance 10 metros

Tabla 2 Características del Módulo HC05Elaborado por: Burgasi, Carbajal, Espín, Falcon, Paéz,
Villarroel
MÓDULO L298N CARACTERISTICAS

 Double: puede conducir el motor de la CC de 2

canales o un motor de pasos 2-fase de 4 hilos
 Power: 2V-10V Voltaje de entrada del puerto
 Signal: 1.8-7V Corriente de funcionamiento del canal
 Single: 1.5A; 2.5A (valor máximo); <0.1uA
(corriente espera)
 Built-En el circuito de conexión Anti-Costate:
cuando el puerto de entrada colgando, el motor no
 maloperación
 Built-En circuito de protección contra
sobrecalentamiento con efecto de retraso
 Size: 24.7 * 21 * 5m m

Tabla 3Características del Módulo HC05Elaborado por: Burgasi, Carbajal, Espín, Falcon, Paéz,
Villarroel

7.3 SENSORES
Los sensores son considerados como un dispositivo de entrada que provee una salida
manipulable de la variable física mediada, es decir es un dispositivo capaz de detectar
magnitudes físicas o químicas, siendo un intermediario entre la variable física y el
sistema de medición es decir el sensor se caracteriza por transformar la energía en
señales eléctricas a de salida, ya sean analógica o digitales. [2]

CLASIFICACIÓN DE LOS SENSORES SEGÚN LA VARIABLE FÍSICA A MEDIR

De posición, velocidad y aceleración
De nivel y proximidad
De fuerza y deformación
De flujo y presión
De color, luz y visión
De gas y PH
Biométricos
De corriente
Tabla 4 Clasificación de sensores [2] Elaborado por: Burgasi, Carbajal,
Espín, Falcon, Paéz, Villarroel

7.3.1 Sensor MPU- 6050

Sensor MPU- 6050 CARACTERISTICAS
 Voltaje de operación: 3V/3.3V~5V DC
 Regulador de voltaje en placa
 Grados de libertad (DoF): 6
 Rango Acelerómetro: 2g/4g/8g/16g
 Rango Giroscopio: 250Grad/Seg, 500Grad/Seg,
1000Grad/Seg, 2000Grad/Seg
 Sensibilidad Giroscopio: 131 LSBs/dps
 Interfaz: I2C
 Conversor AD: 16 Bits (salida digital)

Tabla 5 Características del Sensor MPU- 6050Elaborado por: Burgasi, Carbajal, Espín, Falcon, Paéz
8 Materiales y equipos
8.1 Software
 Software Proteus
 Software Arduino

8.2 Componentes
 Sensor giroscopio acelerómetro (MPU6050)
 Arduino Pro Mini
 Carro
 Puente h (ese vele el integrado o el modulo vele cuánto está )
 Baquela perforada pequeña

9 METODOLOGÍA

Para nuestro proyecto de conexión inalámbrica es recomendable primeramente

comprobar nuestro módulo bluetooh si está funcionando y por ende saber que se utilizó
el módulo Bluetooth HC-05 y el esp 8266. De tal forma, configurar de forma maestro a
esclavo.
Este es un tipo de automóvil que se puede controlar con solo gestos con las manos. Este
proyecto tiene tremendas aplicaciones, especialmente en el dominio de la salud. Por
ejemplo, se puede usar allí para abrir puertas de forma inalámbrica, para suministrar
alimentos a los pacientes a través de un robot o un automóvil robótico con solo usar
gestos con las manos.

9.1 Función del componente de hardware

 MPU-6050 (x1): este es un acelerómetro de 3 ejes (AX, AY, AZ) + módulo de

giroscopio de 3 ejes (GX, GY GZ).
 Chasis (x1): Este es el cuerpo del Coche Robótico.
 Arduino Pro Mini (x2): este es el cerebro del transmisor y del receptor. Un
Arduino se usa para recibir los datos mientras que, por otro lado, un Arduino se
usa para transmitir los datos.
 Otros componentes necesarios: cables de puente, mini placa de prueba, ruedas,
guante de mano derecha.
 L298N: este es el controlador de motor para impulsar los motores del automóvil.
  Módulo bluetooth HC-05.
 Esp 8266.
 Raspberry Pi.

Fig 1. Componentes

Fig 2. Esquema Bluetooth Hc-05

9.2 Movimientos

Fig 3. Gestos de movimientos.

Los gestos que se ha usado para controlar el auto. Cuando el usuario realiza un gesto,
los valores MPU-6050 son mapeados por Arduino pro mini (transmisor). El controlador
del transmisor codifica este valor como una cadena y lo transmite al Arduino receptor a
través del módulo transmisor de 433 MHz. El Arduino receptor recibe los datos a través
del módulo receptor de 433 MHz . Cuando se reciben los datos en su formato de cadena.
El controlador convierte este “Cadena" en "INT" y luego, según el programa, controla el
automóvil " HACIA DELANTE", " HACIA ATRÁS “, "IZQUIERDA" o
"DERECHA”.
[1]
ASK – Modulación por desplazamiento de amplitud:
En la modulación por desplazamiento de amplitud, la amplitud (es decir, el nivel) de la
onda portadora cambia en respuesta a la señal de datos entrante. Esto a veces se
denomina modulación de cambio de amplitud binaria, ya que en realidad solo hay dos
niveles de los que preocuparse:
§ Digital 1: impulsa la portadora con toda su fuerza.
§ Digital 0 – Esto corta la portadora por completo.
#include <RH_ASK.h> //Radio head ASK Library
RH_ASK rf_driver;
9.3 CÓDIGO DEL CARRO INALÁMBRICO

- //#define DEBUG_ARRAY(a) {for (int index = 0; index < sizeof(a) / sizeof(a[0]);

index++) {Serial.print(a[index]); Serial.print('\t');} Serial.println();};
- #define DEBUG_ARRAY(a) {for (int index = 0; index < sizeof(a) / sizeof(a[0]);
index++) {Serial.print(a[index]); Serial.print('\t');} Serial.println();};
- #include <ESP8266WiFi.h>
- #include <PubSubClient.h>
-
- const char* ssid = "KUKA";
- const char* password = "21122014";
- const char* mqtt_server = "192.168.0.101";
-
-
- WiFiClient espClient;
- PubSubClient client(espClient);
- long lastMsg = 0;
- char msg[50];
- int value = 0;
-
- String yow2, pitch2, roll2;
- int DATOS=0;
- int dutty=200;
- int dutty2=150;
- int vel=0;
- int vel2=0;
- String str = "";
- const char separator = ','; // separador de trama
- const int dataLength = 4; // el numero del incremento para los valores de la cadena
- float data[dataLength]; // tipo de datos que se almacena en el vector
- float motor;
- float pitch, yow, roll;
- #define motor1D D0
- #define motor1I D1
- #define motor2D D2
- #define motor2I D3
- void setup() {
- Serial.begin(9600);
- setup_wifi();
- client.setServer(mqtt_server, 1883);
- client.setCallback(callback);
- pinMode(BUILTIN_LED, OUTPUT);
- pinMode(motor1D, OUTPUT);
- pinMode(motor1I, OUTPUT);
- pinMode(motor2D, OUTPUT);
- pinMode(motor2I, OUTPUT);
- analogWrite(motor1D, 0);
- analogWrite(motor1I, 0);
- analogWrite(motor2D, 0);
- analogWrite(motor2I, 0);
-
- }
-
- void loop() {
- if (!client.connected()) {
- reconnect();
- }
- client.loop();
-
- vel=map(dutty, 0,255,0,1023);
- vel2=map(dutty2, 0,255,0,1023);
-
- while (Serial.available() > 0) {
-
- envioCondicion(); //llama a la funcion envio Condicion
- motor=(data[0]); // guardamos el dato en la variable humedad
- pitch=data[1];
- yow=data[2];
- roll=data[3];
- pitch2=String(pitch,2);
- yow2=String(yow,2);
- roll2=String(roll,2);
- const char *pitch3 = pitch2.c_str();
- const char *roll3 = roll2.c_str();
- const char *yow3 = yow2.c_str();
-
- snprintf (msg, 75, yow3);
- //Serial.print("Publish message: ");
- //Serial.println(msg);
- client.publish("carro/giroscopio/yow", msg);
- snprintf (msg, 75, roll3);
- //Serial.print("Publish message: ");
- //Serial.println(msg);
- client.publish("carro/giroscopio/roll", msg);
- snprintf (msg, 75, pitch3);
- //Serial.print("Publish message: ");
- //Serial.println(msg);
- client.publish("carro/giroscopio/pitch", msg);
- //DATOS=Serial.read();
- if (motor==1){
- analogWrite(motor1D, 0);
- analogWrite(motor1I, vel);
- analogWrite(motor2D, 0);
- analogWrite(motor2I, vel);
- }
- if (motor==2){
- analogWrite(motor1D, vel);
- analogWrite(motor1I, 0);
- analogWrite(motor2D,vel);
- analogWrite(motor2I, 0);
- }
- if (motor==3){
- analogWrite(motor1D,0);
- analogWrite(motor1I,vel2);
- analogWrite(motor2D,vel2);
- analogWrite(motor2I,0);
- }
- if (motor==4){
- analogWrite(motor1D, vel2);
- analogWrite(motor1I, 0);
- analogWrite(motor2D, 0);
- analogWrite(motor2I, vel2);
- }
- if (motor==5){
- analogWrite(motor1D, 0);
- analogWrite(motor1I, 0);
- analogWrite(motor2D, 0);
- analogWrite(motor2I, 0);
- }
-
- }
- delay(200);
-
- }
- void envioCondicion(){
- str = Serial.readStringUntil('\n'); // leemos la cadena
- //Serial.println(str);
- for (int i = 0; i < dataLength ; i++) // inicializamos el for
- {
- int index = str.indexOf(separator); // tomamos valores en funcion del separador
- data[i] = str.substring(0, index).toFloat(); //lo convertimos en flotante
- str = str.substring(index + 1); // aumentamos el index
- }
- }
- void setup_wifi() {
-
- delay(10);
- // We start by connecting to a WiFi network
- Serial.println();
- Serial.print("Connecting to ");
- Serial.println(ssid);
-
- WiFi.begin(ssid, password);
-
- while (WiFi.status() != WL_CONNECTED) {
- delay(500);
- Serial.print(".");
- }
-
- Serial.println("");
- Serial.println("WiFi connected");
- Serial.println("IP address: ");
- Serial.println(WiFi.localIP());
- }
-
- void callback(char* topic, byte* payload, unsigned int length) {
- Serial.print("Message arrived [");
- Serial.print(topic);
- Serial.print("] ");
- for (int i = 0; i < length; i++) {
- Serial.print((char)payload[i]);
- }
- Serial.println();
-
- // Switch on the LED if an 1 was received as first character
- if ((char)payload[0] == '1') {
- digitalWrite(BUILTIN_LED, LOW); // Turn the LED on (Note that LOW is the
voltage level
- // but actually the LED is on; this is because
- // it is acive low on the ESP-01)
- } else {
- digitalWrite(BUILTIN_LED, HIGH); // Turn the LED off by making the voltage
HIGH
- }
-
- }
-
- void reconnect() {
- // Loop until we're reconnected
- while (!client.connected()) {
- Serial.print("Attempting MQTT connection...");
- // Attempt to connect
- if (client.connect("ESP8266Client")) {
- Serial.println("connected");
- // Once connected, publish an announcement...
- client.publish("casa/comedor/temperatura", "Enviando el primer mensaje");
- // ... and resubscribe
- client.subscribe("casa/comedor/temperatura");
- } else {
 - Serial.print("failed, rc=");
- Serial.print(client.state());
- Serial.println(" try again in 5 seconds");
- // Wait 5 seconds before retrying
- delay(5000);
- }
- }
- }

9.3.1 GIROSCOPIOACELERÓMETRO
#include "I2Cdev.h"
#include "MPU6050_6Axis_MotionApps_V6_12.h"
//#include "MPU6050.h" // not necessary if using MotionApps include file
#include <SoftwareSerial.h>
SoftwareSerial mySerial(8,9);
// Arduino Wire library is required if I2Cdev I2CDEV_ARDUINO_WIRE implementation
// is used in I2Cdev.h
#if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
#include "Wire.h"
#endif

// class default I2C address is 0x68

// specific I2C addresses may be passed as a parameter here
// AD0 low = 0x68 (default for SparkFun breakout and InvenSense evaluation board)
// AD0 high = 0x69
MPU6050 mpu;
int16_t ax, ay, az, gx, ggy, gz;
float pitch, yow, roll;
int uno=1;
int dos=2;
int tres=3;
int cuatro=4;
int cinco=5;
//MPU6050 mpu(0x69); // <-- use for AD0 high

/*
==================================================================
=======
NOTE: In addition to connection 3.3v, GND, SDA, and SCL, this sketch
depends on the MPU-6050's INT pin being connected to the Arduino's
external interrupt #0 pin. On the Arduino Uno and Mega 2560, this is
digital I/O pin 2.
=================================================================
======== */

/*
==================================================================
=======
NOTE: Arduino v1.0.1 with the Leonardo board generates a compile error
when using Serial.write(buf, len). The Teapot output uses this method.
The solution requires a modification to the Arduino USBAPI.h file, which
is fortunately simple, but annoying. This will be fixed in the next IDE
release. For more info, see these links:
 http://arduino.cc/forum/index.php/topic,109987.0.html
http://code.google.com/p/arduino/issues/detail?id=958
=================================================================
======== */

// uncomment "OUTPUT_READABLE_QUATERNION" if you want to see the actual

// quaternion components in a [w, x, y, z] format (not best for parsing
// on a remote host such as Processing or something though)
//#define OUTPUT_READABLE_QUATERNION

// uncomment "OUTPUT_READABLE_EULER" if you want to see Euler angles

// (in degrees) calculated from the quaternions coming from the FIFO.
// Note that Euler angles suffer from gimbal lock (for more info, see
// http://en.wikipedia.org/wiki/Gimbal_lock)
//#define OUTPUT_READABLE_EULER

// uncomment "OUTPUT_READABLE_YAWPITCHROLL" if you want to see the yaw/

// pitch/roll angles (in degrees) calculated from the quaternions coming
// from the FIFO. Note this also requires gravity vector calculations.
// Also note that yaw/pitch/roll angles suffer from gimbal lock (for
// more info, see: http://en.wikipedia.org/wiki/Gimbal_lock)
#define OUTPUT_READABLE_YAWPITCHROLL

// uncomment "OUTPUT_READABLE_REALACCEL" if you want to see acceleration

// components with gravity removed. This acceleration reference frame is
// not compensated for orientation, so +X is always +X according to the
// sensor, just without the effects of gravity. If you want acceleration
// compensated for orientation, us OUTPUT_READABLE_WORLDACCEL instead.
//#define OUTPUT_READABLE_REALACCEL

// uncomment "OUTPUT_READABLE_WORLDACCEL" if you want to see acceleration

// components with gravity removed and adjusted for the world frame of
// reference (yaw is relative to initial orientation, since no magnetometer
// is present in this case). Could be quite handy in some cases.
//#define OUTPUT_READABLE_WORLDACCEL

// uncomment "OUTPUT_TEAPOT" if you want output that matches the

// format used for the InvenSense teapot demo
//#define OUTPUT_TEAPOT

#define INTERRUPT_PIN 2 // use pin 2 on Arduino Uno & most boards

#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 gy; // [x, y, z] gyro 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();
Wire.setClock(400000); // 400kHz I2C clock. Comment this line if having compilation
difficulties
#elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE
Fastwire::setup(400, true);
#endif

// initialize serial communication

// (115200 chosen because it is required for Teapot Demo output, but it's
// really up to you depending on your project)
Serial.begin(115200);
while (!Serial); // wait for Leonardo enumeration, others continue immediately

mpu.initialize();
pinMode(INTERRUPT_PIN, INPUT);

devStatus = mpu.dmpInitialize();

// supply your own gyro offsets here, scaled for min sensitivity
mpu.setXGyroOffset(51);
mpu.setYGyroOffset(8);
 mpu.setZGyroOffset(21);
mpu.setXAccelOffset(1150);
mpu.setYAccelOffset(-50);
mpu.setZAccelOffset(1060);
// make sure it worked (returns 0 if so)
if (devStatus == 0) {
// Calibration Time: generate offsets and calibrate our MPU6050
mpu.CalibrateAccel(6);
mpu.CalibrateGyro(6);
Serial.println();
mySerial.begin(9600);
mpu.PrintActiveOffsets();
// turn on the DMP, now that it's ready
Serial.println(F("Enabling DMP..."));
mpu.setDMPEnabled(true);

// enable Arduino interrupt detection

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

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(devStatus);

// 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;
// read a packet from FIFO
if (mpu.dmpGetCurrentFIFOPacket(fifoBuffer)) { // Get the Latest packet

#ifdef OUTPUT_READABLE_QUATERNION
// display quaternion values in easy matrix form: w x y z
 mpu.dmpGetQuaternion(&q, fifoBuffer);

#endif

#ifdef OUTPUT_READABLE_EULER
// display Euler angles in degrees
mpu.dmpGetQuaternion(&q, fifoBuffer);
mpu.dmpGetEuler(euler, &q);

#endif

#ifdef OUTPUT_READABLE_YAWPITCHROLL
// display Euler angles in degrees
mpu.dmpGetQuaternion(&q, fifoBuffer);
mpu.dmpGetGravity(&gravity, &q);
mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);
mpu.getMotion6(&ax, &ay, &az, &gx, &ggy, &gz);
pitch=(float(ax)/1000);
yow=(float(az)/1000);
roll=(float(ay)/1000);
ax=-(ax/1000);
ay=-(ay/1000);
Serial.print("ypr\t");
yow=(ypr[0] * 180 / M_PI);
Serial.print(yow);
Serial.print("\t");
pitch=(ypr[1] * 180 / M_PI);
Serial.print(pitch);
Serial.print("\t");
roll=(ypr[2] * 180 / M_PI);
Serial.print(roll);
Serial.println();
//ADELANTE
if(ax<=-4 && ay>=-3 && ay<=3){
mySerial.print(tres);
mySerial.print(',');
mySerial.print(pitch);
mySerial.print(',');
mySerial.print(yow);
mySerial.print(',');
mySerial.println(roll);
}
//Atras
if(ax>=4 && ay>=-3 && ay<=3){
mySerial.print(cuatro);\
mySerial.print(',');
mySerial.print(pitch);
mySerial.print(',');
mySerial.print(yow);
mySerial.print(',');
mySerial.println(roll);
}
//Dete
if(ax>=-3 && ax<=3 && ay>=-3 && ay<=3){
mySerial.print(cinco);
 mySerial.print(',');
mySerial.print(pitch);
mySerial.print(',');
mySerial.print(yow);
mySerial.print(',');
mySerial.println(roll);
}
// adelantar
if(ay<=-4 && ax>=-3 && ax<=3){
mySerial.print(uno);
mySerial.print(',');
mySerial.print(pitch);
mySerial.print(',');
mySerial.print(yow);
mySerial.print(',');
mySerial.println(roll);
}
// atras
if(ay>=4 && ax>=-3 && ax<=3){
mySerial.print(dos);
mySerial.print(',');
mySerial.print(pitch);
mySerial.print(',');
mySerial.print(yow);
mySerial.print(',');
mySerial.println(roll);

#endif

#ifdef OUTPUT_READABLE_REALACCEL
// display real acceleration, adjusted to remove gravity
mpu.dmpGetQuaternion(&q, fifoBuffer);
mpu.dmpGetAccel(&aa, fifoBuffer);
mpu.dmpGetGravity(&gravity, &q);
mpu.dmpGetLinearAccel(&aaReal, &aa, &gravity);
#endif

#ifdef OUTPUT_READABLE_WORLDACCEL
// display initial world-frame acceleration, adjusted to remove gravity
// and rotated based on known orientation from quaternion
mpu.dmpGetQuaternion(&q, fifoBuffer);
mpu.dmpGetAccel(&aa, fifoBuffer);
mpu.dmpGetGravity(&gravity, &q);
mpu.dmpGetLinearAccel(&aaReal, &aa, &gravity);
mpu.dmpGetLinearAccelInWorld(&aaWorld, &aaReal, &q);
#endif

#ifdef OUTPUT_TEAPOT
// display quaternion values in InvenSense Teapot demo format:
teapotPacket[2] = fifoBuffer[0];
teapotPacket[3] = fifoBuffer[1];
teapotPacket[4] = fifoBuffer[4];
 teapotPacket[5] = fifoBuffer[5];
teapotPacket[6] = fifoBuffer[8];
teapotPacket[7] = fifoBuffer[9];
teapotPacket[8] = fifoBuffer[12];
teapotPacket[9] = fifoBuffer[13];
teapotPacket[11]++; // packetCount, loops at 0xFF on purpose
#endif // blink LED to indicate activity
blinkState = !blinkState;

}
}

9.4 Controlador de guante inalámbrico ensamblado

En el guante se utilizó un módulo bluetooh hc05 donde va ser el maestro. De tal forma
se utilizó un Arduino mini, un giroscopio mpu6050 se va generar loa ángulos punch,
yow y roll, un swich, por último, una batería. Y en este lo acoplamos una baquelita
perforada y se le une al guante.

Fig 4. Guante inalámbrico ensamblado.

9.5 Carro inalámbrico ensamblado

El carro inalámbrico de la misma forma se utilizó un módulo Bluetooth HC-05,

una protoboard pequeña, un esp 8266 el que hace la comunicación MQTT en
notred. De tal manera que nuestro bluetooth sea el esclavo se necesita un driver
de motor para controlar los motores DC y una batería.
 Fig 5. Carro inalámbrico.

Fig 6. Vista frontal del carro inalámbrico.

10 Implementación

Por último, podemos comprobar el funcionamiento del guante inalámbrico ya ensamblado y

también el carro inalámbrico donde se puede observar en la imagen los movimientos que se
realizo y verificar si se cumple cada uno de los parámetros establecidos para este proyecto.

Fig 7. Implementación Final.

.
10.1 Visualización de datos

- Se puede observar el monitoreo de las gráficas.

Fig 8. Monitoreo.

- Se utilizó un router y una raspberry para que nos de los valores individuales del
pich, yow, roll. Con la dirección IP 192.168.0.101 y se realizó las respectivas
configuraciones.

11 ANEXOS

Fig 9. Gráficas pich, yow,roll.

 Fig 10. Visualización de datos.

12 Conclusiones

 El empleo de sistemas automatizados, como vehículos autónomos, permite a las

industrias aumentar la productividad, beneficiarse de una amplia gama de
tecnologías y capacidades y mejorar la seguridad en el lugar de trabajo, la
mayoría de los sistemas existentes consideran utilizar un tipo de vehículo
autónomo.
 Al proporcionar alta capacidad, cobertura extendida y mejor calidad de
servicios, los sistemas de colaboración autónomos pueden permitir casos de uso
emergentes, como el monitoreo remoto y la asistencia a la navegación.
 Usando resultados de medición y simulación, evaluamos el desempeño de los
enlaces diseñados en diferentes escenarios de comunicación y mostramos los
beneficios de emplear múltiples vehículos autónomos en el sistema de
comunicación propuesto.
 Pueden equiparse con sensores portátiles que son capaces de comunicar sus
datos a través de una cadena de dispositivos para un control ágil y eficaz de su
movilidad. Este trabajo describe un completo sistema de extremo a extremo
implementado a través de la integración de diferentes tecnologías
complementarias.
13 Bibliografías

[1] Trasmdigital, «uv.eS,» 7 6 2019. [En línea]. Available:

https://www.uv.es/~hertz/hertz/Docencia/teoria/Trasmdigital.pdf. [Último acceso: 5 12
2022].
[2] hetpro-store, «hetpro-store,» 7 6 2020. [En línea]. Available:
https://hetpro-store.com/TUTORIALES/modulo-acelerometro-y-giroscopio-mpu6050-i2c-
twi/. [Último acceso: 07 12 2022].
[3] «naylampmechatronics,» 7 6 2018. [En línea]. Available:
https://naylampmechatronics.com/blog/45_tutorial-mpu6050-acelerometro-y-
giroscopio.html. [Último acceso: 5 12 2022].
[4] Luisllamas, «arduino-orientacion,» 7 8 2019. [En línea]. Available:
https://www.luisllamas.es/arduino-orientacion-imu-mpu-6050/. [Último acceso: 5 12 2022].