Hola de nuevo,
 
tras varias horas de intensas peleas con el giroscopio, que en muchas ocasiones ha requerido reiniciar el s5, porque se le iba la pinza, he conseguido que funcione, pero no consigo el efecto deseado.
 
Omitiendo varias funciones de calibración que no he conseguido tampoco hacer que funcionen, el código que tengo es este:
 

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class Giroscopio : MonoBehaviour
{
    public GameObject pista;
    private float posicionInicialZ = 0f;
    private float posicionGiroZ = 0f;
     
    // Start is called before the first frame update
    void Start()
    {
        Input.gyro.enabled = true;
       // posicionInicialZ = pista.transform.eulerAngles.z;
    }
    // Update is called once per frame
    void FixedUpdate()
    {
        transform.position = new Vector3(-2.43f, -22.43f, 0);
        RotacionGiroscopio();  
    }
    void RotacionGiroscopio()
    {
        pista.transform.rotation = Input.gyro.attitude;
        pista.transform.Rotate(0, 0, 2.65f, Space.World);       
    }
}

 
El GameObject llamado pista, rota sobre el eje Z con el gyroscopio. No consigo anclar los ejes X e Y.
 
Aunque no lo voy a usar, con el fin de aprender, quisiera saber como bloquear los ejes.
 
Gracias y un saludo,
 
.

En otro post (no de este topic) ya lo comenté. Pongo la copia:
 
Olvídate de hacer rotaciones con los ángulos. Solo los Quaternions te van a servir. Las 3 reglas básicas de oro:
 
- Para sumar rotaciones, se multiplican dos Quaternions.
 
- Para restar rotaciones, se multiplica un Quaternion por el Quaternion.Inverse del otro.
 
- No asignes nunca el valor 0 a un eje de una rotación. Réstale el offset inicial de rotación para mantener el eje fijo.
 
Y en el caso particular del gyro es importante recoger el offset inicial, ya que puede estar en cualquier estado que no será el que te interese.
 
Saludos

Cita de: iRobb date=1567492494En otro post (no de este topic) ya lo comenté. Pongo la copia:
   
   
      Olvídate de hacer rotaciones con los ángulos. Solo los Quaternions te van a servir. Las 3 reglas básicas de oro:
   
   
      - Para sumar rotaciones, se multiplican dos Quaternions.
   
   
      - Para restar rotaciones, se multiplica un Quaternion por el Quaternion.Inverse del otro.
   
   
      - No asignes nunca el valor 0 a un eje de una rotación. Réstale el offset inicial de rotación para mantener el eje fijo.
   
   
      Y en el caso particular del gyro es importante recoger el offset inicial, ya que puede estar en cualquier estado que no será el que te interese.
   
   
      Saludos
   

Reglas de oro sin duda alguna, agrego una de Vectores con Quaternions muy útil:
 
- Para rotar un vector usando un Quaternion se multiplica (en este orden):
 
       vectorRotado = quaternion * vector

Cita de: lightbug date=1567514429Reglas de oro sin duda alguna, agrego una de Vectores con Quaternions muy útil:
   
   
      - Para rotar un vector usando un Quaternion se multiplica (en este orden):
   
   
             vectorRotado = quaternion * vector
   

Pues una regla más a la lista. Las 4 reglas de oro 

Cita de: iRobb date=1567518567Pues una regla más a la lista. Las 4 reglas de oro 

Me anoto las cuatro, aunque aún no se ponerlas en práctica.  Es más, el tema qu aternion no termino de entenderlo.  He visto algún tutorial pr youtube pero me quedo igual que estaba, pues con la hipotenusa, ecuaciones y demás me pierdo. De momento para mi son como una especie de vector. 
 
Descartando el tema giroscopio y retomando el acelerómetro y su rotación de la gravedad voy encontrando mas problemas sobre lo mismo.
 
de momento estoy haciendo lo posible por ver si los soluciono por mi mismo sin molestaros más. 
 
Gracias

Cita de: Sreaver date=1567631823Me anoto las cuatro, aunque aún no se ponerlas en práctica.  Es más, el tema qu aternion no termino de entenderlo.  He visto algún tutorial pr youtube pero me quedo igual que estaba, pues con la hipotenusa, ecuaciones y demás me pierdo. De momento para mi son como una especie de vector. 
   
   
      Descartando el tema giroscopio y retomando el acelerómetro y su rotación de la gravedad voy encontrando mas problemas sobre lo mismo.
   
   
      de momento estoy haciendo lo posible por ver si los soluciono por mi mismo sin molestaros más. 
   
   
      Gracias
   

