traballo en progreso

O mBot Ranger conta cunha completa librería de funcións (https://github.com/Makeblock-official/Makeblock-Libraries/archive/master.zip) que permite programalo directamente desde o IDE de arduino.

Con todo, a sintaxe resulta un pouco confusa para quen está a dar os primeiros pasos na programación co IDE de arduino (e para moitos que xa levan moito andado). O obxectivo deste artigo é facilitar os recursos para que o alumnado e o profesorado poidan programar a placa Auriga do mBot Ranger ao máis puro estilo arduino.

Hai moitas referencias de problemas co chip de comunicación CH340g que trae a placa Auriga que ven co Ranger. Pero para iso non temos alternativa, xa que é o chip de comunicacións que vén soldado na placa. A forma máis fácil de instalar o controlador é a que vos indicamos a continuación, usando o mesmo programa mBlock.

Pero se tes problemas, ou prefires probar a instalar a última versión, que nalgúns casos funciona mellor, unha boa idea para empezar é buscar na internet “driver CH340g” e o nome do voso sistema operativo. Podes atopar moitas páxinas como esta http://www.prometec.net/ch340g que poden ser de axuda. Por se tes tentacións de ir directamente á páxina do fabricante http://www.wch.cn/product/ch340.html, que sería o máis lóxico, adiantámosche que está exclusivamente en chinés.

Se prefires empezar polo máis fácil, abonda con que no programa mBlock seleccións no menú Conectar > Instalar Driver de arduino. É moi posible que as primeiras veces que te conectes teñas problemas que poden ir desde que o punteiro do rato quede conxelado por un tempo, ata que o computador se reinície bruscamente. É importante que te asegures de ter o teu traballo gardado antes de conectar o ordenador á placa. Máis adiante mellora un pouco. A verdade é que este driver non vai moi fino.

Debes ter en conta que cando abriches o Ranger por primeira vez, a placa Auriga trae cargado un programa que inclúe varias funcións para poder usala co mBlock, ou conectar por Bluetooth. Cando subas un novo programa desde o IDE de arduino ese programa substitúese polo que estás a subir, e perdes esas funcións. Sempre podes recuperar as funcións que viñan de fábrica volvendo cargar o programa orixinal no menú Conectar > Actualizar Firmware

O primeiro nun robot é lograr que se mova. A solución máis sinxela que se nos ocorre é usar a librería mobilerobot que é parte do conxunto de librerías para accionamiento de motores con arduino que podedes descargar en https://github.com/brico-labs/ArduinoDCmotorDrivers.

Para instalar esta librería e as outras que iremos necesitando o primeiro é descargala e descomprimirla. A librería que nos interesa é mobilerobot, e para instalala, o que tedes que facer é copiar o cartafol mobilerobot ao cartafol arduino>libraríes

Para comprobar se a librería está ben instalada podedes entrar no programa arduino, o IDE de arduino (se xa o tiñades aberto é necesario saír e volver entrar cada vez que instaledes novas librerías). Logo, no menú Arquivo > Exemplos > mobilerobot > mBotRanger_Arduino > mBotRanger_Arduino podedes abrir o exemplo para mBot.

Lembrade que se queredes modificar e gardar o exemplo deberedes gardar unha copia (Gardar como?).

No exemplo que temes a continuación poderes ver como se pode crear un obxecto do tipo Robot que sexa compatible co Ranger, e como usar as catro funciones que acabamos de incluír:

• fordward (velocidade_L, velocidade_R, tempo_avance): fai avanzar o mBot durante o tempo_avance indicado (en mili segundos) coas velocidades velocidade_L e velocidade_R nas rodas esquerda e dereita. O valor debe estar entre 0 e 255.
• reverse (velocidade_L, velocidade_R, tempo_avance): para que o Ranger retroceda. Os parámetros son os mesmos que na función anterior.
• rotate (tempo_xiro): O Ranger vira sobre se mesmo durante o tempo de xiro indicado (en mili segundos). Se tempo_xiro é positivo, o xiro é cara á dereita. Se é negativo cara á esquerda.
• brake (tempo_freo): Frea o robot durante o tempo indicado (en mili segundos)

Un exemplo de uso podería ser:

#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);
}

A mesma librería serve para controlar calquera robot que construades cun arduino e un driver dos tipos que se usan máis habitualmente para pequenos motores (L293, L298 e TB6612). No cartafol de exemplos da librería están os esquemas de como montar cada un deles e ligazóns a algúns proxectos abertos de robots.

O Ranger vén equipado cunha tarxeta chamada Auriga que inclúe varios sensores. Aos nosos efectos é como unha tarxeta arduino MEGA 2560. Os sensores están conectados con pines analóxicos do microprocesador, polo que se poden ler coa instrución analogRead (número_de_pin) http://www.arduino.org/learning/reference/analogread. O valor de saída variará entre 0 e 1023.

• Sensor de luz esquerdo… A3 analogRead(A3)
• Sensor de luz dereito……. A2 analogRead(A2)
• Sensor de temperatura…. A0 analogRead(A0)
• Sensor de son……………. A1 analogRead(A1).

