Me Auriga -Makeblock & Ide Arduíno.

Esta entrada supone que ya tiene experiencia con Makeblock y lo que se pretende es controlar la placa Me Auriga y sus dispositivos con el Ide de Arduíno.

Cuando empecé con la robótica doméstica, lo primero que hice fue comprar un Mbot Ranger de Makeblock. En mi opinión es una buena plataforma para iniciarte, pero una vez montas tu vehiculo robot y juegas un poco, ves que realmente no sabes nada, Durante años arrinconé el robot y me dedique a investigar la base del conocimiento de este mundo. Ahora que empecé con el código, me acordé de la antigua placa Me Auriga y creo que se le puede sacar algun partido si nos olvidamos de la programación por bloques y la metemos dentro del ide Arduíno.

Los pasos que estoy siguiendo los expongo aqui conforme pruebo los sketch y veo que funcionan.

Primera tarea: compatibilizar la placa con el entorno Ide arduíno.

Encontre las librerias oficiales de Makeblock en Github:

https://github.com/Makeblock-official/Makeblock-Libraries/archive/master.zip

Conecté la placa con el <Ide> y elegí “arduino Mega 2560” como avr board.

Ademas de estas librerias oficiales también encontré aquí una libreria sencilla para los encoders:

https://bricolabs.cc/wiki/guias/mbot_con_ide_arduino

Entradas analógicas y digitales de la placa Me Auriga:

ANALÓGICASDIGITALES
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).
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		PUERTO 1 D4 Y D5( D4 DEFault pin tone)rojo
PUERTO 2 D2 Y D3
PUERTO 3 D6 Y D7
PUERTO 4 D8 Y D9
PUERTO 5 D16 Y D17(SERIAL 2)
BUZZER ………D45
RGB LED………D44
BLINK LED…..D13

PINEADO DE MOTORES CON ENCODER Y PUENTE H(L293D)

SKETCHS PROBADOS

Onboard LedRing (PIN D44)

He utilizado la librería oficial de Makeblocks para comprobar como el anillo de leds de abordo funciona.El pin digital fijo que utiliza es el numero 44. La luminosidad la he puesto con un valor de 25, suficiente para que no moleste.

//Basado en la librería oficial de Makeblocks
 
 #include <MeAuriga.h>

#define numleds  12
#define all_leds  0

MeRGBLed led_ring( 0, 12 );



void setup()
{
    
led_ring.setpin( 44 );

}

void loop()
{
  int i=25;

    //RED
      led_ring.setColor( 0, i, 0, 0 ) ;
      led_ring.show();
      delay( 1000 );
  
      //GREEN 
      led_ring.setColor( 0, 0, i, 0 );
      led_ring.show();
      delay( 1000);
  
      //BLUE
      led_ring.setColor( 0, 0, 0, i );
      led_ring.show();
      delay( 1000 );
  
    // all LEDs off
    led_ring.setColor( 0, 0, 0, 0 );
    led_ring.show();
    delay( 500 );
        
    for ( i = 1; i <= numleds; i++ )
    {
        // Turn on  LEDs one at a time IN YELOOW
        led_ring.setColor( i, 25, 25, 0);
        led_ring.show();
        delay( 200 );
    }
   
}

Ahora utilizaré la librería <Adafruit_NeoPixel.h> 

#include <Adafruit_NeoPixel.h>

#define PIN        44 
#define numleds 12 

Adafruit_NeoPixel pixels(numleds, PIN, NEO_GRB + NEO_KHZ800);


void setup() {
 
  pixels.begin();
}

void loop() {
  pixels.clear(); // Set all pixel colors to 'off'

  
  for(int i=0; i<numleds; i++) { 
    
    pixels.setPixelColor(i, pixels.Color(0, 25,0));

    pixels.show();  
    delay(100);
  }
 
  for(int i=numleds; i>0; i--) {
    pixels.setPixelColor(i, pixels.Color(25, 25,0));

    pixels.show();  
    delay(100); 
  }
}

LEDMATRIX

