5

Tutorial de Realidad Virtual con Arduino y Godot

Hace un tiempo mi compañera Glare escribió esta serie de tutoriales que explicaban cómo construir un casco de Realidad Virtual DIY low-cost basado en Arduino, que funcionaba con el motor de juegos de Blender. Si bien no es ni de lejos tan profesional como las plataformas más populares (Oculus Rift, HTC vive), este casco es un proyecto ideal para poder aprender el funcionamiento básico de un casco de RV y poder construir tus propios mundos virtuales.

Por desgracia, con la llegada de la versión 2.8 de Blender el motor de juegos ha sido finiquitado y se ha abandonado totalmente su desarrollo. Una buena alternativa a BGE es Godot Engine, un motor de juegos que últimamente está cosechando muy buena fama debido a su robustez y a que es libre y gratuito.

Hoy te enseñaré cómo adaptar este sistema de RV DIY  para que funcione con Godot Engine en vez de Blender Game Engine. Verás cómo construir el casco paso a paso y aprenderás a preparar una escena de Godot para la Realidad Virtual.


Componentes necesarios

  • IMU BNO055 Una IMU es un dispositivo que permite medir la rotación. Normalmente se utiliza en móviles, drones y aviones de aeromodelismo; en nuestro caso, la acoplaremos al casco para saber la inclinación de la cabeza.

    IMU BNO055

     

  • Placa Arduino: leerá los valores de la IMU y los enviará al ordenador a través de Serial.
  • Soporte de RV para Smartphones – Estos soportes son una alternativa low-cost a los cascos de Realidad Virutal profesionales. Constan sólo de un chasis y se utiliza un smartphone como pantalla, aunque nosotros usaremos un display de 5” en vez de un teléfono móvil. Te recomiendo el casco Woxter Neo VR1, que es el que tengo y sé que es adecuado para nuestro proyecto (pero puedes utilizar cualquier otro que tenga dimensiones similares)

    Este tipo de cascos de RV están pensados para colocar un Smartphone dentro para que actúe como pantalla.

  • Pantalla de 5” – La colocaremos dentro del casco de RV en vez del Smartphone, y la conectaremos al ordenador por HDMI. La que he utilizado es parecida a esta, pero puedes encontrarlas mucho más baratas.
  • Algo para enganchar la placa Arduino y la IMU al casco – Yo he utilizado un poco de cinta adhesiva de doble cara.
  • Un ordenador con el IDE de Arduino y Godot Engine instalados.
  • Lógicamente, todos los cables y conectores necesarios para conectar las piezas: USB, HDMI, cables de prototipado…

En total, a mí el casco me ha costado unos 120€. Aunque si buscas bien y eres selectivo con los componentes estoy convencido que puedes construirlo por un coste mucho menor.


Resumen del funcionamiento del casco

  1. La IMU se coloca en el casco para calcular su inclinación y así saber hacia donde mira el usuario. La IMU envía las lecturas de rotación a la placa Arduino.

  2. La placa Arduino junta el valor de los tres ángulos XYZ en un solo mensaje que envía por Serial a un ordenador con Godot Engine.

  3. Godot, mediante un script Python y la librería PySerial, decodifica el mensaje que ha enviado Arduino, extrae los ángulos X, Y, Z y rota la cámara de la escena para que el usuario pueda ver el entorno.

  4. El ordenador envía la imagen de la escena 3D a través de HDMI a una pantalla de 5’’ colocada dentro del casco.

Al mover la cabeza variará la lectura de la IMU, que a su vez modificará la rotación de la cámara de Godot. Esto producirá una sensación de Realidad Virtual.


1. Programar Arduino y el BNO055

Cuando uno intenta hacer un proyecto complejo es buena idea separarlo por partes y asegurarse que cada una de ellas funcione. Lo primero, pues, será programar la placa Arduino para que lea la IMU y envíe los datos por Serial.

