Bricolabs Wiki

Esta páxina é só de lectura. Podes ver o código fonte, mais non podes mudala. Coméntallo ao teu administrador se consideras que é un erro.
====== 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.
Bricolabs Wiki

Ferramentas de usuario

Ferramentas do sitio

Ferramentas de páxina
