Noticias:

¿Has Leído las Normas de HispaLUG? LEER AHORA

Menú Principal

Acelerometro casero para NXT

Iniciado por 31415926, 28 de Marzo de 2010, 22:05:49 PM

Tema anterior - Siguiente tema

0 Miembros y 1 Visitante están viendo este tema.

Minipepito

#15
Hace algún tiempo que el mío es operativo, pero como me faltan algunos detalles por terminar, entre ellos, la carcasa que es en parte de cinta aislante, jejejeje, no lo había posteado


He dejado de lado Nxt-g en favor de robotc, dime qué pruebas quieres que haga y veré si soy capaz, jejeje, cosa que no aseguro, pues soy todavía peor en robotc que con Nxt-g.

Señor Pi, con el uso de un sistema virtual, creo que solucionarías tu problema con el bluetooth y el uso de múltiples pcs, y alguno más, jejeje.

31415926

Cita de: Minipepito en 08 de Mayo de 2010, 09:39:26 AM
He dejado de lado Nxt-g en favor de robotc, dime qué pruebas quieres que haga y veré si soy capaz, jejeje, cosa que no aseguro, pues soy todavía peor en robotc que con Nxt-g.
Si lanzas este programa tendrían que aparecer los datos de calibración.

Cuando los vi (antes de borrarlos), no se recuperaban los 16 valores a la vez, lo tenia que leer de seis en seis. Por eso hay un bucle que incrementa la posición de memoria que se lee según pulsas el botón naranja.

Una descripción de lo que obtenemos la encuentras en Wiimote Project. Me gustaría ver el resultado para añadir funciones de lectura y que modifiquen la salida de Nunchuk_LIB.c
3,1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229 . . .             

Minipepito

Weno, amos al lio:

cmd 20                         cmd 21                          cmd 22
129  129  127     5           129  127     5  179           127     5  179  179
179  179  139  238           179  179  138  208           179   16  208    17
208    17  125  221            17  125  221    29           125  221   29  126
  29  126  252    87           126  252   87  125           252   87  125  125

A partir de aquí pondreé solo los dos dígitos nuevos que aparecen en cada conjunto de datos en las posiciones sexta y última:

cmd 23       cmd 24       cmd 25       cmd 26       cmd 27       cmd 28       cmd 29     cmd 2A     cmd 2B     cmd 2C     cmd 2D     cmd 2E             
222  127     29  249       129  139     225  139     33  139       128  238     2  208       87   17     129  125    129  221    127   29      5  126


No tengo ni idea qué son estos numerajos, jejeje, pero espero haberte servido de ayuda, señor Pi. Cualquier otra cosa, no tienes más que pedirla, jejeje

31415926

Estupendo, gracias por la info  :}. Estos valores se interpretan así:

Para el acelerómetro
Cero --> acX.Cero:129 acY.Cero:129 acZ.Cero:127 ; los bit mas bajos 5:00000101 pero no está claro que pares corresponden a cada eje.
Valor de 1g --> acX.g:179 acY.g:179 acZ.g:139 ; los bits más bajos 238: 11101110 idem.

Para el joystick
X.Maximo:208 X.Minimo:17 X.Centro:125
Y.Maximo:221 Y.Minimo:29 Z.Centro:126

Como suponía, el centro del joystick no corresponde al medio del máximo y el mínimo. Para obtener un valor correcto habrá que interpolar usando los datos de calibración, siempre y cuando siga alojado en la carcasa original; si lo sacamos fuera, el recorrido del joystick varia y puede que no sirvan los datos.

Voy a reescribir el modulo de acceso y de paso le añado algunas funciones.
3,1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229 . . .             

31415926

Por fin he sacado un ratito:

Una estructura para guardar todo y  funciones para leer y normalizar la lectura con los datos de calibración. Se calcula el ángulo del joystick y la inclinación y balanceo del mando.

Hunchuk_lib.h
Citar

////////////////////////////////////////////////////////////////////////////////////
//
//    NUNCHUK v0.2
//
///////////////////////////////////////////////////////////////////////////////////

// codigos para los botones
#define NUNCHUK_BOTON_ROJO    0x01
#define NUNCHUK_BOTON_AZUL    0x02
#define NUNCHUK_B0TON_TODOS   0x03

// vector 2D de byte sin signo
typedef struct {
  ubyte x, y;
} vec2b_t;

// vector 3D de short
typedef struct {
  short x, y, z;
} vec3s_t;