La Matriz de LED Me contiene 128 piezas de LED de matriz, hay 8 piezas por línea y 16 por fila. La placa principal envía los datos al módulo a través del bus I2C, y el chip específico del control LED en el módulo puede manejar los datos e interpretarlos. Y salida de señal relativa para encender o apagar el LED. Haz que muestren el contenido.

Con LedMx(PORT_ elejimos el puerto donde lo vaamos a conectar)

He probado con ledMx.showNum(xxxx),leer el pin digital 5 : (digitalRead(5))

#include "MeAuriga.h"

MeLEDMatrix ledMx(PORT_6);

void setup()
{
  pinMode(5,INPUT);
  ledMx.setBrightness(4);
  ledMx.setColorIndex(1);
}

char *s = "ABC";

void loop()
{
  //ledMx.showClock(12,03,1);
  //delay(2000);
  //ledMx.drawStr(0,7,s);
  //delay(2000);
  ledMx.showNum(digitalRead(5));
  delay(200);
}

Me Compass

El módulo Me Compass puede detectar la intensidad del campo magnético circundante y hacer que el dispositivo o equipo en movimiento gire en la dirección especificada. Por ejemplo, cuando está montado en un vehiculo, se puede controlar para que gire o camine en la dirección especificada. 

#include "MeAuriga.h"
#include <Wire.h>

MeCompass Compass(PORT_7);

void setup()
{
  Serial.begin(9600);
  Serial.println("Initializing I2C devices...");
  Compass.begin();
  Serial.println("Testing device connections...");
  Serial.println(Compass.testConnection() ? "HMC5883L connection successful" : "HMC5883L connection failed");
}

void loop()
{
  int16_t head_X, head_Y, head_Z;
  double angle_number = 0;
  
  head_X = Compass.getHeadingX();
  head_Y = Compass.getHeadingY();
  head_Z = Compass.getHeadingZ();

  angle_number = Compass.getAngle();
  Serial.println(angle_number, 1);
  delay(500);
}

Combinación Me compass y temperatura imprimiendo en LedMatrix

#include "MeAuriga.h"
#include <Wire.h>

int PIN_temperatura = A0;
float temperatura;

MeCompass Compass(PORT_7);
MeLEDMatrix ledMx(PORT_6);

void setup()
{
    Compass.begin();
    ledMx.setBrightness(4);
  ledMx.setColorIndex(1);
  }

void loop()
{
  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;
  int16_t head_X, head_Y, head_Z;
  double angle_number = 0;
  
  head_X = Compass.getHeadingX();
  head_Y = Compass.getHeadingY();
  head_Z = Compass.getHeadingZ();

  angle_number = Compass.getAngle();
   ledMx.showNum(angle_number, 0);
    delay(1000);
     ledMx.showNum(temperatura);
     delay(1000);
}

Me Potenciometro

Con un rango ajustable con la resistencia de 10 KΩ, el módulo de potenciómetro Me es una resistencia con tres terminales, y su resistencia se puede ajustar girando la perilla. 

#include "MeAuriga.h"

MePotentiometer pot(PORT_8);


void setup()
{
  Serial.begin(9600);
}

void loop()
{
  Serial.print("value=");
  Serial.println(pot.read() );
  delay(100);
}

Control Makeblock Encoder Motor 180 Óptico

Aunque es muy interesante el uso de la librería oficial de Makeblock, por el momento, utilizaré la de Bricolabs <RobotMovil.h> dada su sencillez y buenos resultados.

“RobotMovil robot (46,47,10,49,48,11)” indican los pines internos de control del motor izquiedo M2 y M1.

Así primero sería para M2 los pines de control de giro 46 y 47 y para M1 el 49 y 48.

EL pin 10 corresponde al PWM que controla la velocidad de M2 y el pin 11 el PWm de M1

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

ejemplo:

#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);
}
#include <RobotMovil.h>
RobotMovil robot;

void setup()
{
}

