Primera comunicación NXT <--> Arduino <--> Sensor analógico

         En esta entrada se va a describir cómo conectar sensores analógicos al NXT usando Arduino como intermediario.

Aunque la conexión de sensores analógicos se puede hacer de manera directa a los puertos del NXT, cada sensor presenta unas resistencias de salida distintas, unos rangos de tensión y corriente distintos, y además, para poder conectar varios sensores a la misma entrada sería necesario un multiplexor y una circuitería que permitiera al robot elegir de qué sensor quiere leer. Todas estas funciones van a ser desempeñadas por Arduino, que será el encargado de leer los valores analógicos desde los sensores, hacer la conversión a digital, y mandar los datos al robot que éste necesite.

Sensor analógico: Ardupilot 4 DOF

El Ardupilot 4 DOF es un IMU que proviene de un proyecto original de Chris Anderson y Jordi Muñoz para crear un AHRS (Attitude Heading Reference System) para control UAV y captura general de movimiento y orientación.

Ésta es la placa principal de sensores que se usa en la placa ArduPilot. Por si sola proporciona 4 grados de libertad (4 DOF) y puede ser conectada directamente a sus pines analógicos o utilizado en cualquier otro proyecto que necesite de captura de movimiento sobre varios ejes.

El sensor viene equipado con un giroscopio LISY300AL de ±300°/s de un sólo eje y un acelerómetro ADXL335 de 3 ejes ±3g. Todo los componentes de filtrado están incorporados en la placa. No dispone de regulador de tensión, por lo que hay que aplicar una tensión de alimentación limpia de 3.3V.

Las principales características de esta placa son:

• 4 grados de libertad:
• ADXL335 - acelerómetro de 3 ejes, ±3g
• LISY300AL - giroscopio de un eje para velocidad angular, ±300°/s
• Compatible con ArduPilot 6DOF daughter board
• Los valores analógicos de los seis ejes son accesibles
• Espaciado de pines: 0.1"
• Dimensiones: 2.3x1.5cm

En las figura siguiente se puede ver tanto el tamaño de la placa, como las salidas que ésta nos ofrece:

Conexiones entre Arduino Mega 2560 y el IMU

El primer paso es realizar la conexión entre la placa de Arduino que se ha utilizado (Arduino Mega 2560) y el sensor descrito anteriormente. Las conexiones que se han hecho han sido:

• Salidas y,z,x del acelerómetro y x, y z del giróscopo a las entradas A0-A5 analógicas de la placa (en ese orden, aunque eso da igual siempre y cuando lo tengamos en cuenta en el código que se use).
• La toma de alimentación de 3,3 V del sensor necesita una alimentación estable. Se conecta a la salida de 3,3 V de Arduino y al pin AREF. Esto último se hace para escalar correctamente el conversor A/D, ya que la referencia analógica por defecto para Arduino es de 5 V.
• Las tierras se conectan juntas

Conexiones entre Arduino Mega 2560 y el NXT

En cuanto a las conexiones entre el sistema de desarrollo de Arduino y el NXT, éstas ya se comentaron en otra entrada del blog. Al igual que entonces, esta comunicación se va a realizar siguiendo el protocolo de comunicación I²C. Estas conexiones serían las siguientes:

• Pines 2 y 3 del NXT (colores rojo y negro) se conectan a las entradas de tierra de Arduino (GND).
• Pin 4 del NXT (color verde) que corresponde a la alimentación, se conecta a la entrada de 5 V de Arduino.
•  Pin 5 del NXT (color amarillo) que corresponde a la línea de reloj del protocolo I²C se conecta al pin marcado como SCL en la placa de Arduino.
• Pin 6 del NXT (color azul) que corresponde a la línea de datos del protocolo I²C se conecta al pin marcado como SDA en la placa de Arduino.

 Código cargado en el NXT

En cuanto a las conexiones entre el sistema de desarrollo de Arduino y el NXT, éstas ya se comentaron el apartado 4.3 de esta memoria. Al igual que entonces, esta comunicación se va a realizar siguiendo el protocolo de comunicación I²C. Estas conexiones serían las siguientes:

-       Pines 2 y 3 del NXT (colores rojo y negro) se conectan a las entradas de tierra de Arduino (GND).

-       Pin 4 del NXT (color verde) que corresponde a la alimentación, se conecta a la entrada de 5 V de Arduino.

-       Pin 5 del NXT (color amarillo) que corresponde a la línea de reloj del protocolo I²C se conecta al pin marcado como SCL en la placa de Arduino.

-       Pin 6 del NXT (color azul) que corresponde a la línea de datos del protocolo I²C se conecta al pin marcado como SDA en la placa de Arduino.

import lejos.nxt.*;




public class ArduCom {




    public static void main(String[] args) throws Exception{
        byte [] dato = new byte[3];
        String Tipo = "";
        String ID ="";
        String Ver="";
        int err = 0;
       
        for (int i=0;i<dato.length;i++){
            dato[i] = 0;
        }
       
        I2CSensor Arduino = new I2CSensor(SensorPort.S1);
        Arduino.setAddress(1);
        Ver = Arduino.getVersion();
        System.out.println("Ver: "+Ver);
        Tipo = Arduino.getSensorType();
        System.out.println("Tipo: "+Tipo);
        ID = Arduino.getProductID();
        System.out.println("ID: "+ID);
        Thread.sleep(1000);
        while (!Button.ESCAPE.isPressed()) {
            err = Arduino.getData(3, dato, 3);
            System.out.println("Acel: "+dato[0]+" "+dato[1]+" "+dato[2]);;
            err = Arduino.getData(4, dato, 3);
            System.out.println("Giros: "+dato[0]+" "+dato[1]+" "+dato[2]);
        } //Fin del while
    }
}