// estructura para almacenar los datos de calibracion
typedef struct  {
  vec3s_t ac_cero; // cero del acelerometro
  vec3s_t ac_g;   // diferencia 1g alrededor del cero

  vec2b_t js_max; // valor maximo del joystick
  vec2b_t js_min; // valor minimo del joystick
  vec2b_t js_centro; // valor del centro del joystick
} calibracion_t;

// estructura para almacenar los datos del joystick
//
// x,y: contienen la posicion del joystick si no se ha usado nunchuk_calibra_datos
//
// si se normaliza usando nunchuk_calibra_datos
// x,y: posicion del joystick con valores entre -1 y 1, interpolados entre el centro y
// el maximo o minimo, (x min) [-1] ----*--- [0] (x centro) [0] ----- [1] (x max)
// angulo: con valores entre -PI y PI
// distancia: al centro con valores entre 0 y 1
typedef struct {
  float x, y;        // posicion del joystick
  float angulo;      // angulo en radianes
  float distancia;   // distancia al centro
} joystick_t;

// estructura para almacenar los datos del acelerometro
//
// x,y,z: contienen los datos del acelerometro si no se ha usado nunchuk_calibra_datos
//
// si se normaliza usando nunchuk_calibra_datos
// x,y,z: valores de aceleracion para cada eje medidos en g, de 0g a 2g
// balanceo e inclinacion: angulo con respecto al horizonte con valores entre -PI y PI
// tienen sentido si el sensor esta estatico, en otro caso no.
typedef struct {
  float x, y, z;     // valores del acelerometro
  float balanceo;    // angulo de balanceo en radianes
  float inclinacion; // angulo de inclinacion en radianes
} acelerometro_t;

// estructura para almacenar toda la informacion del sensor
typedef struct {
  tSensors puerto;      // puerto al que esta conectado
  ubyte buffer[16];     // ultimos datos raw leidos del nunchuk

  calibracion_t cal;    // datos de calibracion, pueden cargarse con nunchuk_calibracion o manual

  byte btn_pulsado;     // indica que botones acaban de ser presionados
  byte btn_presionado;  // indica que botones se mantienen pulsados
  byte btn_soltado;     // indica que botones se han despulsados

  joystick_t js;        // valores del joystick

  acelerometro_t ac;    // valores del acelerometro

} nunchuk_t;

// instancia de nunchuk_t para acceder desde cualquier parte del codigo a los datos del sensor
// NOTA: al encontrar problemas al pasar por referencia la estructura nunchuk_t se ha
// creado para que funcione, aunque no sea buena praxis.
nunchuk_t nunchuk;

// devuelve el angulo formado por (0,0)-(x,y) en radianes con valores entre -PI a PI
float atan2(float x, float y);
// inicia nunchuk y asigna el puerto a usar
void nunchuk_init(tSensors puerto);
// lee tamano datos de cmd posicion usando el protocolo I2C para comunicar con el nunchuk
bool nunchuk_leer_datos(byte tamano, byte cmd);
// lee los datos de calibracion
void nunchuk_calibracion();
// lee los valores actuales del sensor
bool nunchuk_valores();
// con los datos de calibracion, normaliza los ultimos valores leidos del sensor
void nunchuk_calibra_datos();


Me ha entretenido bastante el problema que ha aparecido al tratar de pasar por referencia la estructura nunchuk_t y usar cualquier miembro a la derecha de la asignación, su valor se convertía en 0 !!!!. Lo malo es que no he encontrado la solución y me he tenido que salir por la tangente.

Citar
void nunchuk_calibra_datos(nunchuk_t & nc) {
....
nc.js.x = .... * nc.js.x; // resultado 0  ???
...
}

Espero vuestras sugerencias y dudas. ¿Podéis dar alguna idea para solucionar el paso por referencia de nunchuk_t?
3,1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229 . . .             

nxtorm

Bueno, aprovechando esa super caja que has hecho, resucito este hilo. Yo en su día me decanté por el NXT-G. Y conseguí hacer funcionar el nunchuck copiando algún programa de la red en NXC, pero en NXT-G no he conseguido leer nada.

¿tú tienes algún programa en NXC comentado en detalle de lo que va haciendo? He visto los programas del enlace que pones, pero no acabo de aclararme. Por ejemplo, escribes:

Escribimos la direccion de registro del Nunchuk