void loop()
{
  robot.forward(120,120,1000); // avance con velocidad rueda derecha, rueda izquierda y tiempo en ms
  robot.reverse(120,120,1000); // idem pero retroceso
  robot.rotate(1000); // giro durante un tiempo en ms, valores negativo o positivos indican sentido de giro
  robot.brake(100000); // detiene el robot un tiempo
}

Comunicación Serie

Para comunicar la placa Me con otros dispositivos disponemos del puerto 5 que esta conectado con Serial2 (Tx2/Rx2), pero si no vamos a utilizar el módulo BT LE, disponemos del puerto TX0/RX0, con una limitación, solo podríamos utilizar la TX0 ya que el RX0 se comparte con USB para cargar los sketchs y el firmware.Por ejemplo,podriamos conextar la TX0 con un arduino Nano que tuviera el firmware GRBL y asi enviarles comandos jogging $J=()

Placa Me Auriga con el módulo BT LE desmontado, acceso al Serial 0

Voy a conectar al puerto 5 de comunicaciones un módulo HC_08 configurado como esclavo a 115200 BD a traves de un cable Dupont (rj25) del que solo se utilizan cuatro delos 6 hilos qu dispone

Conexión dupont con 4 hilos; con TX2-RX2-GND-+5v

El módulo HC-08 configurado como master ira conectado a un arduíno Nano que hará de control remoto para probar, por ejemplo, el movimiento del Ranger

Si no se quiere utilizar el Bluetooth, quitaremos el modulo y tendremos los cuatro hilos listos para conectar con otro puerto serie directamente.

Independientemente del código utilizado ,en el void setup() del sketch del arduino Nano, tendremos que incluir las ordenes de emparejamiento:

#include <SoftwareSerial.h>

SoftwareSerial hc_8(3,2);

void setup()
{
 
  hc_8.begin(115200);

  hc_8.println(String("AT+RESET"));
  delay(1000);
  hc_8.println(String("AT"));
  delay(1000);
  hc_8.println(String("AT+INQ"));
  delay(1000);
  hc_8.println(String("AT+CONN1"));
  delay(1000);

}

De esta forma se emprejarán con seguridad y estarán listos para intercomunicarse.

Activar o desactivar un ventilador desde un puerto analógico

Podemos poner en marcha o apagar el pequeño motor que viene con el set del mbot ranger, marcado para conectar como sensor analógico Ax simplemente expresando en el sketch :

pinMode(Ax,OUTPUT);// PAA ACTIVARLO
pinMode(Ax,INPUT); //PARA DESACTIVARLO
Siendo Ax la entrada analógica asociada al uerto de conexión J6 a J10

Valdria para cualquier pequeño otor de 5V.

Probando el Sensor de Sonido onboard A1

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.

void setup() 
{

  Serial.begin (9600);
}
 
void loop() {
  Serial.print("Intensidad de sonido: ");
  Serial.println(analogRead (A1));
 delay (500);
    
}

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.

int PIN_sonido = A1;
int intensidad_sonido;
int i;

 
void setup() 
{

  Serial.begin (9600);
}
 
void loop() {
  intensidad_sonido = 0;
 
 
  for (int i=0; i<100; i++){

  
  intensidad_sonido = max (intensidad_sonido , analogRead (PIN_sonido));

  }
  Serial.print ("Intensidad de sonido: ");
  Serial.println (intensidad_sonido);
 
  delay (500);
}

Generando audio:

En el pin 45 tenemos un zumbador o Buzzer que responde perfectamente a las instrucción tone–

AVISO: <MeAuriga.h> no es compatibles con la función tone()

Control de Stepper Motor con Auriga Me y la función Tone():

En esta entrada expongo un Sketch en el que utilizado los pines digitales 4 y 5 correspondientes al puerto 1 y el pin 2 del puerto 2. El driver tmc2209 esta alimentado con 8V de la batería y 5 V de la msma placa.

Función Tone() y motores paso a paso

Sensor de Ultrasonidos SR04

Utilizando la librería oficial de makeblock vamos a utilizar la función “ultraSensor.distanceCm()” para medir la distancia en cm desde el sensor hasta el objeto enfrentado. Dada esta función ya podemos hacer distintas combinaciones con los encoders y servos ante diferentes situaciones.