Código cargado en Arduino

A continuación se va a presentar el código que se ha cargado en Arduino. Este código se ha dejado comentado para facilitar la comprensión del mismo. Las tareas que realiza son las siguientes:

-       En el apartado de configuración (setup) se configura:

o   Referencia externa de 3,3 V

o   Se marcan los pines analógicos como salidas

o   Nos unimos al bus I²C como esclavos usando la dirección 1. A través de él se realizará la comunicación con el NXT.

o   Se configura la velocidad de escritura por el puerto serie, lo que nos va a permitir ver a través de la herramienta de monitorización del propio entorno de desarrollo de Arduino los datos que vayamos leyendo y convirtiendo desde el sensor analógico.

o   Se configuran las rutinas que se ejecutarán cuando se reciba una petición de datos desde el NXT

-       El bucle principal realiza la lectura de los pines analógicos comprendidos entre el 0 y el 5, que será donde estén conectados los pines del sensor. Se les resta el valor medio del sensor en reposo para que den un valor 0 estando en reposo. Estos datos se almacenan y se dejan listos para enviarlos al NXT cuando sea necesario.

-       En las rutinas de interrupción se identifica  el tipo de dato que está pidiendo el NXT (codificado en el campo registro) y se procede al envío de dichos datos.

El código usado es el siguiente:

#include <Wire.h> //Para gestionar las comunicaciones

//Definiciones y variables globales

uint8_t SensorVersion[9] = " V0.1   ";

uint8_t SensorName[9] =    "Arduino ";

uint8_t SensorType[9] =    "Casero  ";

byte buffersalida[] = { 0, 0, 0, 0, 0, 0}; //Para enviar al RCX

byte buffgiros[] = { 0, 0, 0}; //Ejes x, y, z del giroscopo

byte buffacel[] = { 0, 0, 0}; // Ejes x, y, z del acelerometro

int val = 0;                    //Datos que se leeran del acelerometro o giroscopo

unsigned long timer=0;          //timer

unsigned long  delta_t;         //delta o tiempo entre muestras

byte rec;

void setup(){

 

  analogReference(EXTERNAL);     //Usamos referencia externa de 3,3 V para calibrar el ADC

  Serial.begin(115200);

  DDRC = B00000000; //Marcamos los puertos analogicos como salidas

 

  Serial.println("t[ms] \t az \t ay \t ax \t gx \t gy \t gz "); //Cabeceras

   

  Wire.begin(1); //Nos unimos como esclavos con dir. 1

  Wire.onRequest(requestEvent); //Rutinas para cuando llegue algo

  Wire.onReceive(receiveEvent);

 

  timer=millis();

}

void loop(){

  delta_t = millis() - timer; // Calculamos el tiempo de adquisicion

  timer=millis();          // Actualizamos el timer

  Serial.print(delta_t);

  Serial.print ("\t");

    

  for (long i=0; i<6; i++) //Vamos a recorrer los pines analogicos

 {

  val = analogRead(i);    // Leemos el pin de entrada

 

  if(i==0) { //Le quitamos el offset al valor leido

    val = val - 601;

    buffacel[2] = val; //Eje z del acelerometro

  } else if (i==1) {

    val = val - 506;

    buffacel[1] =  val; // Eje y del acelerometro

  } else if (i==2) {

    val = val - 504;

    buffacel[0] =  val; // Eje x del acelerometro

  } else if (i==3) {

    val = val - 504;

    buffgiros[0] = val; //Eje x del giroscopo

  } else if (i==4) {

    val = val - 502; //Valor medio       

    buffgiros[1] = val; //Eje y del giroscopo

  } else if (i==5) {

    val = val - 483; //Valor medio

    buffgiros[2] = val; //Eje z del giroscopo

  }

 

  Serial.print(val);      //Imrpimimos por puerto serie

  Serial.print ("\t");

 } 

  Serial.println("");

  delay(16);             //Bucle ejecutado a ~ 50Hz o 20ms

}

void receiveEvent(int len){ //Devuelve el nº de bytes recibidos

  while (0 < Wire.available() ) {

    rec = Wire.receive();

  } //While

}

void requestEvent(){

  Serial.print(rec, BYTE);

  if (rec == 0x00){ //Version del sensor

    Wire.send(SensorVersion, 8);

  } else if (rec == 0x08){ //Nombre del sensor

    Wire.send(SensorName, 8);

  } else if (rec == 0x10){ //Tipo del sensor

    Wire.send(SensorType, 8);

  } else if (rec == 0x03) { // Lectura del acelerometro

    Wire.send(buffacel, 3);

  } else if (rec = 0x04) { //Lectura del giroscopo

    Wire.send(buffgiros, 3);

  } else {

    buffersalida[0] = 0;

    buffersalida[1] = 0;

    Wire.send(buffersalida, 2);

  }

}

Conclusiones

Se ha realizado con éxito la comunicación entre un sensor analógico y el NXT usando como intermediario el Sistema de Desarrollo Arduino, que se comunica con el robot haciendo uso del protocolo I²C. Los datos que se reciben desde el sensor analógico son correctos, y sólo se aprecia una oscilación de números algo mayor en dos ejes del giróscopo. Esta oscilación debida al ruido de medida, puede estar relacionada con el hecho de que las pruebas se hayan realizado en una placa de prototipos estándar y con hilos de conexión normales. A continuación se muestra una fotografía tomada del sistema bajo pruebas.

----------------------------------------------------------------------------------------------------------------

Referencias:

- La placa IMU usada: http://www.bricogeek.com/shop/181-sensor-ardupilot-6-dof.html  

- Razor IMU and Arduino: http://voidbot.net/razor-6dof.html