¿Qué números concretos serían? Es solo un ejemplo. Me refiero en general a qué direcciones y registros escribe para el reset y que direcciones lee luego cuando se mueve el nunchuck.

En NXT-g hay un icono de "Read" y otro de "Write", con el que puedo escribir las direcciones (que desconozco) y los registros (que también). Como no se bien cómo trabaja, no se si lo que pido es muy complicado, ya me dices. Me gustaría alguna vez acabar esa espina pendiente de mi web.

31415926

No creo que haya problemas en resucitar este hilo si aportamos cosas nuevas. Además este subforo no tiene demasiado movimiento. Tengo que actualizar los enlaces, están todos rotos!!!

Decidí, a la semana de abrir la caja del NXT 2.0, no usar NXT-G. Además ahora no puedo usarlo, cambie el S.O. de los ordenadores de casa a linux. Siento no poder ayudarte demasiado en ese entorno.

Dame unos días para cambiar el firmware del ladrillo y probar si con un código más sencillo accedemos a los datos usando NXC (con el firmware original de Lego). Luego lo comento bien y lo subo. De todas maneras no creo que sea fácil. Entre los cambios irá el acceso a los datos sin necesidad de descifrarlos. El resto es tratar el resultado.

¿Podrías explicar como funcionan esos bloques? ¿Donde están?

La dirección (adress) del nunchuk es fija 0xA4, escribimos 0x55 en el registro 0xF0, escribimos 0x00 en el registro 0xFB y tachan, ya está iniciado. Todos estos valores son fijos y están escritos en hexadecimal. Luego  podemos pedirle 6 byte de datos desde el registro 0x00 y nos los da sin cifrar.

Este es el código que estoy usando con MagicPuzzleBox y funciona perfectamente.
[spoiler]
public class NunchukSensor extends I2CSensor {

    private byte[] data = new byte[6];

    public NunchukSensor(I2CPort port) {
        super(port);
        this.port = port;
        this.address = 0xA4;
        this.port.setType(SensorConstants.TYPE_LOWSPEED);
        this.port.setMode(SensorConstants.MODE_RAW);
    }

    public void init() {
        this.sendData(0xF0, (byte) 0x55);
        this.sendData(0xFB, (byte) 0x00);
    }

    public byte[] getData() {
        this.getData(0x00, this.data, 6);
        return data;
    }

    public int getAccX() {
        return (ubyte2int(data[2]) << 2) + ((data[5] >> 2) & 3);
    }

    ...etc...

    public static int ubyte2int(byte b) {
        return (int) b & 0xFF;
    }
}
[/spoiler]
Ten paciencia, no tengo demasiado tiempo libre. Ahora estoy trasnochando, a ver como me levanto mañana.
3,1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229 . . .             

nxtorm

Gracias!

Bueno Pi (¿te puedo llamar por el nombre corto?  :D), me has dado un hilo de donde poder estirar algo. He podido hacer algunas pruebas y parecen prometedoras, aunque no alcanzo aun a comprenderlo todo. Te cuento. Este es el programa que he hecho (pincha sobre la imagen para agrandar):



He puesto un par de iconos de configuración como ejemplo, para que los veas. Son el icono Write y el Read. En mi web los puedes descargar y hay algunas explicaciones muy básicas:

http://www.nxtorm.es/digitales/sd-c-software.html

Si los instalas, tienes también unas ayudas en línea. Te adjunto los enlaces: Write y Read.

Mirando por ahí, también he encontrado este enlace con información interesante al respecto:

http://blog.ingenegros.org/?p=24

Bueno, el programa que he puesto en NXT-G lee el registro 1 y presenta en pantalla el valor X del joystic. Con otros valores entre 0 y 5 presenta el resto. Nunca había conseguido leer datos con algún sentido, así que me he alegrado mucho, gracias de nuevo.

Pero aun hay muchas dudas, quizás con más pruebas lo saque. Voy a intentar enumerarlas:

- En otras páginas (especialmente de Arduino) aparecen otras direcciones y otros registros y no le veo sentido.

- No era capaz de leer ningún dato hasta que puse los 2 iconos W dentro del bucle. La "pista" me la dió el enlace que puse antes. Hasta ese momento, todo eran 0 o 255.

- A veces, el programa se bloqueaba. Parece que poniendo esos 2 iconos Write fuera del bucle, es algo más estable, pero realmente no se qué están haciendo.

