HispaLUG

Hace mucho tiempo estuve curioseando sobre la Wii y en WiiBrew (http://wiibrew.org/wiki/Wiimote/Extension_Controllers) leí, sin darle importancia, protocolo I2C (http://es.wikipedia.org/wiki/I%C2%B2C). Pasados los años resurgió la afición de lego, empecé a leer sobre el NXT y volvió a aparecer I2C. A partir de ese momento googlear, adquirir un Nunchuk (que se lo cambie a mi hijo por el original de la Wii), esperar al momento oportuno para comprar un NXT y ya puestos, hacerle una casita-lego.

Por supuesto, el trabajo duro ya lo habían realizado

• Primer hilo en el que encontré algo (http://forums.nxtasy.org/index.php?showtopic=3043)


• Direct connect Wii Nunchuk over I2C with NXT (http://forums.nxtasy.org/index.php?showtopic=3075)

y sólo hay que seguir sus pasos para tener un sensor para el NXT que dispone de joystick con dos botones y acelerómetro, todo ello por muy poquitos €.

Para realizarlo he necesitado: 1 Nunchuk 2 resistencias de 33k 1 diodo 1N4148 1 cable de NTX Unas cuantas piezas, desparejadas y sucias

(http://farm5.static.flickr.com/4060/4465961066_244d2bf61e_m.jpg) (http://farm5.static.flickr.com/4060/4465961066_244d2bf61e_b.jpg)

Para desmontar el nunchuk hay que utilizar un destornillador Triwing y quitarle las dos resistencias. La primera prueba la hice con dos resistencias y un diodo sacados de un coche teledirigido de un todo a 100, sobre los cables pelados, sujeto con pinzas (literalmente) y enroscados los cables sobre las patillas. Siguiendo este circuito para unirlo todo.


FUNCIONÓ y no se quemo nada. (No me hago responsable de posibles desastres si se hace mal)

Ya solo queda lo fácil, con un cuter ir rebajando las piezas hasta que la placa del nunchuk encaje. Para esto hay que tener mucha paciencia, tiempo (y que te guste autolesionarte los dedos). Queda suficiente espacio entre el joystick y los botones para que se alojen las resistencias y el diodo, pero como ya he dicho también se puede hacer donde se unan los cables del nunchuk y del NXT.


Para que quede más robusto, pegué las piezas con pegamento de contacto. No tengo fotos de las soldaduras pero mejor, me da vergüenza enseñar los pegotes de estaño que puse, además de ser soldaduras frías.
Nunca más utilizaré un soldador, quema mucho y tiene la manía de apoyarse en los dedos.


Ahora a divertirse, el código está en los ficheros adjuntos:

• NXT-G
  No pienso usarlo, soy muy mayor para aprender y no me gusta programa a base de ratón. Pero en nxtasy (http://www.nxtasy.org/repository/nxt-g-blocks/) se pueden encontrar bloques para leer y escribir sobre I2C, no se si funcionará.
• NXC
  *Nunchuk_LIB.nxc   Contiene una funcion para inicializar el puerto, una estructura para almacenar el resultado y otra función para leer y procesar los valores recogidos de Nunchuck. Falta leer y utilizar los datos de calibración.
  *Visor. nxc   Mismo ejemplo que el de los creadores de invento.
  *Velocidad.nxc   Mide el tiempo que tarda en realizar X lecturas. Me arroja un valor de unas 35 lecturas por segundos. Me parecen pocas pero es lo que hay.
  *Oruga.nxc   Ejemplo práctico de un vehiculo dirigido por este sensor, tanto con el joystick como con el acelerómetro.
  
• 
  ROBOTC
  Los mismos ejemplos pero para RobotC. Hay una curiosa diferencia, se obtiene una media de 140 LECTURAS!!! por segundo. Esto me ha entretenido bastante ya que la demo caduca y hay que hacer ... para tener otros 30 días extra sin reinstalar el equipo.
  
• 
  LeJOS
  En LeJos (http://lejos.sourceforge.net/forum/viewtopic.php?t=1457) lo han implementado.
  
• 
  nxtOSEK
  Esta en mi punto de mira, nxtOSEK (http://lejos-osek.sourceforge.net/ecrobot_c_api.htm#I2C)
  
• pbLua
  No he encontrado nada pero API para I2C (http://www.hempeldesigngroup.com/lego/pbLua/tutorial/pbLuaI2C.html)
  

     
Por último un pequeño video (http://www.flickr.com/photos/sergio_31415926535/4470548989/)

Todas las críticas constructivas y cualquier mejora que propongáis serán bienvenidas.

Excelente trabajo de investigación y perfectamente documentado. Casi me da pena tener ya el sensor de HiTechnic...

(http://t3.gstatic.com/images?q=tbn:Cg5HTThEVUchQM:http://www.uam.es/personal_pdi/ciencias/jdemigue/fisica1/cap6/pi.gif), me parece que que acabas de ahorrar un dinerillo en el sensor, y encima cacharreando y destripando, como más me gusta. No veo el día para probar esto... directo a Favoritos. Una maravilla  :B

Muchas Gracias!

¡Que bueno!  :O
Si acaso al joystick haberle colocado una pieza como esta... (http://img.bricklink.com/P/85/6538b.gif)
Para luego poder integrarlo sin muchos problemas en un robot o adaptarle un volante, por ejemplo.
Pero no me hagas mucho caso, tal y como está queda perfecto.

¡Ups! iba a nominarte, pero al ir a mirar ya estabas secundado, ¡enhorabuena!

Me has dejado loco.

Cita de: PotaG en 28 de Marzo de 2010, 23:35:41 PM
¡Si acaso al joystick haberle colocado una pieza como esta… (http://img.bricklink.com/P/85/6538b.gif)

Muy buena idea, le puede dar mucho juego.
Por cierto, pregunta de novato (18 mensajes),  ¿Nominarme para qué?  ??? Espero que no signifique lo mismo que en 'el gran petardo', prefiero que me metáis en la nevera si he infringido alguna norma.

Tengo que depurar el código, para afinar los tipos de las variables e implementar la lectura de los datos de calibración. Quizás me he precipitado, pero continuaré.

Je je, no te asustes, estas nominado para esto... http://www.hispalug.com/foro/index.php?topic=9686.0 (http://www.hispalug.com/foro/index.php?topic=9686.0)

Ey tremendo!!! lo maloe s que me veo incapaz de destripar mi pobre nunchuk!!

Si señor, menudo invento.  :O  :O

Necesito tu ayuda, señor Pi.

Ya he quitado las resistencias R1 y R2, pero como no sé leer diagramas eléctricos, no tengo claro el siguiente paso.

He intentado simular con gomillas, como he entendido que hay que hacerlo, la derecha sería el nunchaku y la izquierda iría al nxt:
(http://www.brickshelf.com/gallery/Minipepito/Explorin/nunchaku_a_la_derecha.jpg)

La resistencia de abajo iría al cable de datos.

También me he fijado en que eliminas el cable negro, que creo,  es de blindaje, si lo dejo sin conectar por el lado del nxt, ¿podría darme problemas?

Gracias de antemano por tu ayuda y, con muchas ganas de probar el aparatejo, espero tu respuesta, jejeje...

... Muuuuuuuuuchas gracias por la nominación, me habéis dejado  :O y :E  durante muchos días.

Tras conseguir leer los datos de calibración (cero y valor de 1G para cada uno de los tres ejes del acelerómetro y máximo, mínimo y cero de los dos ejes del joystick) estuve intentando acceder a los valores sin necesidad de descifrarlos como dicen en WiiBrew.       

Citar
The New Way
The new way to initialize the extension is by writing 0x55 to 0x(4)A400F0, then writing 0x00 to 0x(4)A400FB. It works on all extensions, and makes the extension type bytes unencrypted. This means that you no longer have to decrypt the extension bytes

No lo conseguí, así que hice barridos por todos los registros, sin buenos resultados => veamos lo que dicen los datos de calibra... ???.

16 redondos, grandes y hermosos ceros :_(. Creo que o los he sobrescrito o he encontrado como resetear un nunchuk, pero no se ir hacia atrás en el tiempo.

Espero sacar tiempo este finde para hacer un banco de pruebas para el cacharrito, un péndulo o algo parecido. ¿Tenéis alguna idea para usarlo?

Cita de: Minipepito
no tengo claro el siguiente paso.

He intentado simular con gomillas, como he entendido que hay que hacerlo, ....

Creo que está bien, las resistencias no puedes ponerlas mal, el diodo con la franja negra hacia el nunchuk. Si lo pones al revés lo que conseguirás es que no llegue corriente al nunchuk, un diodo deja pasar la corriente solo en un sentido.                     
Parece que se podría prescindir del diodo pero el nunchuk trabaja a 3,6V y el NXT le da 4,5V. Con el diodo se reduce el voltaje.
Los cables que no se usan los quité. No te confundas con los colores de los cables, NO me hago responsable de daños colaterales. La primera vez que lo conecte me temblaba la mano al pulsar el botón naranja.
Yo de electrónica NPI, pero está muy bien explicado en los enlaces del primer post.

Hasta hoy no vi este hilo y me he quedado boquiabierto de las cosas que se pueden llegar a hacer con el NXT. Lástima no haberlo hecho antes del día 8, porque esa nominación hubiera llevado también mi voto ;)

A ver si con un poco de suerte consigues pasar la calibración y seguir sacando resultados. Ideas de que hacer... muchas, anda que no da de sí un acelerómetro... desde un simple coche que cuando choca cambia de dirección, a usar un nunchuc conectado a un NXT y a su vez a un emisor PF para usar el nunchuc como control de un cacharro PF


PD: Me intriga ver que tu nick es 10Pi (supongo que porque el nick no puede llevar signos de puntuación), y el avatar Pi/2 ;)

Los datos de calibración siguen siendo 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  :_(. Esperemos que minipepito termine el suyo y podamos ver algo de luz.

He probado el sensor en dos situaciones distintas:

Un paseo: curvas, acelerar, frenar, baches, arboles, ... por lo menos curioso. Una pena no haber incluido en el video el grafico del sensor, como en F1.


Un péndulo: capturando los datos lo más rápido posible y como podéis ver, se nota hasta que el cable ejerce distinta resistencia cuando va que cuando viene.


Siguiente paso, buscar un modelo y compararlo, invertir el péndulo y  ...

Cita de: pulipuli en 12 de Abril de 2010, 08:49:19 AM
PD: Me intriga ver que tu nick es 10Pi (supongo que porque el nick no puede llevar signos de puntuación), y el avatar Pi/2 ;)

Cuando me registre hice muchos juegos de letras que no me convencían, recordé que hacia unos meses habían logrado un nuevo record: 2.699.999.990.000 decimales (http://bellard.org/pi/pi2700e9/index.html). Así que unos cuantos para el nick. He cambiado el avatar si lo identificáis y me decís que los relaciona prometo poner un número muuuuuuuuucho más interesante. B)

CitarCuando me registre hice muchos juegos de letras que no me convencían, recordé que hacia unos meses habían logrado un nuevo record: 2.699.999.990.000 decimales. Así que unos cuantos para el nick. He cambiado el avatar si lo identificáis y me decís que los relaciona prometo poner un número muuuuuuuuucho más interesante.

Alguna vez he tenido que usar la constante de Napier o más comúnmente conocido como número e  o_o
El quebradero de cabeza de mucho estudiantes de ingeniería  xD  xD


Estupendo el gráfico del coche  :angel:

Pues si que me ha durado poco el nuevo avatar  :-\, como prometí lo cambio.

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
(http://www.brickshelf.com/gallery/Minipepito/Explorin/chapuzasensor.jpg)

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.

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 (http://wiki.wiimoteproject.com/Nunchuck). Me gustaría ver el resultado para añadir funciones de lectura y que modifiquen la salida de Nunchuk_LIB.c

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

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.

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?

Bueno, aprovechando esa super caja (http://www.hispalug.com/foro/index.php?topic=14362.msg241508#msg241508) 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.

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.

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):

(http://www.hispalug.com/galeria/albums/userpics/45155/nunchuck_1.jpg) (http://www.hispalug.com/galeria/albums/userpics/45155/nunchuck_1.jpg)

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 (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 (http://file:///C:/Program%20Files/LEGO%20Software/LEGO%20MINDSTORMS%20NXT/engine/EditorVIs/Help%20Content/Full%20Help/start.htm?topic=file:///C:/Program%20Files/LEGO%20Software/LEGO%20MINDSTORMS%20NXT/engine/EditorVIs/Help%20Content/Full%20Help/topics/Help_IIC%20Write.htm) y Read (http://file:///C:/Program%20Files/LEGO%20Software/LEGO%20MINDSTORMS%20NXT/engine/EditorVIs/Help%20Content/Full%20Help/start.htm?topic=file:///C:/Program%20Files/LEGO%20Software/LEGO%20MINDSTORMS%20NXT/engine/EditorVIs/Help%20Content/Full%20Help/topics/Help_IIC%20Read.htm).

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

http://blog.ingenegros.org/?p=24 (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.

Lo tienes a tiro de piedra :}, me alegra mucho.(http://storage.technicbricks.com/Media/Common/Smileys/clapping.gif) (icono de http://technicbricks.blogspot.com/ (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 (http://robots-argentina.com.ar/Comunicacion_busI2C.htm) explican el protocolo I2C y en http://wiibrew.org/wiki/Wiimote/Extension_Controllers/Nunchuck (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.

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# (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:

(http://www.hispalug.com/galeria/albums/userpics/45155/nunchuck.jpg)

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 (http://www.nxtorm.es/digitales/sd-p-nunchuck-nxt.html) 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 (http://www.hispalug.com/foro/index.php?topic=14362.msg241508#msg241508) 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.

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/s²
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.

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!

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  :}

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...

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!

Si no entiendo mal, preguntas (por ejemplo) si se puede hacer avanzar un vehículo y activar una pinza delantera todo a la vez ¿no?

Sí, sí se puede. Puedes leer todos los ejes + joystik + botones a la vez y programar en consecuencia. El icono tiene una salida para cada uno:

(http://www.hispalug.com/galeria/albums/userpics/45155/nunchuck.jpg)

En el video lo he puesto separado por claridad de la explicación pero, por ejemplo, en el segundo 57 del video del mensaje anterior (http://youtu.be/_Zhv34iLdvU), se muestra de forma simultánea la acción del eje X y del eje Y y podrías sumarle la acción de los botones. No se si era esto lo que preguntabas. Si no, nos dices.

Sí era eso lo que decía, gracias!!.

Es que estas explicaciones dan para mucho, así que ya tengo algo en mente jajaja, aunque lo primero va a ser pillarse unos mandos de la wii y adecuarlos para el NXT :P

Saludos!