Bricolabs Wiki

Esta página es de solo lectura. Puedes ver la fuente pero no puedes cambiarla. Pregunta a tu administrador si crees que esto es incorrecto.
{{  :guias:mbot:mbot_ranger.jpg?400  |mbot_ranger.jpg}}

**trabajo en progreso**
====== mBot Ranger con el IDE de arduino ======

El mBot Ranger cuenta con una completa librería de funciones ([[https://github.com/Makeblock-official/Makeblock-Libraries/archive/master.zip|https://github.com/Makeblock-official/Makeblock-Libraries/archive/master.zip]]) que permite programarlo directamente desde el IDE de arduino.

Sin embargo, la sintaxis resulta un poco farragosa para alguien que está dando los primeros pasos en la programación con el IDE de arduino (y para muchos que ya llevan mucho andado). El objetivo de este artículo es facilitar los recursos para que alumnos y profesores puedan programar la placa Auriga del mBot Ranger al más puro estilo arduino.

===== Instalación del Driver de comunicación en el ordenador =====

Hay muchas referencias de problemas con el chip de comunicación CH340g que trae la placa Auriga que equipa al Ranger. Pero para eso no tenemos alternativa, ya que es el chip de comunicaciones que viene soldado en la placa. La forma más fácil de instalar el controlador es la que os indicamos a continuación, usando el mismo programa mBlock. 

Pero si tienes problemas, o prefieres probar a instalar la última versión, que en algunos casos funciona mejor, una buena idea para empezar es buscar en internet "driver CH340g" y el nombre de vuestro sistema operativo. Puedes encontrar muchas páginas como esta [[http://www.prometec.net/ch340g]] que pueden ser de ayuda. Por si tienes tentaciones de ir directamente a la página del fabricante [[http://www.wch.cn/product/CH340.html]], que sería lo más lógico, te adelantamos que está exclusivamente en chino.

Si prefieres empezar por lo más fácil, basta con que en el programa mBlock selecciones en el menú **Conectar>Instalar Driver de arduino**. Es muy posible que las primeras veces que te conectes tengas problemas que pueden ir desde que el puntero del ratón quede congelado por un tiempo, hasta que el ordenador se reinicie bruscamente. Es importante que te asegures de tener tu trabajo guardado antes de conectarte a la placa. Más adelante mejora un poco. La verdad es que este driver no va muy fino.


Debes tener en cuenta que cuando abriste el Ranger por primera vez, la placa Auriga trae cargado un programa que incluye varias funciones para poder usarla con el mBlock, o conectarte por Bluetooth. Cuando subas un nuevo programa desde el IDE de arduino ese programa se sustituye por el que estás subiendo, y pierdes esas funciones. Siempre puedes recuperar las funciones que venían de fábrica volviendo a cargar el programa original en el menú **Conectar>Actualizar Firmware**

====== La primera librería ======

Lo primero en un robot es lograr que se mueva. La solución más sencilla que se nos ocurre es usar la librería mobilerobot que es parte del conjunto de librerías para accionamiento de motores con arduino que podéis descargar en https://github.com/brico-labs/ArduinoDCmotorDrivers.

Para instalar esta librería y las otras que iremos necesitando lo primero es descargarla del repositorio que os indicamos en el párrafo anterior y descomprimirla. La librería que nos interesa es **mobilerobot**, y para instalarla, lo que tenemos que hacer es copiar la carpeta **mobilerobot** a la carpeta **arduino>libraríes**

{{ :guias:mbot:descarga_libreria_github.png?700 |}}

Para comprobar si la librería está bien instalada podéis entrar en el programa arduino, el IDE de arduino (si ya lo teníais abierto es necesario salir y volver a entrar cada vez que instaléis nuevas librerías). Luego, en el menú **Archivo>Ejemplos>mobilerobot>mBotRanger_Arduino>mBotRanger_Arduino** podéis abrir el ejemplo para mBot.

{{ :guias:mbot:ejemplo_mbot.png?800 |}}

Recordad que si queréis modificar y guardar el ejemplo deberéis guardar una copia (Guardar como…).


====== Nos movemos ======

En el ejemplo se muestra cómo crear un objeto del tipo Robot que sea compatible con el Ranger, y cómo usar las cuatro funciones que acabamos de incluir:

  * **forward (velocidad_L, velocidad_R, tiempo_avance)**: hace avanzar el mBot durante el tiempo_avance indicado (en mili segundos) con las velocidades velocidad_l y velocidad_R en las ruedas izquierda y derecha. el valor debe estar entre 0 y 255.
  * **reverse (velocidad_L, velocidad_R, tiempo_avance)**: para que el Ranger retroceda. Los parámetros son los mismos que en la función anterior.
  * **rotate (tiempo_giro)**: El Ranger gira sobre si mismo durante el tiempo de giro indicado (en mili segundos). Si tiempo_giro es positivo, el giro es hacia la derecha. si es negativo hacia la izquierda.
  * **brake (tiempo_freno)**: Frena el robot durante el tiempo indicado (en mili segundos)
Un ejemplo de uso podría ser:

<code c_mac>
#include <RobotMovil.h>
RobotMovil robot(46,47,10,49,48,11);

void setup() {}

void loop()
{
  robot.forward(175,175,1000);
  robot.reverse(120,120,2000);
  robot.rotate(1000);
  robot.rotate(-1000);
  robot.brake(1000);
}
</code>

La misma librería sirve para controlar cualquier robot que construyáis con un arduino y un driver de los tipos que se usan más habitualmente para pequeños motores (L293, L298 y TB6612). En la carpeta de ejemplos de la librería están los esquemas de cómo montar cada uno de ellos y enlaces a algunos proyectos abiertos de robots.

======   ======


====== Explorando el mundo ======

El Ranger viene equipado con una tarjeta llamada Auriga que incluye varios sensores. A nuestros efectos es como una tarjeta arduino MEGA 2560. Los sensores están conectados con pines analógicos del microprocesador, por lo que se pueden leer con la instrucción **analogRead (número_de_pin)**  [[http://www.arduino.org/learning/reference/analogread|http://www.arduino.org/learning/reference/analogread]]. El valor de salida variará entre 0 y 1023.

  * **Sensor de luz izquierdo**  A3 → analogRead(A3)
  * **Sensor de luz derecho**.. A2 → analogRead(A2)
  * **Sensor de temperatura**.. A0 → analogRead(A0)
  * **Sensor de sonido**……. A1 → analogRead(A1). 

El sensor de temperatura es una NTC (resistencia con coeficiente de temperatura negativa) que tiene un comportamiento exponencial. Sin entrar en más detalles, este es un código de ejemplo para leer el valor de la temperatura. Si necesitáis hacer alguna lectura, podéis copiar la fórmula que está dentro de loop.

Este y otros tipo de sensores de temperatura tienen un comportamiento bueno cuando se trata de medir variaciones de temperatura, pero pueden darnos el valor con hasta un par de grados de más o de menos.

<code c_mac>
int PIN_temperatura = A0;
float temperatura;

void setup() 
{
// Abre a comunicación serie (para o monitor serie)
  Serial.begin (9600);
}

void loop() 
{
  // Le o valor da tensión no pin A0
  float v_temperatura = analogRead (PIN_temperatura); 
  
  // Calcula o valor da temperatura
  temperatura = 1.0 / (log(v_temperatura/(1023-v_temperatura)) / 3375.0 + 1/298.15) - 273.15;
  
  Serial.print ("Temperatura: "); Serial.println (temperatura);
 
  delay (500);
}
</code>


En el sensor de sonido, la salida del micrófono integrado se conecta directamente a la entrada analógica A1, por lo que mide el valor instantáneo de la onda de sonido, y no de su amplitud. Un buen truco para conseguir un valor proporcional a la intensidad del ruido ambiente es realizar varias medidas seguidas y quedarse con el máximo. En este ejemplo tomamos 100 medidas, que parecen muchas, pero llevan muy poco tiempo.

<code c_mac>
int PIN_sonido = A1;
int intensidad_sonido;

void setup() 
{
// Abre a comunicación serie (para o monitor serie)
  Serial.begin (9600);
}

void loop() 
{
  intensidad_sonido = 0;
  
  for (int i=0; i<100; i++)
  {
    // Le o valor da tensión no pin A1 e queda co máximo das medidas tomadas
    intensidad_sonido = max (intensidad_sonido, analogRead (PIN_sonido));
  }
  Serial.print ("Intensidad de sonido: "); Serial.println (intensidad_sonido);
 
  delay (500);
}
</code>


====== Haciendo ruido ======

En el **pin 45**  tenemos un zumbador que responde perfectamente a las instrucción **tone**  [[http://www.arduino.org/learning/reference/tone|http://www.arduino.org/learning/reference/tone]] y **noTone**  [[http://www.arduino.org/learning/reference/notone|http://www.arduino.org/learning/reference/notone]]

Un ejemplo que seguro os sonará:

<code c_mac>
int zoador = 45;

void setup()
{
  tone (zoador, 392); delay (600); noTone (zoador); delay (10);
  tone (zoador, 392); delay (600); noTone (zoador); delay (10);
  tone (zoador, 392); delay (600); noTone (zoador); delay (10);
  tone (zoador, 311); delay (450); noTone (zoador); delay (10);
  tone (zoador, 466); delay (150); noTone (zoador); delay (10);
  tone (zoador, 392); delay (600); noTone (zoador); delay (10);
  tone (zoador, 311); delay (450); noTone (zoador); delay (10);
  tone (zoador, 466); delay (150); noTone (zoador); delay (10);
  tone (zoador, 392); delay (600); noTone (zoador); delay (10);

  delay (600);

  tone (zoador, 588); delay (600); noTone (zoador); delay (10);
  tone (zoador, 588); delay (600); noTone (zoador); delay (10);
  tone (zoador, 588); delay (600); noTone (zoador); delay (10);
  tone (zoador, 622); delay (450); noTone (zoador); delay (10);
  tone (zoador, 466); delay (150); noTone (zoador); delay (10);
  tone (zoador, 370); delay (600); noTone (zoador); delay (10);
  tone (zoador, 294); delay (450); noTone (zoador); delay (10);
  tone (zoador, 466); delay (150); noTone (zoador); delay (10);
  tone (zoador, 392); delay (1200); noTone (zoador); delay (10);

  noTone (zoador);
}

void loop() {}
</code>

====== Conectando sensores externos ======

La tarjeta Auriga del mBot tiene 5 puertos dedicados a la conexión con el mundo exterior. Son los que están señalados del 6 al 10 y con los cuatro colores blanco, amarillo, azul y gris oscuro. Cada uno de los puertos tiene alimentación a 5V, está conectado con dos entradas analógicas del arduino MEGA2560. También permiten conectar dispositivos I2C. Las entradas de cada uno de los puertos son las siguientes:

  * **PUERTO 06**  A10 y A15
  * **PUERTO 07**  A9 y A14
  * **PUERTO 08**  A8 y A13
  * **PUERTO 09**  A7 y A12
  * **PUERTO 10**  A6 y A11
======   ======

====== Sensor SIGUE-LINEAS ======

{{  :guias:mbot:sigue_lineas.png?100}} Tiene dos barreras ópticas reflexivas para detectar si el suelo es blanco o negro. La salida es digital (todo o nada), ya que tienen un comparador y un indicador luminoso para cada canal. Cuando se refleja la luz en el suelo (zona blanca o clara) el indicador azul junto al sensor se enciende y la salida pasa a nivel alto. Cuando no se refleja la luz (el suelo está lejos) o el suelo es suficientemente oscuro (estamos sobre la línea negra), el indicador se apaga y la salida pasa a nivel bajo. No podemos ajustar la sensibilidad.

El valor de salida se puede leer con la instrucción **digitalRead (número_de_pin)**  [[http://www.arduino.org/learning/reference/digitalread|http://www.arduino.org/learning/reference/digitalread]].

Por ejemplo, si el sensor está conectado en el PUERTO 09:

  * **Valor del sensor izquierdo**  digitalRead(A7)
  * **Valor del sensor derecho **  digitalRead(A12)

Este es el código para siguelínes básico:  

<code c_mac>
#include <RobotMovil.h>
RobotMovil robot(46,47,10,49,48,11);

  bool linea_dcha;   // Esta variable será certa cando o sensor dereito está sobre a liña
  bool linea_izqda;  // Esta variable será certa cando o sensor esquerdo está sobre a liña
  

void setup() {
  pinMode (A7,  INPUT);  // Son as entradas asociadas co PORTO 9
  pinMode (A12, INPUT);  // Son as entradas asociadas co PORTO 9
}

void loop() {
  linea_dcha  = ! digitalRead (A7);
  linea_izqda = ! digitalRead (A12);
  
  // Os dous sensores están sobre a liña
  if      (  linea_dcha  &&   linea_izqda) robot.forward(135,135,10);
  
  // O sensor dereito saíuse da liña
  else if (! linea_dcha  &&   linea_izqda) robot.rotate( 10);

  // O sensor esquerdo saíuse da liña
  else if (  linea_dcha  && ! linea_izqda) robot.rotate(-10);
  
  // Falta programar o que pasa cando os dous sensores saen la liña
}
</code>

======   ======
====== Sensor de ULTRA SONIDOS ======

{{  :guias:mbot:ultrasonidos.png?100}} Para este sensor lo más conveniente es usar la librería NewPing que podemos descargar en [[https://bitbucket.org/teckel12/arduino-new-ping/downloads/|https://bitbucket.org/teckel12/arduino-new-ping/downloads/]]. De esta forma podremos usar la misma librería en los arduinos con el muy popular y barato sensor de ultrasonidos SR04. Tenemos una completa explicación del uso de esta librería en [[http://playground.arduino.cc/Code/NewPing|http://playground.arduino.cc/Code/NewPing]]

{{  :guias:mbot:ejemplo_newping.png?600  }}

Una vez instalada podemos ver un ejemplo de cómo funciona en **Archivo>Ejemplos>NewPing>NewPingExample**  En el ejemplo tenemos que sustituir los valores TRIGGER_PIN y ECHO_PIN, en función del PUERTO en el que tengamos enchufado el sensor. En nuestro caso TRIGGER_PIN y ECHO_PIN siempre serán iguales. Por ejemplo, si el sensor está conectado en el PUERTO 10:

**#define TRIGGER_PIN A11**

**#define ECHO_PIN A11**

====== Luces ======

Pendiente:

==== El LED del mítico blink está demasiado escondido ====

Para muchos de nosotros el primer programa que hicimos en arduino es el blink que está en **Archivo>Ejemplos>01.Basics>Blink**. Además es el equivalente al "Hello World", la forma de comprobar que todo va bien hasta aquí. En la tarjeta Auriga del Ranger, el led "ON BOARD" está conectado en el pin 13, como en el Arduino UNO. Pero el montaje de la placa hace que quede oculto. Por desgracia no tenemos ningún otro LED en la placa que sea igual de fácil de manejar para comprobar que todo va bien.

==== Vamos a hacer un blink con los Neopixel ====

El círculo de luces que tiene la placa Auriga del Ranger está formado por un tipo de LED un tanto especial: los NEOPIXEL. Para manejarlos también hay una librería, en este caso de Adafruit: [[https://learn.adafruit.com/adafruit-neopixel-uberguide/arduino-library|https://learn.adafruit.com/adafruit-neopixel-uberguide/arduino-library]].

En nuestro caso tenemos un anillo formado por 12 Neopixel que están conectados al pin 44. Para que el ejemplo funcione con el Ranger debemos poner estos valores:

**#define PIN 44 **

**#define NUMPIXELS 12 **

Con este ejemplo podemos conseguir un efecto parecido al del programa de ejemplo Blink, ya que uno de los LED parpadeará una vez por segundo:

<code c_mac>
#include <Adafruit_NeoPixel.h>  // Libreria para manexar o anel de Neopixels
 
int PIN       = 44;  // Pin no que están conectados os Neopixels 
int NUMPIXELS = 12;  // Número de Neopixels

Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
 
void setup() {
  pixels.begin ();   // Esta instrucción inicializa a librería
}
 
void loop (){
  // Con este código encendemos o pixel 8
  pixels.setPixelColor(8, pixels.Color(175,0,0));
  pixels.show();
  delay (500);
 
  pixels.setPixelColor(8, pixels.Color(0,0,0));
  pixels.show();
  delay (500);
}
</code>

Debemos tener en cuenta que el anillo de Neopixels está muy cerca de los sensores de luz, por lo que interfieren mucho con ellos cuando algún LED está encendido.
Bricolabs Wiki

Herramientas de usuario

Herramientas del sitio

Herramientas de la página