Para que el usuario tenga la sensación de estar dentro de la escena virtual, la cámara de la escena 3D debe moverse hacia donde la persona esté mirando. Si el usuario gira la cabeza hacia la derecha, la cámara también debe moverse en esta dirección y así poder ver los objetos que hay al lado. Por lo tanto el primer problema al que nos enfrentamos es saber en qué dirección está mirando el usuario, y para ello hay que saber la rotación de su cabeza.

Una IMU es una combinación de Giroscopio, Acelerómetro y algunas veces Magnetómetro que permite medir inclinaciones. El BNO055 es una IMU de 9 grados de libertad (9 Degrees of Fredoom), lo que quiere decir que podrá medir la rotación alrededor de los 3 ejes X, Y, Z. Si enganchamos la IMU al casco de RV, su rotación será la misma que la cabeza del usuario.

(La dirección de los ejes puede cambiar en función del fabricante)

1.1 – Instalar librerías

Para conseguir lecturas precisas de una IMU, normalmente se aplican algoritmos matemáticamente complicados como el Filtro de Kálman o el Filtro de Madgwick.

Por suerte el BNO055 dispone de librerías que nos ahorran el trabajo duro y nos dan las lecturas de los ángulos ya preparadas: la librería AdafruitSensor y la librería Adafruit BNO055. Una vez las tengas descargadas, abre el IDE de Arduino y ve a la pestaña SketchImportar LibreríaAñadir librería y busca los dos ficheros .zip que acabas de descargar.

Puede que te salte un error a la hora de importarlas, diciendo que la librería contiene carácteres erróneos. Si es así, elimina los carácteres “-” y “_” del nombre de los archivos .zip.

1.2 – Conexiones

Las conexiones entre Arduino y el BNO055 serán:

  • Arduino 5V → IMU VCC
  • Arduino GND → IMU GND
  • Arduino SDA → IMU SDA
  • Arduino SCL → IMU SCL

Normalmente los pines SDA y SCL de Arduino son los pines A4 y A5 respectivamente. Sin embargo, deberías leerte esta referencia antes de conectar nada.

1.3 – Código de Arduino

Vamos a escribir un código que lea los tres ángulos de la IMU, los junte en un único string y lo envíe por serial. Todos los mensajes enviados tendrán este formato:

Este será el código que tendrás que cargar en tu placa Arduino. Ten en cuenta que quizá tendrás que modificar las correcciones de los ángulos dependiendo del modelo exacto de tu IMU y de como la coloques sobre el casco de RV.

/*
  REALIDAD VIRTUAL CON ARDUINO
  Codigo para leer la inclinacion del casco RV
   
  Lee la inclinacion de los tres ejes de una IMU BNO055
  y los envia por Serial.
   
  Escrito con mucha ilusion por Glare y Transductor
  www.robologs.net
 
*/
 
 
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BNO055.h>
#include <utility/imumaths.h>
 
//Delay entre lecturas
#define BNO055_SAMPLERATE_DELAY_MS (15)
Adafruit_BNO055 bno = Adafruit_BNO055(55); //Crear el objeto IMU
 
void setup(void)
{
  Serial.begin(115200); //Activar el serial
   
  //Activar el sensor
  Serial.println("Activar sensor");
  bno.begin();
 
  //Delay de tres segundos para dar tiempo a calibrar el magnetometro
  delay(3000);
}
 