- Verás una pestañita en ambos iconos del NXT-G (el Read y el Write) que pone WriteReg. En total hay 5 iconos amarillos, y la configuración de pestañitas es: SI/SI/NO/NO/X. La X final es que pinchada, da la Y del joystic y sin pinchar da la X del joystic.

- No consigo ver la pulsación de C y Z.

- Los datos del registro 5 va completamente locos. ¿Estará ahí resumida toda la información anterior, leyendo bit a bit?.

- He cambiado los registros de los iconos W dentro del bucle y sigue funcionando, pero deja de hacerlo si elimino alguno de esos 2 iconos. O sea, no se qué función realizan. En la web de antes dice que "se mandan 2 bytes "0×40,0×00″, y despues se manda 1 byte "0×00″ cada vez que se quieren recibir datos del nunchuck". Parece que es el mensaje de inicio de comunicación, pero no lo entiendo bien. ¿existe alguna web original de la marca que especifique estos datos?

- ¿cómo se hace un reset a la posición inicial del nunchuck? 

Por cierto, los datos a introducir en estos bloques W y R van en decimal. Bueno, he querido ser exhaustivo por si te animas (o cualquier otra persona), aunque con lo que me has contado que tienes que cambiar, tira para atrás. Ninguna prisa por mi parte, yo seguiré investigando, que me encanta. De momento ya te digo, tengo hilo para estirar y algunos resultados más que alentadores.

31415926