No necesitas conocer la teoría sobre Quaternions. Solamente las reglas a aplicar. Realmente, nadie sabe lo que son 

Cita de: iRobb date=1567639491No necesitas conocer la teoría sobre Quaternions. Solamente las reglas a aplicar. Realmente, nadie sabe lo que son 

Jajaj totalmente, acá el uso práctico hace la diferencia. Según Wikipedia:
 
"In mathematics, the quaternions are a number system that extends the complex numbers."    --->    a +b i + c j + d k
 
Un número complejo se puede expresar en 2 dimensiones, una para la parte real (que NO acompaña a la "i") y otra para la parte imaginaria (que acompaña a la "i"). Entonces acá se puede decir que un Quaterion se puede expresar con 4 dimensiones.
 
Revisando el código de Unity, un Quaterion es efectivamente un vector de 4x1,:
 

public Quaternion(float x, float y, float z, float w)
    {
      this.x = x;
      this.y = y;
      this.z = z;
      this.w = w;
    }

 
En el mundo matricial la multiplicación de una matriz de (M filas xN columnas ) x (I filas x j columnas):
 
( M x N )  x  (I x J )   ....     Es válida o realizable si N = I, es decir   --->( M x N )  x  ( I x J )  ...   y el resultado tiene dimensión MxJ (Extremos)  ---> ( M x N )  x  (I x J )
 
Acá dejo un poco de código de Quaternions (sacado del código de Unity). Lo interesante es que estos valores se puede arreglar de tal o tal forma y resultar en vectores, quaternions o directamente matrices de 4x4 (ejemplo: parte las matrices que usan los shader, MVP en OpenGL, WVP en D3D , necesitan agregar una componente a la posición, de Vec3 a Vec4). Basicamente lo que hace Unity es afectar a los factores de tal forma de generar el resultado querido.
 
Acá el operador *(Q,V) ... la regla que mencioné arriba:
 

public static Vector3 operator *(Quaternion rotation, Vector3 point)
    {
      float num1 = rotation.x * 2f;
      float num2 = rotation.y * 2f;
      float num3 = rotation.z * 2f;
      float num4 = rotation.x * num1;
      float num5 = rotation.y * num2;
      float num6 = rotation.z * num3;
      float num7 = rotation.x * num2;
      float num8 = rotation.x * num3;
      float num9 = rotation.y * num3;
      float num10 = rotation.w * num1;
      float num11 = rotation.w * num2;
      float num12 = rotation.w * num3;
      Vector3 vector3;
      vector3.x = (float) ((1.0 - ((double) num5 + (double) num6)) * (double) point.x + ((double) num7 - (double) num12) * (double) point.y + ((double) num8 + (double) num11) * (double) point.z);
      vector3.y = (float) (((double) num7 + (double) num12) * (double) point.x + (1.0 - ((double) num4 + (double) num6)) * (double) point.y + ((double) num9 - (double) num10) * (double) point.z);
      vector3.z = (float) (((double) num8 - (double) num11) * (double) point.x + ((double) num9 + (double) num10) * (double) point.y + (1.0 - ((double) num4 + (double) num5)) * (double) point.z);
      return vector3;
    }

 
Acá el operador* (Q,Q), Multiplicación de Quaternions (otras reglas):
 

public static Quaternion operator *(Quaternion lhs, Quaternion rhs)
{
return new Quaternion(
   (float) ((double) lhs.w * (double) rhs.x + (double) lhs.x * (double) rhs.w + (double) lhs.y * (double) rhs.z - (double) lhs.z * (double) rhs.y), 
         (float) ((double) lhs.w * (double) rhs.y + (double) lhs.y * (double) rhs.w + (double) lhs.z * (double) rhs.x - (double) lhs.x * (double) rhs.z),
   (float) ((double) lhs.w * (double) rhs.z + (double) lhs.z * (double) rhs.w + (double) lhs.x * (double) rhs.y - (double) lhs.y * (double) rhs.x), 
   (float) ((double) lhs.w * (double) rhs.w - (double) lhs.x * (double) rhs.x - (double) lhs.y * (double) rhs.y - (double) lhs.z * (double) rhs.z)
);
}

 
 
 
Da miedo ...
 