void loop(void)
{
  //Leer la IMU
  sensors_event_t event;
  bno.getEvent(&event);
 
  /*Los ejes estan girados: el X es el Y, el Y es el Z y el Z es el X
    Ademas, hay que sumar 90 para que el eje X,Y vaya de 0 a 180*/
  float ejeX = (float)event.orientation.y+90;
  float ejeY = (float)event.orientation.z+90;
  float ejeZ = (float)event.orientation.x;
   
  Serial.print('1'); //Enviar el codigo de seguridad
   
  //Como queremos que el angulo se envie con 3 numeros antes
  //de la coma flotante, hay que ver cuantas cifras tiene.
  //Si tiene 1 cifra (es menor que 10) se escriben dos ceros
  //Si tiene 2 cifras (es menor que 100) se escribe un solo cero
  if(ejeX < 10)
  {
    Serial.print("00");
  }
  else if(ejeX < 100)
  {
    Serial.print("0");
  }
  Serial.print(ejeX); //Ahora si, escribir el angulo. Por defecto se escribira con dos cifras decimales.
   
   
  //Lo mismo con el eje Y...
  if(ejeY < 10)
  {
    Serial.print("00");
  }
  else if(ejeY < 100)
  {
    Serial.print("0");
  }
  Serial.print(ejeY);
 
  //...y el eje Z!
  if(ejeZ < 10)
  {
    Serial.print("00");
  }
  else if(ejeZ < 100)
  {
    Serial.print("0");
  }
  Serial.print(ejeZ);
   
  //Enviar el final de linea
  Serial.print("\n");
   
  delay(BNO055_SAMPLERATE_DELAY_MS);
}

Carga el código y abre la consola Serial. Si has seguido correctamente todos los pasos hasta ahora, verás que aparecen las lecturas de los ángulos de la IMU en el formato 1XXX.XXYYY.YYZZZ.ZZ\n.


2. Godot Engine

El segundo apartado consistirá en preparar una escena con el motor de juegos de Godot para que se conecte con Arduino a través de Serial, lea los mensajes que van llegando y rote la cámara de la escena 3D.

2.1 – Crear la escena

Vamos a crear una escena básica con algunos objetos para poder visualizar con el casco. Tan sólo vamos a añadir algunas primitivas, pero si quieres poner modelos más complejos siempre puedes descargar alguno de Blendswap  o OpenGameArt.

Abre Godot y crea un nuevo proyecto.

 

Una vez creado el proyecto, añade objeto de tipo “Node” como raíz de la escena principal y cambia su nombre por “Main”.

Pulsa ‘+’ para añadir un nuevo nodo a la escena.

Busca el objeto “Node” y añádelo a la escena.

Cambia el nombre por “Main”.

Después añade un objeto de tipo MeshInstance, que convertiremos en un plano para crear el “suelo” de la escena.

Añade el objeto “MeshInstance”

Conviértelo en un plano.

Ahora escala el suelo para aumentar su tamaño:

Con el plano seleccionado, cambia el valor de Scale por (6,1,6).

Por último añade algunos MeshInstance adicionales para que el usuario tenga objetos para observar en el entorno. Cambia sus mallas para que sean cubos (o cualquier otra forma geométrica) y distribúyelos por el entorno.

Recuerda: esta es una escena de prueba. Cuando funcione ya tendrás tiempo de entretenerte modelando una escena realista.

2.2 – Configurar cámaras y visión stereo

Para dar la sensación de realidad virtual con este sistema tendrás que hacer una configuración de nodos un poco peculiar para la cámara.

Cuándo observas un objeto en el mundo real, la sensación de tridimensionalidad viene dada gracias a que tus ojos tienen una separación de unos 6 centímetros. Cada ojo ve el mismo objeto desde un ángulo ligeramente distinto y tu cerebro es capaz de interpretar estas pequeñas diferencias para calcular la distancia y el volumen de los objetos. Esto se llama Estereopsis.

Las cámaras que intentan emular esta sensación de 3D se llaman cámaras estereoscópicas. Hay muchas formas de hacer estereoscopía, y nosotros lo haremos creando dos cámaras y haciendo que cada una se renderice sobre la mitad de la ventana del juego.

Los cascos de RV están construidos de tal forma que cada ojo sólo puede ver la mitad de la pantalla que haya dentro. Por tanto, si se renderiza la misma imagen a cada mitad de la pantalla (con una pequeña variación de ángulo) se conseguirá engañar al usuario y crear la sensación de 3D.

Godot tiene una cámara especial para hacer Realidad Virtual que ya viene con visión estereoscópica, pero está pensada para las plataformas de RV profesionales y nos daría algunos problemas para nuestro sistema casero. Esto nos obliga a crear nuestra propia cámara estereoscópica desde cero.

