Encoder y Arduino. Tutorial sobre el módulo sensor de velocidad IR con el comparador LM393 (Encoder FC-03) Deja un comentario

En este tutorial muestro como usar el encoder FC-03 o encoder FZ0888 (Módulo sensor de velocidad de infrarrojos con el comparador LM393) o optointerruptor. Lo he implementado en las 4 ruedas del robot Andromina OFF ROAD para calcular la velocidad de giro de estas. Se ha elegido este encoder por que es el más económico que hay en el mercado. Este tutorial muestra las dos mejores soluciones para conectar el encoder FC-03 a Arduino UNO o MEGA sin tener problemas. El encoder se muestra a continuación:

Foto del montaje del motor del robot, del encoder y del disco dentado.

1-El encoder : Con este módulo sensor de velocidad IR con el comparador LM393 podemos calcular la velocidad de rotación de las ruedas de nuestro robot. Si colocamos una corona dentada que gira unida a nuestra rueda. También se podría usar como un interruptor óptico.
El funcionamiento básico de este sensor es el siguiente; Si se hace pasar cualquier cosa entre la ranura del sensor, este crea un pulso digital en el pin D0. Este pulso va de 0V a 5V y es una señal digital TTL. Luego con Arduino podemos leer este pulso.
A continuación describimos las diferentes partes del encoder:

Principales características técnicas:
Dimensiones: 32 x 14 x 7mm
La ranura de lectura del sensor tiene un ancho de 5mm.
Dos salidas, una Digital y otra Analógica.
LED indicador de alimentación.
LED indicador de los pulsos de salida del pin D0.

2-Pulsos malos: Con este encoder he tenido también problemas a la hora de leer los pulsos digitales que genera el comparador LM-393. Arduino UNO o MEGA lee más pulsos de los que se generan realmente. Lee del orden de 4 veces más pulsos de los que se generan realmente. He buscado información sobre este problema en internet y he encontrado poca. Por lo que he podido aprender, es que este sensor es muy sensible a las interferencias que se puede introducir en los pines VCC y GND. Si alimentamos el sensor desde el propio Arduino a 3,3V o 5V, El regulador de tensión del propio Arduino pueden introducir corrientes parásitas en el sensor. Produciendo que este no funcione correctamente.
Usando un osciloscopio conectado entre los pin D0 y GND y analizado los pulsos que se generan en el encoder. Ver las fotos siguientes:

Señal del pulso digital del pin A0.

Señal del pulso analógico del pin D0.

Si miramos el pulso generado parece que es un pulso cuadrado correcto, pero si se amplia mucho el inicio del pulso se puede ver que el pulso no es cuadrado. Tal y como puede verse en la foto siguiente, la señal digital cuadrada TTL que genera el encoder FC-03 tiene rebotes al inicio del pulso.

Rebote inicial de la señal visto con un osciloscopio.

También tiene rebotes al final del pulso. Arduino es muy sensible y lee estos rebotes como pulsos buenos y realmente no lo son. Ver foto siguiente con los rebotes al final del pulso:

Rebote final de la señal visto con un osciloscopio.

3-Dos soluciones : Para solventar este problema, he diseñado dos soluciones. La primera solución es hacer un programa, un “sketch” de Arduino que no lea los rebotes y no lea falsas señales. La segunda solución es colocar un condensador para que elimine los rebotes iniciales y finales.
La solución mejor que propongo para solventar este problema es la siguiente.

5-Diseño : Este encoder se a implementado en el robot Andromina OFF ROAD. Para medir la velocidad del robot, podemos poner solo dos encoders en dos ruedas o poner 4 encoders en las 4 ruedas.

Vista del chasis del robot Andromina OFF ROAD.

A continuación se enseña el esquema básico de la conexión de los 4 encoders FC-03 al Arduino MEGA para un robot 4×4. Este esquema no se puede implementar en el Arduino UNO ya que solo tiene 2 pines con interrupciones. El Arduino MEGA tiene 6 pines con interrupciones, que son ; 2, 3, 18, 19, 20 y 21.

Esquema del robot con los conexión de los 4 encoders.

En la foto siguiente se puede apreciar todas las piezas que conforman el conjunto motriz; la rueda, el disco dentado, el encoder, el motor del robot y el soporte del motor. He diseñado un disco dentado que se acopla a la llanta de la rueda. Este disco lo he diseñado con 20 dientes. Con este número de dientes el encoder tiene una óptima presición. También he diseñado un nuevo soporte de motor para poder atornillar el encoder al motor.