Os sensores de luz dan un valor maior canto maior sexa a cantidade de luz que reciben, ainda que non se corresponden con ningunha unidade de medida de iluminación.

O sensor de temperatura é unha NTC (resistencia con coeficiente de temperatura negativa) que ten un comportamento exponencial. Sen entrar en máis detalles, a continuación redes un código de exemplo para ler o valor da temperatura. Se quereres facer algunha lectura, podedes copiar a fórmula que está dentro da sección loop.

Este e outros tipo de sensores de temperatura teñen un comportamento bo cando se trata de medir variacións de temperatura, pero poden darnos o valor con ata un par de graos de máis ou de menos que o valor real. Eso pode facer que varias placas den valores de temperatura distintos incluso nas mismas condicións.

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);
}

No sensor de son, a saída do micrófono integrado está conectada directamente á entrada analóxica A1, polo que mide o valor instantáneo da onda de son, e non a súa amplitude. Un bo truco para conseguir un valor proporcional á intensidade do ruído ambiente é realizar varias medidas seguidas e quedar co máximo. Neste exemplo tomamos 100 medidas, que parecen moitas, pero levan moi pouco tempo.

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);
}

No pin 45 temos un zumbador que responde perfectamente ás instrución tone http://www.arduino.org/learning/reference/tone e noTone http://www.arduino.org/learning/reference/notone

Un exemplo que seguro vos soará:

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() {}

A tarxeta de control do Auriga do mBot ten 5 portos dedicados á conexión co mundo exterior. Son os que están sinalados do 6 ao 10 e coas catro cores branco, amarelo, azul e gris escuro. Cada un dos portos ten alimentación a 5V e está conectado con dúas entradas analóxicas do arduino MEGA2560. Tamén permiten conectar dispositivos I2C. As entradas analóxicas de cada un dos portos son as seguintes:

• PORTO 06 A10 e A15
• PORTO 07 A9 e A14
• PORTO 08 A8 e A13
• PORTO 09 A7 e A12
• PORTO 10 A6 e A11

Ten dúas barreiras ópticas reflexivas para detectar se o chan é branco ou negro. A saída é dixital (todo ou nada), xa que teñen un comparador e un indicador luminoso para cada canle. Cando se reflicte a luz no chan (zona branca ou clara) o indicador azul xunto ao sensor acéndese e a saída pasa a nivel alto. Cando non se reflicte a luz (o chan está lonxe) ou o chan é suficientemente escuro (estamos sobre a liña negra), o indicador apágase e a saída pasa a nivel baixo. Non podemos axustar a sensibilidade.

O valor de saída pódese ler coa instrución digitalRead (número_de_pin) http://www.arduino.org/learning/reference/digitalread.

Por exemplo, se o sensor está conectado no PORTO 09:

• Valor do sensor esquerdo .. digitalRead(A7)
• Valor do sensor dereito ….. digitalRead(A12)

Este é o código para un segue-líñas básico:

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

Para este sensor o máis conveniente é usar a librería NewPing que podemos descargar en https://bitbucket.org/teckel12/arduino-new-ping/downloads/. Desta forma poderemos usar a mesma librería nos arduinos co moi popular e barato sensor de ultrasonidos SR04. Temos unha completa explicación do uso desta librería en http://playground.arduino.cc/Code/NewPing

Unha vez instalada podemos ver un exemplo de como funciona en Arquivo>Exemplos>NewPing>NewPingExample No exemplo temos que substituír os valores TRIGGER_PIN e ECHO_PIN, en función do PORTO no que teñamos enchufado o sensor. No noso caso TRIGGER_PIN e ECHO_PIN sempre serán iguais. Por exemplo, se o sensor está conectado no PORTO 10:

#define TRIGGER_PIN A11

#define ECHO_PIN A11

Pendente:

Para moitos de nós o primeiro programa que fixemos en arduino é o blink que está en Arquivo > Exemplos > 01.Basics>Blink. Ademais de ser o equivalente ao “Hello World”, e a forma de comprobar que todo vai ben ata aquí. Na tarxeta Auriga do Ranger, o led soldado na placa (o led “ON BOARD”) está conectado no pin 13, como no Arduino UNO. Pero a montaxe da placa fai que quede oculto. Por desgraza non temos ningún outro LED na placa que sexa igual de fácil de manexar para comprobar que todo vai ben.

O círculo de luces que ten a placa Auriga do Ranger está formado por un tipo de LED un tanto especial: os NEOPIXEL. Para manexalos tamén hai unha librería, neste caso de Adafruit: https://learn.adafruit.com/adafruit-neopixel-uberguide/arduino-library.

No noso caso temos un anel formado por 12 Neopixel que están conectados ao pin 44. Para que o exemplo funcione co Ranger debemos poñer estes valores:

#define PIN 44

#define NUMPIXELS 12

Con este exemplo podemos conseguir un efecto parecido ao do programa de exemplo Blink, xa que un dos LED parpadeará unha vez por segundo:

#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);
}

Debedes ter en conta que o anel de Neopixels está moi preto dos sensores de luz, polo que interfiren moito con eles cando algún LED está aceso.