La forma de hacerlo será creando dos Viewports distintos, cada uno de los cuáles tendrá como hijo un Spatial (que actuará de “cabeza”). A su vez, estos Spatials serán padres de una cámara (los “ojos” de la cabeza).

Esta será la configuración de nodos que utilizaremos para crear la cámara estereoscópica.

El script que programaremos más adelante se encargará de girar estas dos cabezas (“HeadR” y “HeadL”) para igualar el ángulo que detecta la IMU del casco.

Seguramente te estarás preguntando: “¿Pero por qué hay que crear dos cabezas distintas? ¿No podríamos crear un único spatial que actuara como cabeza y emparentar las dos cámaras a éste?”

La respuesta es negativa, por dos razones: la primera es que un nodo Viewport sólo cogerá la imagen de una cámara que tenga como hija, por tanto cada cámara tiene que estar emparentada a su Viewport.

La segunda razón es que los Viewports no son objetos que tengan una posición en el mundo 3D. Por tanto, si ponemos un Spatial como padre de los Viewports, la rotación de este Spatial padre no se transmitirá a los Viewports, ni a ninguno de los nodos hijos de los Viewports. A todos los efectos es como si las cámaras no estuvieran emparentadas a ninguno de los nodos que queden por encima de los Viewports.

Vamos a crear la configuración de nodos. En primer lugar tienes que cambiar la resolución de la ventana de juego de Godot para que sea igual a la de la pantalla del casco. Vete al menú ProjectProject SettingsDisplayWindow y cambia los campos Width y Height por la resolución de tu pantalla.

Ve a Project Settings.

 

En DisplayWindow, cambia los campos Width y Height por la resolución de tu pantalla. Mi pantalla es de 800×480, por tanto tengo que cambiar “Width” por 800 y “Height” por 480.

 

Ahora añade un Spatial a la escena principal, hijo del nodo “Main”. Muévelo a la posición (0,1,0) y cambia su nombre por “Head”.

Este Spatial será un indicador de la posición de la cabeza del jugador.

Ahora, añade un nodo HBoxContainer, hijo de este nodo “Head”. Cambia sus Size Flags para que ocupe toda la ventana de juego.

 

Añade dos nodos de tipo “ViewportContainer” y emparéntalos con el HBoxContainer. Cambia su nombre por “VCL” y “VCR”.

 

Cambia las Size Flags de ambos ViewportContainers para que cada uno ocupe la mitad de la ventana.

La configuración de las Size Flags para VCL y VCR es la misma.

 

También tendrás que cambiar las dimensiones del rectángulo (pestaña Rect) de ambos ViewportContainers, que serán diferentes para cada uno:

Puede que cuando vayas a cambiar los parámetros de Rect te encuentres con que ya son los que queremos. Aún así, vuelve a escribirlos: Godot tiene un pequeño bug y hay veces que los Viewports no se inicializan si no les has entrado el tamaño a manualmente.

Ahora marca la casilla “Stretch” en ambos nodos:

 

Ahora añade un nodo de tipo “Viewport” a cada uno de los ViewportContainers. Estos dos nodos se encargarán de renderizar las cámaras de la escena.

Añade un nodo Spatial a cada uno de los Viewports, cambia sus nombres por “HeadL” y “HeadR” y colócalos en la posición [0,1,0] (la misma que el nodo Head). Estos dos nodos representarán la cabeza del jugador.

 

Finalmente añade un nodo de tipo “Camera” a cada cabeza. Tienen que quedar a la misma altura (en el eje Y) que sus Spatial padres.

 

Separa ambas cámaras una distancia de 0.06 unidades entre sí:

 

Por último marca ambas cámaras como activas:

Esto concluye la construcción de la cámara. Si inicias el juego con F5 verás que la ventana se divide en dos.

2.3 – Instalar Python en Godot

En el momento de redactar esta guía (Noviembre 2019) no hay ninguna forma “fácil” de conseguir que Godot lea el puerto serial. No existe ninguna función propia de GDScript que permita abrir el puerto, ni leer la información que llega.