Lo importante es leer el manual y saber que hace cada método del Quaternion. Cuando apretás el botón del ascensor que hace que el ascensor funcione (para un usuario promedio), lo que importa es saber a qué piso querés ir.

Cita de: lightbug date=1567693052Jajaj totalmente, acá el uso práctico hace la diferencia. Según Wikipedia:
   
   
      "In mathematics, the quaternions are a number system that extends the complex numbers."    --->    a +b i + c j + d k
   
   
      Un número complejo se puede expresar en 2 dimensiones, una para la parte real (que NO acompaña a la "i") y otra para la parte imaginaria (que acompaña a la "i"). Entonces acá se puede decir que un Quaterion se puede expresar con 4 dimensiones.
   
   
      Revisando el código de Unity, un Quaterion es efectivamente un vector de 4x1,:
   
   

public Quaternion(float x, float y, float z, float w)
    {
      this.x = x;
      this.y = y;
      this.z = z;
      this.w = w;
    }

   
      En el mundo matricial la multiplicación de una matriz de (M filas xN columnas ) x (I filas x j columnas):
   
   
      ( M x N )  x  (I x J )   ....     Es válida o realizable si N = I, es decir   --->( M x N )  x  ( I x J )  ...   y el resultado tiene dimensión MxJ (Extremos)  ---> ( M x N )  x  (I x J )
   
   
      Acá dejo un poco de código de Quaternions (sacado del código de Unity). Lo interesante es que estos valores se puede arreglar de tal o tal forma y resultar en vectores, quaternions o directamente matrices de 4x4 (ejemplo: parte las matrices que usan los shader, MVP en OpenGL, WVP en D3D , necesitan agregar una componente a la posición, de Vec3 a Vec4). Basicamente lo que hace Unity es afectar a los factores de tal forma de generar el resultado querido.
   
   
      Acá el operador *(Q,V) ... la regla que mencioné arriba:
   
   

public static Vector3 operator *(Quaternion rotation, Vector3 point)
    {
      float num1 = rotation.x * 2f;
      float num2 = rotation.y * 2f;
      float num3 = rotation.z * 2f;
      float num4 = rotation.x * num1;
      float num5 = rotation.y * num2;
      float num6 = rotation.z * num3;
      float num7 = rotation.x * num2;
      float num8 = rotation.x * num3;
      float num9 = rotation.y * num3;
      float num10 = rotation.w * num1;
      float num11 = rotation.w * num2;
      float num12 = rotation.w * num3;
      Vector3 vector3;
      vector3.x = (float) ((1.0 - ((double) num5 + (double) num6)) * (double) point.x + ((double) num7 - (double) num12) * (double) point.y + ((double) num8 + (double) num11) * (double) point.z);
      vector3.y = (float) (((double) num7 + (double) num12) * (double) point.x + (1.0 - ((double) num4 + (double) num6)) * (double) point.y + ((double) num9 - (double) num10) * (double) point.z);
      vector3.z = (float) (((double) num8 - (double) num11) * (double) point.x + ((double) num9 + (double) num10) * (double) point.y + (1.0 - ((double) num4 + (double) num5)) * (double) point.z);
      return vector3;
    }

   
      Acá el operador* (Q,Q), Multiplicación de Quaternions (otras reglas):
   
   

public static Quaternion operator *(Quaternion lhs, Quaternion rhs)
{
return new Quaternion(
   (float) ((double) lhs.w * (double) rhs.x + (double) lhs.x * (double) rhs.w + (double) lhs.y * (double) rhs.z - (double) lhs.z * (double) rhs.y), 
         (float) ((double) lhs.w * (double) rhs.y + (double) lhs.y * (double) rhs.w + (double) lhs.z * (double) rhs.x - (double) lhs.x * (double) rhs.z),
   (float) ((double) lhs.w * (double) rhs.z + (double) lhs.z * (double) rhs.w + (double) lhs.x * (double) rhs.y - (double) lhs.y * (double) rhs.x), 
   (float) ((double) lhs.w * (double) rhs.w - (double) lhs.x * (double) rhs.x - (double) lhs.y * (double) rhs.y - (double) lhs.z * (double) rhs.z)
);
}

   
       
   
   
      Da miedo ...
   
   
      Lo importante es leer el manual y saber que hace cada método del Quaternion. Cuando apretás el botón del ascensor que hace que el ascensor funcione (para un usuario promedio), lo que importa es saber a qué piso querés ir.
   

Muchas gracias.  Voy a ver a que piso voy xD