Lo tienes a tiro de piedra :}, me alegra mucho. (icono de http://technicbricks.blogspot.com/ si hay problemas quitármelo)

Cuando dije que parecía difícil es porque el bloque de lectura lee sólo una posición y desconozco los efectos al consultar todas las posiciones de una en una. Espero que no sea un inconveniente.

Cita de: nxtorm en 23 de Noviembre de 2011, 19:21:03 PM
1- En otras páginas (especialmente de Arduino) aparecen otras direcciones y otros registros y no le veo sentido.
2- No era capaz de leer ningún dato hasta que puse los 2 iconos W dentro del bucle. La "pista" me la dió el enlace que puse antes. Hasta ese momento, todo eran 0 o 255.
3- A veces, el programa se bloqueaba. Parece que poniendo esos 2 iconos Write fuera del bucle, es algo más estable, pero realmente no se qué están haciendo.
4- Verás una pestañita en ambos iconos del NXT-G (el Read y el Write) que pone WriteReg. En total hay 5 iconos amarillos, y la configuración de pestañitas es: SI/SI/NO/NO/X. La X final es que pinchada, da la Y del joystic y sin pinchar da la X del joystic.
5- No consigo ver la pulsación de C y Z.
6- Los datos del registro 5 va completamente locos. ¿Estará ahí resumida toda la información anterior, leyendo bit a bit?.
7- He cambiado los registros de los iconos W dentro del bucle y sigue funcionando, pero deja de hacerlo si elimino alguno de esos 2 iconos. O sea, no se qué función realizan. En la web de antes dice que "se mandan 2 bytes "0×40,0×00″, y despues se manda 1 byte "0×00″ cada vez que se quieren recibir datos del nunchuck". Parece que es el mensaje de inicio de comunicación, pero no lo entiendo bien. ¿existe alguna web original de la marca que especifique estos datos?
8- ¿cómo se hace un reset a la posición inicial del nunchuck? 
No soy un experto, solo se lo que he leído por en la WEB. Por partes:

1- Se envían y reciben bytes. El primero es la dirección y en este él último bit es un marcador para indicar si quieres escribir o leer en el dispositivo esclavo. El nunchuk tiene la dirección 0x52 pero queremos escribir así que le ponemos un 0 a la izquierda y tenemos nuestro 0xA4. Seguramente en Arduino se establezca este ultimo bit a 0 por si solo cuando hacen un send y a 1 cuando usan requestFrom.
2- Hay algo que yo no hago bien: 'Esperar a que el bus este libre para enviar más datos', desconozco si sendData lo hace por mi o que al ser java un lenguaje interpretado interpretado le da tiempo para comerse el siguiente envió. Ese bloque no sabemos como funciona por dentro, pero quizás esperar 10ms entre bloque y bloque sea suficiente y te evite tener que meterlos dentro del bucle. Al ponerlos en el bucle en 10 ciclos puede que solo tengas <10 lecturas.
3- No se me ocurre ninguna explicación. Tendrás que trastear.
4- No entiendo el objetivo de WriteReg, pero esta situado a la altura del registro, quizás afecte al registro en el último bit o a la dirección en el bit de lectura/escritura, ... tendrás que usar ingeniería inversa para averiguarlo y que todo quede comprensible.
5- Son los dos bis mas bajos del registro 5.
6- CORRECTO, el valor de cada eje del acelerometro tiene una precisión de 10 bit, los mas altos en los registros 2,3,4 y los más bajos en el registro 5:ZZYYXXCZ por eso hacemos (reg[2] << 2) + (reg[5] >> 2) & 3: desplazamos dos posiciones a la derecha el registro 5 y le sumamos los bits 3 y 4 del reg[5]. Ahora bien para hacer esa operacion en NXT-G ni ... idea.
7- Al pricipios si mandaba ese cero antes de pedir los datos, pero por casualidad (comente la linea sin quere) me encontre que no es necesario. o eso creo.
8- No entiendo la pregunta, que quieres resetear si solo hay que pedirle datos sin parar y jugar con ellos.  ???

En http://robots-argentina.com.ar/Comunicacion_busI2C.htm explican el protocolo I2C y en http://wiibrew.org/wiki/Wiimote/Extension_Controllers/Nunchuck el funcionamiento del nunchuk. aunque seguro que ya las conocías.

Menos mal que me has avisado ya esta haciendo una partición al disco para instalar un Windows.

Si ya les la información del sensor, tienes la parte más difícil solucionada. Suerte y cuéntanos los avances, hay mucha gente que usa NXT-G y estará deseosa de saber que también funciona.
3,1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229 . . .             

nxtorm

#24
Me he vuelto casi loco con la programación pero por fin ¡lo he consegido!. Funciona perfectamente en NXT-G!!!
Gracias 3,14 por todas las aclaraciones, me han servido de gran ayuda en puntos clave, no lo hubiera sacado sin esas aportaciones. Os dejo un video:

http://www.youtube.com/watch?v=_Zhv34iLdvU#

Para simplificar el tema y que le pueda servir a más gente, he creado un "My Block" que os podéis descargar en mi web:



Como véis, tiene 2 salidas lógicas que corresponden a la pulsación de los botones C y Z del nunchuk, y 5 salidas más que corresponden a: Joystic eje X, Joystic eje Y, y los 3 ejes del acelerómetro X, Y y Z. Simplemente lo unimos a un bloque de display del NXT-g y visualizamos en pantalla directamente los valores aportados por el nunchuk.

Estoy muy satisfecho porque es un proyecto que llevaba tiempo parado y porque no he encontrado nada similar por la web, no digo que no exista, pero no lo he visto.

Ya sabéis que los programas en *.rbt del NXT-g son bastante pesados para ponerlos por aquí, y además hay que descargar algunos iconos adicionales de la web que no vienen de serie en el NXT-G. Ya he actualizado adecuadamente mi web con este icono y las explicaciones. De todas formas, si hay cualquier duda, el hilo sigue abierto. Espero que le sirve a alguien o le pique la curiosidad a algún otro pirata del NXT.

No tengo nada en mente ahora mismo, pero estoy seguro que esto abre puertas a nuevos proyectos interesantes que hasta ahora no me eran accesibles, ya que disponemos de datos de 2 botones y 2 joystics a través de un solo puerto. Como el de la Magic Puzzle Box de 3,1415. Lo que no he pillado aun es el eje Z cuál es, alrededor de qué gira, pero ya lo pillaré.

Saludos.

31415926

Enhorabuena nxtorm.  :}  Grandísimo aporte para los que desarrollan con NXT-G.

Cita de: nxtorm en 26 de Noviembre de 2011, 15:56:50 PM
Lo que no he pillado aun es el eje Z cuál es, alrededor de qué gira, pero ya lo pillaré.
Recuerda que es un acelerometro no un giroscopio, no mide velocidad de giro sino aceleración. Que nos mantiene pegados al suelo, la fuerza de la gravedad, que no es una fuerza sino una aceleración g=9.80665 m/s2
Si el sensor está estático y en horizontal X e Y no tendrán aceleración pero Z tendrá 1g, si lo pones boca abajo Z valdrá -1g. Cuando el sensor no está horizontal la 'fuerza' de la gravedad se descompone y los otros valores empiezan a moverse.
Esto si no mueves el sensor, si se mueve cada eje informa de la aceleración que tiene. Si con el ejemplo que te has montado para el vídeo mantienes el nunchuk horizontal y lo mueves rápido de izquierda a derecha tendrás el mismo efecto que al girarlo, y si lo haces con mucha fuerza seguro que golpearás con los palitos en el suelo.

