{"id":4477,"date":"2018-03-02T19:25:16","date_gmt":"2018-03-02T18:25:16","guid":{"rendered":"https:\/\/www.diarioelectronicohoy.com\/blog\/?p=4477"},"modified":"2022-06-08T17:30:10","modified_gmt":"2022-06-08T15:30:10","slug":"configurar-el-mpu6050","status":"publish","type":"post","link":"https:\/\/www.diarioelectronicohoy.com\/blog\/configurar-el-mpu6050","title":{"rendered":"Configurar el MPU6050."},"content":{"rendered":"

INTRODUCCI\u00d3N.<\/h3>\n

Este tutorial, es una extensi\u00f3n del art\u00edculo\u00a0sensormpu6050<\/a>. EL m\u00f3dulo MPU6050 contiene un giroscopio de tres ejes con el que podemos medir velocidad angular y un aceler\u00f3metro tambi\u00e9n de 3 ejes con el que medimos los componentes X, Y y Z de la aceleraci\u00f3n, el aceler\u00f3metro trabaja sobre el principio piezo el\u00e9ctrico, posee adem\u00e1s de un sensor de temperatura.<\/p>\n

Los aceler\u00f3metros internamente tienen un MEMS (MicroElectroMechanical Systems) que de forma similar a un sistema masa-resorte permite medir la aceleraci\u00f3n. Los giroscopios utilizan un MEMS (MicroElectroMechanical Systems) para medir la velocidad angular usando el efecto Coriolis.<\/p>\n

En esta ocasi\u00f3n presento un ejemplo simple de c\u00f3mo interconectar el MPU-6050 con una placa Arduino. El MPU6050 es un sensor de movimiento, que tiene un conversor ADC de 16 bits que convierte los datos a un valor digital, el m\u00f3dulo de giroscopio se comunica con el Arduino a trav\u00e9s de la comunicaci\u00f3n serie I2C a trav\u00e9s del reloj serial (SCL) y datos (SDA), el chip MPU6050 necesita 3.3V pero un regulador de voltaje en la tarjeta GY-521 le permite alimentarlo hasta 5V, en nuestro caso en un Arduino con el que haremos unos ejercicios.<\/p>\n

El procesador interno del IMU (Inertial Measurment Units) es capaz de realizar c\u00e1lculos precisos de los valores que miden sus sensores internos que son, aceleraciones lineales y angulares, para informarnos de valores \u00fatiles como los \u00e1ngulos de inclinaci\u00f3n con respecto a los 3 ejes principales. Un dato importante es que ni la aceleraci\u00f3n ni la velocidad lineal afectan la medici\u00f3n de giro.<\/p>\n

La direcci\u00f3n de los ejes est\u00e1 indicado en el m\u00f3dulo el cual hay que tener en cuenta para no equivocarnos en el signo de las aceleraciones. Como la comunicaci\u00f3n del m\u00f3dulo es v\u00eda I2C, esto le permite trabajar con la mayor\u00eda de microcontroladores. En el m\u00f3dulo los pines SCL y SDA tienen una resistencia pull-up en placa para una conexi\u00f3n directa al microcontrolador que estemos utilizando.<\/p>\n

\"\"<\/a>Fig. 1<\/p>\n

Alguien como Jeff Rowberg ya ha hecho el trabajo duro por nosotros, escribi\u00f3 algunas bibliotecas de Arduino para obtener los datos del aceler\u00f3metro\/giroscopio y manejar todos los c\u00e1lculos. Las librer\u00edas est\u00e1n disponibles como un archivo zip desde\u00a0aqu\u00ed<\/a>.<\/p>\n

Y tambi\u00e9n las puede descargar de:
\nhttps:\/\/github.com\/jrowberg\/i2cdevlib\/tree\/master\/Arduino\/MPU6050<\/a>
\ny la encargada de I2Cdev de:
\nhttps:\/\/github.com\/jrowberg\/i2cdevlib\/tree\/master\/Arduino\/I2Cdev<\/a><\/p>\n

Instalar las librer\u00edas en el IDE Arduino, con ellas podremos trabajar los siguientes ejercicios. Una vez descomprimido, copie las dos carpetas \u201cI2Cdev\u201d y \u201cMPU6050\u201d en su carpeta Arduino \u201clibraries\u201d en el siguiente directorio:\u00a0C: \\ Archivos de programa (x86) \\ Arduino \\ libraries<\/em><\/p>\n

EL CIRCUITO.<\/h3>\n

\"\"<\/a>Fig. 2 Circuito.<\/p>\n

Abra su Arduino si no lo tiene abierto ya, vaya al men\u00fa Archivos\/Ejemplos\u2026 y navegue hasta MPU6050> y encontrar\u00e1 el archivo MPU6050_DMP6, \u00e1bralo y seleccione el puerto COM adecuado, suba el boceto. En el monitor Serial elija la velocidad de 115200 Baudios.<\/p>\n

\"\"<\/a>Fig. 3 Archivo MPU6050_DMP6.<\/p>\n

Le aparecer\u00e1 una indicaci\u00f3n, pruebe a escribir alg\u00fan dato y pulse Enter, en ese momento deber\u00edan aparecer los datos, lo que indica que todo est\u00e1 saliendo bien.<\/p>\n

\"\"<\/a>Fig. 4 Monitor Serial.<\/p>\n

CALIBRANDO EL MPU6050<\/h3>\n

Muchos de los ejemplos que podemos encontrar, tienen un problema y es que presentan muchas vibraciones y ruido en las medidas, adem\u00e1s cuando tengamos instalado el m\u00f3dulo MPU6050 en el proyecto, siempre puede haber un desnivel en sus componentes, motivo por el cual debemos calibrar el m\u00f3dulo, asegur\u00e1ndonos de que no haya un error de desnivel agregado en cada componente.<\/p>\n

\"\"<\/a>Fig. 5 Ejes Tait-Brayan o Euler<\/p>\n

Podemos solucionar estos problemas al configurar el m\u00f3dulo MPU6050 OFFSETS, para compensar dichos errores.<\/p>\n

Este c\u00f3digo nos sirve para\u00a0calibrar los offset<\/strong>\u00a0del MPU6050.<\/form>\n
\/\/ calibrar_mpu6050.ino\r\n\/\/ Librerias I2C para controlar el mpu6050 con Arduino,\r\n\/\/ la libreria MPU6050.h necesita I2Cdev.h, la libreria I2Cdev.h necesita Wire.h\r\n \r\n#include \"I2Cdev.h\"\r\n#include \"MPU6050.h\"\r\n#include \"Wire.h\"\r\n \r\n\/\/ La direcci\u00f3n del MPU6050 puede ser 0x68 o 0x69, dependiendo \r\n\/\/ del estado de AD0. Si no se especifica, 0x68 estar\u00c3\u00a1 implicito\r\nMPU6050 sensor;\r\n \r\n\/\/ Valores RAW (sin procesar) del acelerometro y giroscopio en los ejes x,y,z\r\nint ax, ay, az;\r\nint gx, gy, gz;\r\n \r\n\/\/Variables usadas por el filtro pasa bajos\r\nlong f_ax,f_ay, f_az;\r\nint p_ax, p_ay, p_az;\r\nlong f_gx,f_gy, f_gz;\r\nint p_gx, p_gy, p_gz;\r\nint counter=0;\r\n \r\n\/\/Valor de los offsets\r\nint ax_o,ay_o,az_o;\r\nint gx_o,gy_o,gz_o;\r\n \r\nvoid setup() {\r\n  Serial.begin(57600);   \/\/Iniciando puerto serial\r\n  Wire.begin();           \/\/Iniciando I2C  \r\n  sensor.initialize();    \/\/Iniciando el sensor\r\n \r\n  if (sensor.testConnection()) Serial.println(\"Sensor iniciado correctamente\");\r\n \r\n  \/\/ Leer los offset los offsets anteriores\r\n  ax_o=sensor.getXAccelOffset();\r\n  ay_o=sensor.getYAccelOffset();\r\n  az_o=sensor.getZAccelOffset();\r\n  gx_o=sensor.getXGyroOffset();\r\n  gy_o=sensor.getYGyroOffset();\r\n  gz_o=sensor.getZGyroOffset();\r\n  \r\n  Serial.println(\"Offsets:\");\r\n  Serial.print(ax_o); Serial.print(\"\\t\"); \r\n  Serial.print(ay_o); Serial.print(\"\\t\"); \r\n  Serial.print(az_o); Serial.print(\"\\t\"); \r\n  Serial.print(gx_o); Serial.print(\"\\t\"); \r\n  Serial.print(gy_o); Serial.print(\"\\t\");\r\n  Serial.print(gz_o); Serial.println(\"\\t\");\r\n \r\n  Serial.println(\"nnEnvie cualquier caracter para empezar la calibracionnn\");  \r\n  \/\/ Espera un caracter para empezar a calibrar\r\n  while (true){if (Serial.available()) break;}  \r\n  Serial.println(\"Calibrando, no mover IMU\");    \r\n}\r\n \r\nvoid loop() {\r\n  \/\/ Leer las aceleraciones y velocidades angulares\r\n  sensor.getAcceleration(&ax, &ay, &az);\r\n  sensor.getRotation(&gx, &gy, &gz);\r\n \r\n  \/\/ Filtrar las lecturas\r\n  f_ax = f_ax-(f_ax>>5)+ax;\r\n  p_ax = f_ax>>5;\r\n \r\n  f_ay = f_ay-(f_ay>>5)+ay;\r\n  p_ay = f_ay>>5;\r\n \r\n  f_az = f_az-(f_az>>5)+az;\r\n  p_az = f_az>>5;\r\n \r\n  f_gx = f_gx-(f_gx>>3)+gx;\r\n  p_gx = f_gx>>3;\r\n \r\n  f_gy = f_gy-(f_gy>>3)+gy;\r\n  p_gy = f_gy>>3;\r\n \r\n  f_gz = f_gz-(f_gz>>3)+gz;\r\n  p_gz = f_gz>>3;\r\n \r\n  \/\/Cada 100 lecturas corregir el offset\r\n  if (counter==100){\r\n    \/\/Mostrar las lecturas separadas por un [tab]\r\n    Serial.print(\"promedio:\"); Serial.print(\"\\t\");\r\n    Serial.print(p_ax); Serial.print(\"\\t\");\r\n    Serial.print(p_ay); Serial.print(\"\\t\");\r\n    Serial.print(p_az); Serial.print(\"\\t\");\r\n    Serial.print(p_gx); Serial.print(\"\\t\");\r\n    Serial.print(p_gy); Serial.print(\"\\t\");\r\n    Serial.println(p_gz);\r\n \r\n    \/\/Calibrar el acelerometro a 1g en el eje z (ajustar el offset)\r\n    if (p_ax>0) ax_o--;\r\n    else {ax_o++;}\r\n    if (p_ay>0) ay_o--;\r\n    else {ay_o++;}\r\n    if (p_az-16384>0) az_o--;\r\n    else {az_o++;}\r\n    \r\n    sensor.setXAccelOffset(ax_o);\r\n    sensor.setYAccelOffset(ay_o);\r\n    sensor.setZAccelOffset(az_o);\r\n \r\n    \/\/Calibrar el giroscopio a 0\u00ba\/s en todos los ejes (ajustar el offset)\r\n    if (p_gx>0) gx_o--;\r\n    else {gx_o++;}\r\n    if (p_gy>0) gy_o--;\r\n    else {gy_o++;}\r\n    if (p_gz>0) gz_o--;\r\n    else {gz_o++;}\r\n    \r\n    sensor.setXGyroOffset(gx_o);\r\n    sensor.setYGyroOffset(gy_o);\r\n    sensor.setZGyroOffset(gz_o);    \r\n \r\n    counter=0;\r\n  }\r\n  counter++;\r\n}<\/pre>\n
Durante la calibraci\u00f3n deberemos mantener el sensor sin moverlo en la posici\u00f3n de trabajo habitual, entonces el programa empieza por leer los offsets y nos pide que enviemos un car\u00e1cter por el puerto serie. El programa trata de corregir los errores de las medidas, para ello modifica constantemente el offest, usando un filtro y cada 100 lecturas comprueba los valores si se acercan a los que deseamos leer, aumentando o disminuyendo los offsets. Esto har\u00e1 que las lecturas filtradas se acerquen a:
\n-aceleraci\u00f3n: p_ax=0 , p_ay=0 , p_az=+16384
\n-velocidad angular: p_gx=0 , p_gy=0 , p_gz=0<\/em><\/p>\n
\"\"<\/a>Fig. 6 Calibrado del PMU6050.<\/p>\n
Tal como indica en el monitor debemos anotar las compensaciones obtenidas para configurarlas en nuestros proyectos, usando la funci\u00f3n mpu.setXAccelOffset(), como se indica a continuaci\u00f3n.<\/p>\n
Abriremos el archivo MPU6050_PMT y buscaremos la parte de\u00a0Calibration results<\/em>\u00a0como se aprecia en la figura que sigue.<\/p>\n
\"\"<\/a>Fig. 7 Configurar el boceto.<\/p>\n
La calibraci\u00f3n solo es necesario hacerla una vez. EL filtro complemento en si, es para combinar el aceler\u00f3metro y el giroscopio. Si solo utiliz\u00e1ramos el aceler\u00f3metro para determinar el \u00e1ngulo, cualquier aceleraci\u00f3n generada por un desplazamiento generar\u00eda errores en el \u00e1ngulo. En cambio s\u00ed solo usamos el giroscopio vamos a obtener un error acumulativo por causa de la integraci\u00f3n de w (velocidad angular). Este filtro se utiliza acunado, queremos sensar el \u00e1ngulo pero el MPU est\u00e1 en constante movimiento (Drones, robots m\u00f3viles, etc). En cambio, si el PMU va a estar fijo podemos tomar s\u00f3lo el vector de la aceleraci\u00f3n de la gravedad para determinar los \u00e1ngulos.<\/p>\n
ESCALADO DE LECTURAS<\/h3>\n
Ahora, vamos a escalar las lecturas a valores con las unidades de aceleraci\u00f3n y velocidad angular. Carguemos el siguiente programa que usa una ecuaci\u00f3n para convertir el valor le\u00eddo en un valor de aceleraci\u00f3n o velocidad angular.<\/p>\n
Este c\u00f3digo nos permite\u00a0escalar valores<\/strong>\u00a0de aceleraci\u00f3n y velocidad angular.<\/p>\n
\/\/ escalar_valores.ino\r\n\/\/ Librerias I2C para controlar el mpu6050 con Arduino,\r\n\/\/ la libreria MPU6050.h necesita I2Cdev.h y la libreria I2Cdev.h necesita Wire.h\r\n\/* \r\n Conociendo los rangos con los que est\u00e1 configurado nuestro MPU6050, \r\n dichos rangos pueden ser 2g\/4g\/8g\/16g para el aceler\u00f3metro y \r\n 250\/500\/1000\/2000(\u00b0\/s) para el giroscopio.\r\n Los rangos por defecto (2g y 250\u00b0\/s)\r\n \r\n Variable        valor m\u00ednimo  valor central  valor m\u00e1ximo\r\n Lectura MPU6050    -32768        0             +32767 \r\n Aceleraci\u00f3n         -2g          0g            +2g\r\n Velocidad angular  -250\u00b0\/s       0\u00b0\/s          +250\u00b0\/s\r\n*\/\r\n \r\n#include \"I2Cdev.h\"\r\n#include \"MPU6050.h\"\r\n#include \"Wire.h\"\r\n \r\n\/\/ La direcci\u00f3n del MPU6050 puede ser 0x68 o 0x69, dependiendo \r\n\/\/ del estado de AD0. Si no se especifica, 0x68 estar\u00e1 implicito\r\nMPU6050 sensor;\r\n \r\n\/\/ Valores RAW (sin procesar) del acelerometro y giroscopio en los ejes x,y,z\r\nint ax, ay, az;\r\nint gx, gy, gz;\r\n \r\nvoid setup() {\r\n  Serial.begin(57600);    \/\/Iniciando puerto serial\r\n  Wire.begin();           \/\/Iniciando I2C  \r\n  sensor.initialize();    \/\/Iniciando el sensor\r\n \r\n  if (sensor.testConnection()) Serial.println(\"Sensor iniciado correctamente\");\r\n  else Serial.println(\"Error al iniciar el sensor\");\r\n}\r\n \r\nvoid loop() {\r\n  \/\/ Leer las aceleraciones y velocidades angulares\r\n  sensor.getAcceleration(&ax, &ay, &az);\r\n  sensor.getRotation(&gx, &gy, &gz);\r\n  float ax_m_s2 = ax * (9.81\/16384.0);\r\n  float ay_m_s2 = ay * (9.81\/16384.0);\r\n  float az_m_s2 = az * (9.81\/16384.0);\r\n  float gx_deg_s = gx * (250.0\/32768.0);\r\n  float gy_deg_s = gy * (250.0\/32768.0);\r\n  float gz_deg_s = gz * (250.0\/32768.0);\r\n \r\n  \/\/Mostrar las lecturas separadas por un [tab]\r\n  Serial.print(\"a[x y z](m\/s2) g[x y z](deg\/s):\\t\");\r\n  Serial.print(ax_m_s2); Serial.print(\"\\t\");\r\n  Serial.print(ay_m_s2); Serial.print(\"\\t\");\r\n  Serial.print(az_m_s2); Serial.print(\"\\t\");\r\n  Serial.print(gx_deg_s); Serial.print(\"\\t\");\r\n  Serial.print(gy_deg_s); Serial.print(\"\\t\");\r\n  Serial.println(gz_deg_s);\r\n \r\n  delay(100);\r\n}<\/pre>\n
\u00a0Con el MPU6050, s\u00f3lo podemos obtener los \u00e1ngulos X e Y, con el filtro de complemento usamos los \u00e1ngulos obtenidos del aceler\u00f3metro, los cuales se limitan a X e Y, puesto que una rotaci\u00f3n en Z del aceler\u00f3metro no la detectar\u00e1 ya que usamos la gravedad para determinar el \u00e1ngulo. Para esto es mejor usar un Magnet\u00f3metro similar al HMC5883L.<\/p>\n
\"\"<\/a>Fig. 8 Escalar valores de acel\/grad.<\/p>\n
Los valores obtenidos ya est\u00e1n escalados a unidades de aceleraci\u00f3n y velocidad angular, hemos convertido la aceleraci\u00f3n a valores en m\/s^2 por lo que se reemplaz\u00f3 el valor de g=9.81 si el sensor se mantiene en posici\u00f3n horizontal se deben obtener mediciones cercanas a 9.8 m\/s^2 (aceleraci\u00f3n de la gravedad terrestre) es la componente z de la aceleraci\u00f3n.<\/p>\n
SIMULACI\u00d3N 3D.<\/h3>\n
Para ejecutar la demostraci\u00f3n o simulaci\u00f3n 3D, vamos a utilizar una sencilla maqueta de un Eurofighter para que se comprenda mejor la evoluci\u00f3n de los par\u00e1metros\u00a0Yaw<\/em>,\u00a0Roll<\/em>\u00a0y\u00a0Pitch<\/em>\u00a0a medida que se generan al cambiar la posici\u00f3n del IMU.<\/p>\n
El primer paso es subir el c\u00f3digo al IDE Arduino o si lo prefiere al nodeMCU, vamos a probar con Arduino, en ese caso, nos sirve el circuito descrito en la figura 2, en el que la conexi\u00f3n INT del MPU6050 no es necesaria.<\/p>\n
En el caso de utilizar el nodeMCU12, el esquema es el siguiente:<\/p>\n
\"\"<\/a>Fig. 9 Conexiones nodeMCU e IMU.<\/p>\n
EL C\u00d3DIGO.<\/h3>\n
El c\u00f3digo\u00a0obtener inclinaci\u00f3n<\/strong>\u00a0viene bastante bien descrito y no har\u00e1 falta muchas aclaraciones.<\/p>\n
\/*\r\n*   obtener_inclinacion.ino\r\n* Con el c\u00f3digo se leen datos de la MPU-6050, este c\u00f3digo \r\n* es modificado de la web: \r\n* http:\/\/robologs.net\/2014\/10\/15\/tutorial-de-arduino-y-mpu-6050\/\r\n* \r\n* Descrito muy bien en el v\u00eddeo: \r\n* https:\/\/www.youtube.com\/watch?v=uN8SYfGwYVw&t=164s\r\n*\r\n*  El factor de conversi\u00f3n: w= Lectura*(250\/32768) = lectura*(1\/131)\r\n*\/\r\n \r\n#include \"Wire.h\" \/\/ librer\u00eda Wire.h\r\n \r\n\/\/Direccion I2C de la IMU\r\n#define MPU 0x68\r\n \r\n\/\/Ratios de conversion\r\n#define A_R 16384.0    \/\/ 32768\/2\r\n#define G_R 131.0       \/\/ 32768\/250\r\n \r\n\/\/Conversion de radianes a grados 180\/PI\r\n#define RAD_A_DEG = 57.295779\r\n \r\n\/\/MPU-6050 da los valores en enteros de 16 bits\r\n\/\/Valores RAW\r\nint16_t AcX, AcY, AcZ, GyX, GyY, GyZ;\r\n \r\n\/\/Angulos\r\nfloat Acc[2];\r\nfloat Gy[3];\r\nfloat Angle[3];\r\n \r\nString valores;\r\n \r\nlong tiempo_prev;\r\nfloat dt;\r\n \r\nvoid setup()\r\n{\r\n Wire.begin(); \/\/ D2(GPIO4)=SDA \/ D1(GPIO5)=SCL\r\n Wire.beginTransmission(MPU);\r\n Wire.write(0x6B);\r\n Wire.write(0);\r\n Wire.endTransmission(true);\r\n Serial.begin(115200);\r\n}\r\n \r\nvoid loop()\r\n{\r\n   \/\/Leer los valores del Acelerometro de la IMU\r\n   Wire.beginTransmission(MPU);\r\n   Wire.write(0x3B); \/\/Pedir el registro 0x3B - corresponde al AcX\r\n   Wire.endTransmission(false);\r\n   Wire.requestFrom(MPU,6,true);   \/\/A partir del 0x3B, se piden 6 registros\r\n   AcX=Wire.read()<<8|Wire.read(); \/\/Cada valor ocupa 2 registros\r\n   AcY=Wire.read()<<8|Wire.read();\r\n   AcZ=Wire.read()<<8|Wire.read();\r\n \r\n   \/\/A partir de los valores del acelerometro, se calculan los angulos Y, X\r\n   \/\/respectivamente, con la formula de la tangente.\r\n   Acc[1] = atan(-1*(AcX\/A_R)\/sqrt(pow((AcY\/A_R),2) + pow((AcZ\/A_R),2)))*RAD_TO_DEG;\r\n   Acc[0] = atan((AcY\/A_R)\/sqrt(pow((AcX\/A_R),2) + pow((AcZ\/A_R),2)))*RAD_TO_DEG;\r\n \r\n   \/\/Leer los valores del Giroscopio\r\n   Wire.beginTransmission(MPU);\r\n   Wire.write(0x43);\r\n   Wire.endTransmission(false);\r\n   Wire.requestFrom(MPU,6,true);   \/\/A partir del 0x43, se piden 6 registros\r\n   GyX=Wire.read()<<8|Wire.read(); \/\/Cada valor ocupa 2 registros\r\n   GyY=Wire.read()<<8|Wire.read();\r\n   GyZ=Wire.read()<<8|Wire.read();\r\n \r\n   \/\/Calculo del angulo del Giroscopio\r\n   Gy[0] = GyX\/G_R;\r\n   Gy[1] = GyY\/G_R;\r\n   Gy[2] = GyZ\/G_R;\r\n \r\n   dt = (millis() - tiempo_prev) \/ 1000.0;\r\n   tiempo_prev = millis();\r\n \r\n   \/\/Aplicar el Filtro Complementario\r\n   Angle[0] = 0.98 *(Angle[0]+Gy[0]*dt) + 0.02*Acc[0];\r\n   Angle[1] = 0.98 *(Angle[1]+Gy[1]*dt) + 0.02*Acc[1];\r\n \r\n   \/\/Integraci\u00f3n respecto del tiempo paras calcular el YAW\r\n   Angle[2] = Angle[2]+Gy[2]*dt;\r\n \r\n   \/\/Mostrar los valores por consola\r\n   valores = \"90, \" +String(Angle[0]) + \",\" + String(Angle[1]) + \",\" + String(Angle[2]) + \", -90\";\r\n   Serial.println(valores);\r\n   \r\n   delay(10);\r\n}<\/pre>\n
Copie y pegue el anterior c\u00f3digo y gu\u00e1rdelo con un nombre por ej.\u00a0simulador.ino<\/em>, s\u00fabalo al IDE Arduino o al nogeMCU y ejec\u00fatelo. Cuando termine, si todo ha ido bien, al abrir el monitor serie podr\u00e1 ver como surgen los valores que detecta el IMU.<\/p>\n
\"\"<\/a>Fig. 10 Monitor Serial.<\/p>\n
Para tener una imagen m\u00e1s aproximada de lo que representan estos valores, vamos a poder ver la evoluci\u00f3n de estos datos con la ayuda del monitor llamado\u00a0Serial Plotter<\/em>, pulse\u00a0CRTL+May\u00fas+L<\/em>\u00a0o vaya al men\u00fa\u00a0Herramientas\/Serial Plotter<\/em>, se abre una ventana que nos muestra unas l\u00edneas de colores que indican el progreso de los par\u00e1metros YAW, PITCH y ROLL en la medida que se producen.<\/p>\n
\"tres-ejes.gif\"<\/a>Fig. 11 Tres ejes.<\/p>\n
En la nueva ventana aparecen unas l\u00edneas de colores que corresponden a los ya mencionados\u00a0YAW, PITCH y ROLL<\/em>\u00a0(seg\u00fan se puede ver en la figura 11). Pueden apreciarse las variaciones de cada l\u00ednea de color en su evoluci\u00f3n.<\/p>\n
\"\"<\/a>Fig. 12 Serial Plotter.<\/p>\n
Estos datos que he intentado describir se aprecian mejor en el v\u00eddeo que he realizado y se muestra a continuaci\u00f3n.<\/p>\n