Si el pin VCC del encoder FC-03 se alimenta con una tensión de 5 Voltios se generan corrientes parásitas (rebotes) en la señal digital de pulsos y Arduino no lee bien los pulsos del encoder. Leyendo más pulsos de los que realmente se generan.
A continuación se muestran las diferentes señales que salen de los dos pines del módulo.

Señal analógica de los pulsos de la salida del pin A0.

Señal digital de los pulsos de la salida del pin D0.

En la gráfica siguiente se puede ver como el pulso cuadrado digital se ha deformado un poco en su inicio debido a la colocación de un condensador.

Señal digital de los pulsos de la salida del pin D0 con un condensador (104)

7-Solución 2; Aquí presento la solución  mediante “software”. En el siguiente “sketch” de Arduino se soluciona el problema de los rebotes en los pulsos digitales del encoder. Con la función “counter” del “sketch”. Esta función se activa por medio de una interrupción en el pin 2 de Arduino, cuando se detecta la rampa de subida del pulso. Para no contar los rebotes la función primero lee la rampa de subida, luego comprueba que ha pasado unos 500 micro-segundos desde la última lectura de un pulso y luego vuelve a leer la señal del pin 2 para verificar que aún se esta leyendo el pulso entrante. Si todo esto se cumple se cuenta el pulso como bueno. De esta manera evitamos leer los rebotes que se generan al inicio del pulso y al final.
Esta solució es correcta si no queremos poner un condensador. Pero estamos enviado a Arduino señales buenas y señales malas. lo que provoca más interrupciones de las realmente necessaris.

/// Variables //////////////////////////////////////////////////////////////////////////////////////////////////////////////

int encoder_pin = 2;             //Pin 2, donde se conecta el encoder

unsigned int rpm = 0;           // Revoluciones por minuto calculadas.

float velocity = 0;                 //Velocidad en [Km/h]

volatile byte pulses = 0;       // Número de pulsos leidos por el Arduino en un segundo

unsigned long timeold = 0;  // Tiempo

unsigned int pulsesperturn = 20; // Número de muescas que tiene el disco del encoder.

const int wheel_diameter = 64;   // Diámetro de la rueda pequeña[mm]

static volatile unsigned long debounce = 0; // Tiempo del rebote.

////  Configuración del Arduino /////////////////////////////////////////////////////////

void setup(){

Serial.begin(9600); // Configuración del puerto serie

pinMode(encoder_pin, INPUT); // Configuración del pin nº2

attachInterrupt(0, counter, RISING); // Configuración de la interrupción 0, donde esta conectado.

pulses = 0;

rpm = 0;

timeold = 0;

Serial.print(“Seconds “);

Serial.print(“RPM “);

Serial.print(“Pulses “);

Serial.println(“Velocity[Km/h]”);}

////  Programa principal ///////////////////////////////////////////////////////////////////////

void loop(){

if (millis() – timeold >= 1000){  // Se actualiza cada segundo

noInterrupts(); //Don’t process interrupts during calculations // Desconectamos la interrupción para que no actué en esta parte del programa.

rpm = (60 * 1000 / pulsesperturn )/ (millis() – timeold)* pulses; // Calculamos las revoluciones por minuto

velocity = rpm * 3.1416 * wheel_diameter * 60 / 1000000; // Cálculo de la velocidad en [Km/h]

timeold = millis(); // Almacenamos el tiempo actual.

Serial.print(millis()/1000); Serial.print(”       “);// Se envia al puerto serie el valor de tiempo, de las rpm y los pulsos.

Serial.print(rpm,DEC); Serial.print(”   “);

Serial.print(pulses,DEC); Serial.print(”     “);

Serial.println(velocity,2);

pulses = 0;  // Inicializamos los pulsos.

interrupts(); // Restart the interrupt processing // Reiniciamos la interrupción

}

}

////Fin de programa principal //////////////////////////////////////////////////////////////////////////////////

///////////////////////////Función que cuenta los pulsos buenos ///////////////////////////////////////////

void counter(){

if(  digitalRead (encoder_pin) && (micros()-debounce > 500) && digitalRead (encoder_pin) ) {

// Vuelve a comprobar que el encoder envia una señal buena y luego comprueba que el tiempo es superior a 1000 microsegundos y vuelve a comprobar que la señal es correcta.

debounce = micros(); // Almacena el tiempo para comprobar que no contamos el rebote que hay en la señal.

pulses++;}  // Suma el pulso bueno que entra.

else ; }