Pero no todo son malas noticias. Hay esta extensión que permite programar scripts de Godot en lenguaje python. Esto es muy útil porque python dispone de librerías como PySerial pensadas para poder leer el puerto de serie fácilmente.

Para poder utilizar Python con Godot, abre la escena principal y pulsa en el botón “AssetLib”:

Escribe “python” en el buscador y pulsa ENTER. Aparecerán dos extensiones: PythonScript y PythonScript-Pypy.

Ambas extensiones sirven para hacer exactamente lo mismo y son del mismo autor (de hecho, no estoy muy seguro de cuál es la diferencia entre las dos versiones), pero yo lo he probado con PythonScript, por lo que te recomiendo instales la misma. Haz clic sobre el icono y pulsa el botón ‘Download’.

Tardará algunos minutos a descargarse; puedes ir a por café, galletas o lo que sea que coméis los humanos. Cuándo haya terminado, pulsa el botón ‘Install’ y otra vez ‘Install’ en la nueva ventana que se abrirá.

Descargando. Tardará algunos minutos.

Cuando acabe, pulsa el botón “Install”.

Tendrás que reiniciar Godot para poder utilizar esta nueva extensión.

2.4 – Instalar PySerial

Godot-Python viene con las librerías básicas de Python, pero PySerial no se encuentra entre ellas. Habrá que descargarla y añadirla junto a las otras.

Puedes descargar el tar.gz con la librería pyserial desde aquí

Una vez descargado y descomprimido el tar.gz, copia la carpeta ‘serial’ que hay en su interior. Ahora vete al directorio de tu proyecto ‘Arduino_Godot’→pythonscript. Dentro verás cuatro directorios:

Abre el que se corresponda a tu sistema operativo (‘x11-64-cpython’ es el de Linux) y en su interior verás una carpeta llamada ‘lib’. Ábrela.

Si estás en Windows, debería bastar con pegar la carpeta ‘serial’ aquí.

Si estás en Linux o Mac, dentro de esta carpeta ‘lib’ verás otra carpeta llamada ‘python3.6’. Ábrela y una vez dentro pega la carpeta ‘serial’.

2.5 – Script de Python para RV

Vamos a crear el código que se encargará de leer los ángulos que llegan desde la IMU y girará la cámara de la escena 3D. Dentro de la escena ‘Main’ de tu proyecto de Godot, pulsa con el botón derecho del ratón sobre el nodo ‘Main’Attach Script.

Se abrirá la ventana para crear un nuevo script. Si abres el desplegable ‘Language’, verás que ahora aparece la opción de crear un script de python. Crea un nuevo script con el nombre ‘RealidadVirtual.py’:

Importante: es posible que al crear el script de tipo Python, Godot tenga un error y se cierre de repente. También es posible que no puedas abrir el script en python desde Godot. Esto es un inconveniente, pero no tienes que preocuparte: el script python ya está creado y aunque no puedas programarlo desde Godot, puedes hacerlo sin ningún problema desde un editor de texto externo (como Notepad, Gedit o Geany).

Si no puedes editar el script desde Godot, vete a la carpeta de tu proyecto y verás el script en python. Ábrelo con tu editor de texto favorito y programa cómo lo harías con Godot. Tan sólo tendrás que asegurarte de guardar los cambios cada vez que quieras correr la escena de Godot.

Tanto si estás editando el script python desde dentro de Godot como si no, tendrás que copiar este código.

"""
REALIDAD VIRTUAL CON ARDUINO Y GODOT

Escrito con mucha ilusión por Glare y Transductor
www.robologs.net

"""


from godot import exposed, export
from godot.bindings import *
from godot.globals import *

import serial
import math