#include "MeAuriga.h"

MeUltrasonicSensor ultraSensor(PORT_10);

void setup()
{
  Serial.begin(9600);
}

void loop()
{
  Serial.print("Distance : ");
  Serial.print(ultraSensor.distanceCm() );
  Serial.println(" cm");
  delay(100); /* the minimal measure interval is 100 milliseconds */
}

Utilizando la librería NewPing que podemos descargar en https://bitbucket.org/teckel12/arduino-new-ping/downloads

Adaptándola a nuestra placa Auriga, los pines digitales son sustituidos por una misma entrada Ax asociadas a TRIGGER_PIN y ECHO_PIN. Según mis pruebas, Ax esta ligada a cada S2 de los puertos 6 al 10.

Si elegimos el puerto 6, tiene conectados las entradas A10 y A15, pues la que se conecta al sensor de ultrasonidos es A15, luego:

#define TRIGGER_PIN A15

#define ECHO_PIN A15
#include <NewPing.h>
 
#define TRIGGER_PIN  A15
#define ECHO_PIN     A15
#define MAX_DISTANCE 100
 
NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);
 
void setup() {
  Serial.begin(9600);
}
 
void loop() {
  delay(250);
  Serial.print("Ping: ");
  Serial.print(sonar.ping_cm());
  Serial.println("cm");
}

Después de probar ambas librerías , he comprobado que amas librerias no miden distancias inferiores a 2 cm.Sin embargo con la librería “Newping”, compruebo que marca 0 cm en acercamientos inferiores a 2 cm, lo que no ocurre con la librería oficial, midiendo de forma errónea.

AVISO: La libreria < newPing.h> y <MeAuriga.h> no son compatibles y generarán error de compilación.

Adaptador RJ25

El adaptador RJ25 dispone de dos slot con entradas/salidas analógicas S1 y S2 que en cada puerto del 6 al 10 corresponden desde A6 hasta A15. Con la libreria <MeAuriga,h>, no hace falta recordar estas entradas, con la función output.dWrite y input.dRead conseguiremos que S1/S2 pasen a nivel H/L o lean valores analógicos.

En este sencillo SKetch primero declaramos el puerto donde vamos a enchufar el adaptador , y ponemos S1 a nivel H con output.dWrite1(HIGH), y leeremos valores analógicos en S2 con input.dRead2(). Haciendo un puente entre S1 y S2 veremos en nuestro monitor serie el valor 1/0 .

#include "MeAuriga.h"

MePort output(PORT_9);


MePort input(PORT_9);


int val;
void setup()
{
  Serial.begin(9600);
}

void loop()
{
  output.dWrite1(HIGH);   /* S1 GO high
  delay(500);
 

  val = input.dRead2();   /* read S2 */
  Serial.print("val=");
  Serial.println(val);
}

Servos

Ejemplo del uso de tres servos en dos puertos y dos adaptadores 

//Parts required:Me RJ25 Adapter and two servo   
//Me RJ25 Adapter SLOT1 connect servo1,SLOT2 connect servo2,
//The Me RJ25 Adapter module can connect to the port with yellow tag (PORT_3 to PROT_8). 

MePort port10(PORT_10);
MePort port9(PORT_9);
Servo myservo1;  // create servo object to control a servo 
Servo myservo2;  // create servo object to control another servo
Servo myservo3;
int16_t servo1pin =  port10.pin1();//attaches the servo on PORT_3 SLOT1 to the servo object
int16_t servo2pin =  port10.pin2();//attaches the servo on PORT_3 SLOT2 to the servo object
int16_t servo3pin =  port9.pin1();
void setup() 
{ 
  myservo1.attach(servo1pin);  // attaches the servo on servopin1
  myservo2.attach(servo2pin);  // attaches the servo on servopin2
  myservo3.attach(servo3pin);
} 

void loop() 
{ 
  myservo1.write(90);                  // sets the servo position according to the scaled value 
  
  myservo2.write(45);
  myservo3.write(45);
  
}

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

➤
Translate »