Gracias por las menciones :E, no hacían falta pero son bienvenidas.
3,1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229 . . .             

monki

Gran proyecto que os habéis currado, enhorabuena!!!

Como gran fan del NXT, creo que si le añadimos un multiplexor podemos aprovechar todas las funciones del Nunchuck al conectar más servomotores y poder crear robots luchadores con todas las funciones :P

¿Qué opináis?

Saludos!

nxtorm

Gracias por la parte que me toca.

Bueno, por partes, que aquí hay varias cosas. Primero, respecto al eje Z:

Pues al día siguiente me puse un rato y efectivamente encontré eso que dices. El "eje" Z corresponde a un plano paralelo al suelo, y de ahí mi lio. Boca arriba el mando, +1g y boca abajo, -1g. Pero ha estado muy bien dejar constancia de la pregunta porque desconocía eso de mover de izquierda a derecha el joystic. En algún momento intentaré sacar una gráfica, pero ya he comprobado que los valores efectivamente cambian. Experimentar está muy bien, y compartir más todavía.

Respecto a las menciones... qué menos.

Ahora mismo ando intentando sacar el "ajuste fino" con los 10 bits. Lo he conseguido para un eje, el X, en programa aparte, pero al incorporarlo al programa con el resto de ejes, los resultados van locos, cosa que no tiene sentido. Ya probaré en otro momento.

Por si alguien tiene curosidad, la forma de hacerlo es como sigue:

- Con el icono Mask, podemos conocer cualquier bit o bits de un número.
- Multiplicamos por 4 el registro X (por ejemplo), que es el equivalente en binario de x100 en decimal. O sea, desplazamos 2 posiciones el registro X.
- Sumamos los 2 bits (dígitos) del registro 5 obtenidos con el Mask.
- Sumamos ambos valores.

Ya digo que funciona perfectamente... en programa aparte.  Seguiré probando, ya que efectivamente de esta forma es muuucho más fino.

Cita de: monki en 30 de Noviembre de 2011, 09:27:25 AM
[...]si le añadimos un multiplexor podemos aprovechar todas las funciones del Nunchuck al conectar más servomotores
Pues opino que sí monki, que esto del nunchuk abre un montón de posibilidades. No se si daría para abrir un hilo nuevo para que esto no se salga mucho del tema. De todas formas, multiplexar motores es harina de otro costal. Hay algún multiplexor para motores en el mercado, pero hay que añadir baterías adicionales, ya que el NXT no puede con ellos. Personalmente creo que la mejor forma de controlar más motores es con un sensor de enlace IR, que permite controlar (si no recuerdo mal) 8 motores PF además de los 3 del NXT con 1 solo NXT. Pero esto ya es una preferencia personal. Y perdón por el off-topic.

Seguimos, que esto puede dar mucho de si  :}


nxtorm

Bueno, siento repetirme (que lo del "flodeo" me da un poco de grima), pero tengo pequeñas novedades. Siempre se puede entender como una continuación...

Bueno, ya he podido sacar el "ajuste fino" del nunchuk con los 10 bits siguiendo el procedimiento explicado en la respuesta anterior. El siguiente gráfico corresponde a lo siguiente: inicio en reposo desde el centro; muevo el mando de izquierda a derecha lento (las curvas suaves); después lo mismo rápido (los picos); acabo en reposo en el centro (línea "recta" del final). El registro corresponde a 12 segundos de movimiento del eje X.


He quedado muy satisfecho del resultado, es muy fiel a los movimientos. La web ya está adecuadamente actualizada con todos los detalles de la programación, gráficas y este segundo "My Block" más fino. Ya estoy barruntando alguna aplicación...

monki

Gracias por estos datos, habrá que mirarlos atentamente y planear algo :P
Duda que tengo:
En el vídeo que muestras, primero haces movimientos normales y mueves los servos, y luego utilizas los botones, cambias los servos de posición y también se mueven.
Ahora la pregunta jeje, ¿se puede hacer todo a la vez?, es decir, sería como un robot con acciones y movimiento.
Al mover el mando lo mueves de un lado a otro y al presionar los botones ejecuta la acción, o ¿no se puede hacer?

Perdón por la explicación, si no se entiende algo lo repito de mejor manera :P

Saludos!