====== mBot Ranger co IDE de arduino ======

{{  :guias:mbot:mbot_ranger.jpg?400  |mbot_ranger.jpg}}

**traballo en progreso**
====== mBot Ranger co IDE de arduino ======

O mBot Ranger conta cunha completa librería de funcións ([[https://github.com/Makeblock-official/Makeblock-Libraries/archive/master.zip|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.

===== Instalación do Driver de comunicación co computador =====

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




====== A primeira librería ======

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

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

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.

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

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


====== Movémonos ======

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:

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


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.

======   ======
====== Explorando o mundo ======

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

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


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.

<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>
====== Facendo ruído ======

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

Un exemplo que seguro vos soará:

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

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

====== Sensor SEGUE-LINEAS ======

{{  :guias:mbot:sigue_lineas.png?100}} 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|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:  

<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 ULTRASONS ======

{{  :guias:mbot:ultrasonidos.png?100}} Para este sensor o máis conveniente é usar a librería NewPing que podemos descargar en [[https://bitbucket.org/teckel12/arduino-new-ping/downloads/|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|http://playground.arduino.cc/Code/NewPing]]

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

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**
====== Luces ======

Pendente:

==== O LED do blink está demasiado escondido ====

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.

==== Fagamos un blink cos Neopixel ====

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

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

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.