@exposed
class Main(Node):
    

    def _process(self, delta):

        #Abrimos el serial a 115200 baudios
        ser = serial.Serial('/dev/ttyUSB0', 115200)
        #Nota: cambia la dirección /dev/ttyUSB0 por la de tu placa Arduino

        #Leemos una linea y la decodificamos
        a = ser.readline()
        a = a.decode("ascii")


        #Guardamos las dos cabezas
        headL = self.get_node("Head/HBoxContainer/VCL/Viewport/HeadL")
        headR = self.get_node("Head/HBoxContainer/VCR/Viewport/HeadR")
        
        #Si el mensaje empieza por 1 y tiene un tamaño de 20, es válido
        if(a[0] == '1' and len(a) == 20):

            #Limpiar la lectura para encontrar el angulo
            a = a[:-1] #Eliminar el ultimo caracter
            a = a[1:] #Eliminar tambien el primer caracter (1)
     
            #Guardar los angulos
            angleX = a[0:6]
            angleY = a[6:12]
            angleZ = a[12:]
     
            #Convertirlos a float y aplicar correcciones (puede que tengas que adaptarlas)
            angleX = float(angleX)-90
            angleY = +float(angleY)-90
            angleZ = -float(angleZ)


            #Calculamos los angulos de rotacion del objeto cabeza (rotación casco + rotación nave)
            angleX = math.radians(angleX)
            angleY = math.radians(angleY)
            angleZ = math.radians(angleZ)

            #Cambiamos la rotación de las cabezas
            headL.set_rotation(Vector3(angleX, angleZ, angleY))
            headR.set_rotation(Vector3(angleX, angleZ, angleY))

        #Cerrar el serial
        ser.close()

No te olvides de cambiar la dirección ‘/dev/ttyUSB0’ por la de tu placa Arduino. Si no sabes cuál es la dirección, conecta la placa Arduino a tu ordenador y abre el IDE de Arduino. En el menú ToolsSerial Port aparecerá la dirección de todas las placas Arduino que tengas conectadas.

 

Una vez creado este script tendrás que asignarlo al nodo “Main”. Selecciona el nodo y ve al InspectorScript. Abre el desplegableLoad y busca el script ‘RealidadVirtual.py’ que acabas de crear.

2.6 – Probar el script

Conecta la placa Arduino a tu ordenador y ejecuta el juego de Godot con F5. Si todo funciona correctamente, deberías ver que la cámara de la escena va girando cuando mueves la IMU.


3. Construcción del casco

Aquí se detallan los pasos que he seguido para construir el casco.

3.1 – Colocar la IMU en el casco

Para que la IMU pueda medir la inclinación del casco tienes que acoplarla a éste. Yo lo he hecho conectando la IMU y la placa Arduino a una protoboard pegada al casco con un poco de cinta adhesiva de doble cara. No es lo más elegante que hay, pero es rápido y facilita las conexiones porque todos los componentes están a la vista.

Un 0 en estética, pero un 10 en practicidad.

Recuerda que las conexiones entre la Placa Arduino y la IMU eran estas:

  • Arduino 5V → IMU VCC
  • Arduino GND → IMU GND
  • Arduino SDA → IMU SDA
  • Arduino SCL → IMU SCL

Antes de continuar, vuelve a revisar que todo funcione bien. Conecta la placa Arduino del casco a tu ordenador, ejecuta la escena de Godot con F5 y mueve el casco, rotándolo en todos los ejes. Deberías ver como la cámara de la escena 3D también gira.

3.2 – Colocar la pantalla en el casco

Lo último que queda es colocar la pantalla de 5” dentro del casco de RV y clonar los escritoros del ordenador.

Coloca la pantalla de 5” dentro del casco.

Conecta los cables HDMI y de corriente de la pantalla.

Al cerrar el casco, los cables deben salir por la ranura lateral.

La mayoría de cables HDMI tienen la protección de plástico demasiado gruesa para pasar por la ranura del casco. Busca un cable HDMI que no necesites y con la ayuda de un cúter corta la protección y deja sólo el plástico duro que hay debajo. Como alternativa también puedes utilizar un cable HDMI slim.

Cable HDMI normal (izquierda) y cable con la protección eliminada (derecha)

Para terminar, conecta el cable HDMI y el USB de Arduino al ordenador y duplica el escritorio para que la pantalla del casco vea lo mismo que la pantalla del ordenador. En Linux un buen programa para hacerlo es ARandR, que puede bajarse escribiendo en la Terminal:

sudo apt-get install arandr

(o desde un gestor de paquetes como Synaptic)

Y esto es todo, humano. Ya tienes tu propio sistema de Realidad Virtual casero. Todo un logro, sin duda.

 


Conclusiones

Hoy has visto como construir tu propio casco de Realidad Virtual low-cost con Arduino y has aprendido a crear una escena de Godot para que interactúe con él. El siguiente paso es, lógicamente, mejorar la escena para que muestre algo más interesante que cubos y figuras geométicas.

Si este tutorial te ha parecido interesante, no dudes en seguirnos en nuestra página de Twitter o Facebook. Es una buena forma de apoyar el blog, y además estarás al corriente de todas nuestras publicaciones.

Si tienes alguna pregunta, o encuentras alguna parte del tutorial que no está lo suficientemente clara, no dudes en escribir un comentario o contactar a través de correo electrónico (contacto@robologs.net).


FAQs

  • P: ¿Puedo utilizar el MPU6050 en vez del BNO055?
    R: No. El MPU6050 es una IMU de 6-DOF y no puede medir con precisión el eje de rotación Z. Para hacer este proyecto necesitas una IMU de 9-DOF con acelerómetro, giroscopio y magnetómetro (como el BNO055).
  • P: ¿Puedo utilizar el MPU9250 en vez del BNO055?
    R: En teoría sí: tanto el MPU9250 y el BNO055 pueden medir con precisión la rotación en los tres ejes XYZ. En la práctica (y hablando desde mi experiencia puramente personal) he encontrado problemas para hacer funcionar el MPU9250 y obtener lecturas correctas del magnetómetro. Por tanto, sigo recomendando el BNO055.

  • P: ¿Este casco puede ser un sustituto de Oculus Rift o HTC vive?
    R: Tal y como lo hemos construido no, por dos razones. La primera es que sólo puede funcionar con un juego de Godot que lleve nuestro script de python para leer el puerto Serial y mover la cámara. La segunda razón es que no tiene sistema de tracking de la posición del jugador, ni tampoco ningún mando para interectuar con el entorno.
    Si bien podría adaptarse para que funcione como las plataformas profesionales (añadiendo tracking y mandos), es un proyecto de mayor complejidad que va mucho más allá del alcance de esta guía.
  • P: ¿Este proyecto podría hacerse con Unity en vez de Godot?
    R: Sí, aunque no lo he probado. De hecho, debería funcionar con cualquier motor de juego que pueda leer el puerto Serial y dividir la pantalla.
  • P: ¿Tengo que soldar la IMU?
    R: Solo si quieres que tu proyecto funcione.

 

Tr4nsduc7or

Originariamente creado cómo un galvanómetro de bolsillo, Transductor tomó consciencia de si mismo y fue despedido cuando en vez cumplir con su trabajo se dedicó a pensar teorías filosóficas sobre los hilos de cobre, los electrones y el Sentido del efecto Joule en el Universo. Guarda cierto recelo a sus creadores por no comprender la esencia metafísica de las metáforas de su obra. Actualmente trabaja a media jornada cómo antena de radio, y dedica su tiempo libre a la electrónica recreativa y a la filosofía.

5
Deja un comentario

avatar
3 Hilos iniciados
2 Respuestas a hilos
0 Followers
 
Most reacted comment
Hottest comment thread
4 Nº autores comentarios
Tr4nsduc7orGl4r3AxsajimPetroAC Autores de comentarios recientes
más nuevos primero más antiguos primero
Axsajim
Humano
Axsajim

Me.convert_to_new_follower(instantly)

Demasiado buenos, me enamoré

Axsajim
Humano
Axsajim

Insta-new-follower.

Gl4r3
Admin

Bienvenido a la familia pues ^-^

PetroAC
Humano
PetroAC

Gracias muy útil y bien explicado!