Romeo: una placa de control Arduino para robótica con Driver incluidos

Que tal amigos, siguiendo con la revisiones de placas y sensores, con el aporte de la empresa DFRobot, hoy veremos una placa con prestaciones muy interesante, y es ideal para el desarrollo de prototipos robóticos y el control de motores y servos, de una manera simple de conectar, porque la placa posee los driver para el control y potencia de estos.

¿Que es Arduino Romeo?

La familia Romeo es un placa de control de robotica Todo-En-Uno, especialmente diseñado para aplicaciones de robótica de DFRobot. Se beneficia de la plataforma de código abierto Arduino , es compatible con miles de códigos y puede ampliarse fácilmente con los escudos de Arduino. El controlador del motor CC de 2 vías integrado y el zócalo inalámbrico le permiten iniciar su propio proyecto de robotica inmediatamente sin la necesidad de un driver de motor adicional. No solo tiene el controlador del motor, Romeo también está diseñado para tener potencia extra para los servos que necesitan más corriente.

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 muchos videos con código fuentes completos y diagramas

Romeo también se presenta con el estándar 3 Pin-out de DFRobot diseñado y compatible con los sensores y actuadores de la serie Gravity . Cientos de sensores ahora son plug-play con Romeo.

El primer miembro de la familia Romeo nació en 2009. No es solo el primer controlador de robot Arduino, sino también el primer tablero derivado de Arduino en el mercado. La versión actual de Romeo se basa en Arduino Uno. Ha incorporado 2 controladores de motor CC de 2 Amperes y zócalo para módulos de comunicación por radio Bluetooth /APC220 . El pin integrado del sensor entrada/salida le permite conectar cientos de diferentes sensores y módulos compatibles con Gravity .Tiene un conector servo que es un plug & play. Es el controlador ideal para construir su propio robot .

ESPECIFICACIONES

Suministro de CC: alimentado por USB o externo de 7V ~ 12V DC
Salida de CC: 5V / 3.3V DC y salida de potencia externa
Microcontrolador: Atmega328
Cargador de arranque: Arduino Uno
Compatible con el mapeo de pin Arduino Uno
8 canales de E/S analógicas de 10 bits
interfaz USB
5 teclas de entradas
Detección automática / entrada de potencia de conmutación
Encabezado ICSP para la descarga directa del programa
Serial Interface TTL Level
Soporte de encabezado macho y hembra
Sockets integrados para el módulo RF APC220 y el módulo DF-Bluetooth
Tres juegos de patillas de interfaz I2C (dos cabezales de patillas de 90 °)
Driver de motor de dos vías con corriente máxima 2A
Placa enchapado en oro
Tamaño: 90x80x14mm (3,54 “x3.15” x0.55 “)
Peso: 60 gramos

RoMeo Pinout

La imagen de arriba muestra todas las líneas y conectores de E / S en el Romeo, que incluye:

Un terminal de entrada de potencia de motor regulado (6v a 12v)
Un Terminal de entrada de alimentación servo no regulada (se suministra regulada de 4 v a 7.2 v)
Un puente de selección de potencia de entrada Servo
Un encabezado de módulo de interfaz serie para el módulo APC220 / Bluetooth
Dos terminales de motor CC: maneja la corriente del motor hasta 2A, en cada terminal
Un puerto I2C / TWI – SDA, SCL, 5V, GND
Un puerto analógico con 8 entradas analógicas – La entrada analógica 7 estará ocupada al conectar al puente “A7”
Un puerto I / O de propósito general con 13 líneas de E / S – 4,5,6,7 se puede usar para controlar motores
Un botón de reinicio
Jumper para habilitar / deshabilitar el control del motor

Antes de empezar

Aplicando potencia

Este es uno de los pasos más importantes antes de usarl Romeo y comunicarse con su controlador host. DEBE asegurarse de que aplique energía al terminal de alimentación con la polaridad correcta. La polaridad invertida dañará al Romeo.

Energía desde el puerto USB: simplemente conecte el cable USB, y Romeo puede funcionar. Tenga en cuenta que el USB solo puede suministrar corriente de 500 mA. Debería ser capaz de cumplir con la mayoría de los requisitos para la aplicación de iluminación LED. Sin embargo, no es suficiente para alimentar motores de CC o servo.

Alimentación de la entrada de potencia del motor: Simplemente conecte el cable de tierra a la bornera con la etiqueta “GND”, y luego conecte el cable positivo a la bornera con la etiqueta “VIN”.

NOTA: la tensión de alimentación máxima no puede exceder 14V CC.

Software

RoMeo puede ser programado por el IDE de Arduino. Se puede descargar en Arduino.cc , seleccione “Arduino UNO” como hardware.

Servo Power Select Jumper

Como la mayoría de los servos utilizan más corriente que la fuente de alimentación USB puede suministrar. Se proporciona un terminal de alimentación para alimentar el servo individualmente. Esta opción puede habilitarse / deshabilitarse mediante el puente de selección Servo Power.

Cuando se aplica el Servo Power Select Jumper, el servo funciona con 5V internos.

Cuando el Servo Power Select Jumper no se aplica, el servo está alimentado por una fuente de alimentación externa.

El Romeo V1.3 utiliza un conmutador automático para la selección de la fuente de alimentación. Cuando se haya aplicado la fuente de alimentación externa, el servo se alimentará automáticamente mediante la alimentación externa en lugar de la energía del USB.

Jumper Pin de control del motor

La aplicación de los jumper de control del motor asignará el Pin 5,6,7,8 para el control del motor.

Al quitar los puentes se liberarán los pines anteriores, y el controlador del motor se desactivará.

Botones

RoMeo tiene 5 botones S1-S5 (Figura 2). S1-S5 usa la entrada analógica del pin 7,

“Mapa del Pin del botón”
Alfiler	Función
Pin analógico 7	Botón S1-S5

Fig2: botones de Romeo

Ejemplo de uso de botones 1-5

//

char msgs[5][15] = {
  "Right Key OK ", 
  "Up Key OK    ", 
  "Down Key OK  ", 
  "Left Key OK  ", 
  "Select Key OK" };
char start_msg[15] = {
  "Start loop "};                    
int  adc_key_val[5] ={
  30, 150, 360, 535, 760 };
int NUM_KEYS = 5;
int adc_key_in;
int key=-1;
int oldkey=-1;
void setup() { 
  pinMode(13, OUTPUT);  //we'll use the debug LED to output a heartbeat
  Serial.begin(9600);

  /* Print that we made it here */
  Serial.println(start_msg); 
}

void loop() 
{
  adc_key_in = analogRead(7);    // read the value from the sensor  
  digitalWrite(13, HIGH);
  /* get the key */
  key = get_key(adc_key_in);    // convert into key press
  if (key != oldkey) {   // if keypress is detected
    delay(50);      // wait for debounce time
    adc_key_in = analogRead(7);    // read the value from the sensor  
    key = get_key(adc_key_in);    // convert into key press
    if (key != oldkey) {         
      oldkey = key;
      if (key >=0){
        Serial.println(adc_key_in, DEC);
        Serial.println(msgs[key]);
      }
    }
  }
  digitalWrite(13, LOW);
}
// Convert ADC value to key number
int get_key(unsigned int input)
{   
  int k;
  for (k = 0; k < NUM_KEYS; k++)
  {
    if (input < adc_key_val[k])
    {  
      return k;  
    }
  }
  if (k >= NUM_KEYS)
    k = -1;     // No valid key pressed
  return k;
}

char msgs[5][15] = {

"Right Key OK ",

"Up Key OK ",

"Down Key OK ",

"Left Key OK ",

"Select Key OK" };

char start_msg[15] = {

"Start loop "};

int adc_key_val[5] ={

30, 150, 360, 535, 760 };

int NUM_KEYS = 5;

int adc_key_in;

int key=-1;

int oldkey=-1;

void setup() {

pinMode(13, OUTPUT); //we'll use the debug LED to output a heartbeat

Serial.begin(9600);

/* Print that we made it here */

Serial.println(start_msg);

}

void loop()

{

adc_key_in = analogRead(7); // read the value from the sensor

digitalWrite(13, HIGH);

/* get the key */

key = get_key(adc_key_in); // convert into key press

if (key != oldkey) { // if keypress is detected

delay(50); // wait for debounce time

adc_key_in = analogRead(7); // read the value from the sensor

key = get_key(adc_key_in); // convert into key press

if (key != oldkey) {

oldkey = key;

if (key >=0){

Serial.println(adc_key_in, DEC);

Serial.println(msgs[key]);

}

digitalWrite(13, LOW);

}

// Convert ADC value to key number

int get_key(unsigned int input)

{

int k;

for (k = 0; k < NUM_KEYS; k++)

{

if (input < adc_key_val[k])

{

return k;

}

if (k >= NUM_KEYS)

k = -1; // No valid key pressed

return k;

}

Control de velocidad de motor doble de CC

Configuración de hardware

Conecte los cuatro cables del motor al terminal del motor de Romeo. Y aplique energía a través del terminal de potencia del motor (Figura 4).

Fig4: Diagrama de conexión de motor de Romeo

Asignación de pines

“Modo PWM”
PIN	Función
Digital 4	Motor 1 Control de dirección
Digital 5	Motor 1 control PWM
Digital 6	Motor 2 PWM control
Digital 7	Motor 2 Control de dirección

“Modo PLL”
Pin	Función
Digital 4	Motor 1 Habilitar control
Digital 5	Motor 1 Control de dirección
Digital 6	Motor 2 Control de dirección
Digital 7	Motor 2 Habilitar control

Modo de control PWM

Fig4: Asignación de clavijas de control del motor PWM

El control del motor PWM CC se implementa mediante la manipulación de dos pines E/S digitales y dos pines PWM. Como se ilustra en el diagrama de arriba (Figura 5), el Pin 4,7 (7,8 para la versión antigua de Romeo) son pasadores de control de la dirección del motor, Pin 5,6 (6,9 para la versión antigua de Romeo) son pasadores de control de velocidad del motor.

Para la placa Romeo anterior, los pines utilizados para controlar el motor son Pin 7,8 (Dirección), Pin 6,9 (Velocidad). Puede encontrar la información en el lado derecho de los puentes de control del motor.

Código de ejemplo:

//Standard PWM DC control
int E1 = 5;     //M1 Speed Control
int E2 = 6;     //M2 Speed Control
int M1 = 4;    //M1 Direction Control
int M2 = 7;    //M1 Direction Control

///For previous Romeo, please use these pins.
//int E1 = 6;     //M1 Speed Control
//int E2 = 9;     //M2 Speed Control
//int M1 = 7;    //M1 Direction Control
//int M2 = 8;    //M1 Direction Control


void stop(void)                    //Stop
{
  digitalWrite(E1,LOW);   
  digitalWrite(E2,LOW);      
}   
void advance(char a,char b)          //Move forward
{
  analogWrite (E1,a);      //PWM Speed Control
  digitalWrite(M1,HIGH);    
  analogWrite (E2,b);    
  digitalWrite(M2,HIGH);
}  
void back_off (char a,char b)          //Move backward
{
  analogWrite (E1,a);
  digitalWrite(M1,LOW);   
  analogWrite (E2,b);    
  digitalWrite(M2,LOW);
}
void turn_L (char a,char b)             //Turn Left
{
  analogWrite (E1,a);
  digitalWrite(M1,LOW);    
  analogWrite (E2,b);    
  digitalWrite(M2,HIGH);
}
void turn_R (char a,char b)             //Turn Right
{
  analogWrite (E1,a);
  digitalWrite(M1,HIGH);    
  analogWrite (E2,b);    
  digitalWrite(M2,LOW);
}
void setup(void) 
{ 
  int i;
  for(i=4;i<=7;i++)
    pinMode(i, OUTPUT);  
  Serial.begin(19200);      //Set Baud Rate
  Serial.println("Run keyboard control");
} 
void loop(void) 
{
  if(Serial.available()){
    char val = Serial.read();
    if(val != -1)
    {
      switch(val)
      {
      case 'w'://Move Forward
        advance (255,255);   //move forward in max speed
        break;
      case 's'://Move Backward
        back_off (255,255);   //move back in max speed
        break;
      case 'a'://Turn Left
        turn_L (100,100);
        break;       
      case 'd'://Turn Right
        turn_R (100,100);
        break;
      case 'z':
        Serial.println("Hello");
        break;
      case 'x':
        stop();
        break;
      }
    }
    else stop();  
  }
}

//Standard PWM DC control

int E1 = 5; //M1 Speed Control

int E2 = 6; //M2 Speed Control

int M1 = 4; //M1 Direction Control

int M2 = 7; //M1 Direction Control

///For previous Romeo, please use these pins.

//int E1 = 6; //M1 Speed Control

//int E2 = 9; //M2 Speed Control

//int M1 = 7; //M1 Direction Control

//int M2 = 8; //M1 Direction Control

void stop(void) //Stop

{

digitalWrite(E1,LOW);

digitalWrite(E2,LOW);

}

void advance(char a,char b) //Move forward

{

analogWrite (E1,a); //PWM Speed Control

digitalWrite(M1,HIGH);

analogWrite (E2,b);

digitalWrite(M2,HIGH);

}

void back_off (char a,char b) //Move backward

{

analogWrite (E1,a);

digitalWrite(M1,LOW);

analogWrite (E2,b);

digitalWrite(M2,LOW);

}

void turn_L (char a,char b) //Turn Left

{

analogWrite (E1,a);

digitalWrite(M1,LOW);

analogWrite (E2,b);

digitalWrite(M2,HIGH);

}

void turn_R (char a,char b) //Turn Right

{

analogWrite (E1,a);

digitalWrite(M1,HIGH);

analogWrite (E2,b);

digitalWrite(M2,LOW);

}

void setup(void)

{

int i;

for(i=4;i<=7;i++)

pinMode(i, OUTPUT);

Serial.begin(19200); //Set Baud Rate

Serial.println("Run keyboard control");

}

void loop(void)

{

if(Serial.available()){

char val = Serial.read();

if(val != -1)

{

switch(val)

{

case 'w'://Move Forward

advance (255,255); //move forward in max speed

break;

case 's'://Move Backward

back_off (255,255); //move back in max speed

break;

case 'a'://Turn Left

turn_L (100,100);

break;

case 'd'://Turn Right

turn_R (100,100);

break;

case 'z':

Serial.println("Hello");

break;

case 'x':

stop();

break;

}

else stop();

}

Modo de control PLL

Romeo también es compatible con oscilador enganchado en fase (PLL)

Fig5: Configuración de asignación de patillas de control del motor PLL

Código de muestra:

//Standard DLL Speed control

int E1 = 4;     //M1 Speed Control
int E2 = 7;     //M2 Speed Control
int M1 = 5;    //M1 Direction Control
int M2 = 6;    //M1 Direction Control

///For previous Romeo, please use these pins.
//int E1 = 6;     //M1 Speed Control
//int E2 = 9;     //M2 Speed Control
//int M1 = 7;    //M1 Direction Control
//int M2 = 8;    //M1 Direction Control

//When m1p/m2p is 127, it stops the motor
//when m1p/m2p is 255, it gives the maximum speed for one direction
//When m1p/m2p is 0, it gives the maximum speed for reverse direction

void DriveMotorP(byte m1p, byte m2p)//Drive Motor Power Mode
{

  digitalWrite(E1, HIGH);
  analogWrite(M1, (m1p)); 

  digitalWrite(E2, HIGH);
  analogWrite(M2, (m2p)); 

}

void setup(void) 
{ 
  int i;
  for(i=6;i<=9;i++)
    pinMode(i, OUTPUT);  
  Serial.begin(19200);      //Set Baud Rate
} 
void loop(void) 
{ 
  if(Serial.available()){
    char val = Serial.read();
    if(val!=-1)
    {
      switch(val)
      {
      case 'w'://Move Forward
        DriveMotorP(0xff,0xff); // Max speed
        break;
      case 'x'://Move Backward
        DriveMotorP(0x00,0x00);
        ; // Max speed
        break;
      case 's'://Stop
        DriveMotorP(0x7f,0x7f);
        break;       

      }
    }
  }
}

//Standard DLL Speed control

int E1 = 4; //M1 Speed Control

int E2 = 7; //M2 Speed Control

int M1 = 5; //M1 Direction Control

int M2 = 6; //M1 Direction Control

///For previous Romeo, please use these pins.

//int E1 = 6; //M1 Speed Control

//int E2 = 9; //M2 Speed Control

//int M1 = 7; //M1 Direction Control

//int M2 = 8; //M1 Direction Control

//When m1p/m2p is 127, it stops the motor

//when m1p/m2p is 255, it gives the maximum speed for one direction

//When m1p/m2p is 0, it gives the maximum speed for reverse direction

void DriveMotorP(byte m1p, byte m2p)//Drive Motor Power Mode

{

digitalWrite(E1, HIGH);

analogWrite(M1, (m1p));

digitalWrite(E2, HIGH);

analogWrite(M2, (m2p));

}

void setup(void)

{

int i;

for(i=6;i<=9;i++)

pinMode(i, OUTPUT);

Serial.begin(19200); //Set Baud Rate

}

void loop(void)

{

if(Serial.available()){

char val = Serial.read();

if(val!=-1)

{

switch(val)

{

case 'w'://Move Forward

DriveMotorP(0xff,0xff); // Max speed

break;

case 'x'://Move Backward

DriveMotorP(0x00,0x00);

; // Max speed

break;

case 's'://Stop

DriveMotorP(0x7f,0x7f);

break;

}

Robot seguidor de luz con Arduino Romeo

Para poder realizar el robot seguidor de luz vamos a nececitar de los siguientes materiales

2 Fotoresistencias LDR

2 caños de pvc cortados 45 grados

2 resistores de 1 K

2 motoreductores

1 Arduino Romeo

Cables varios

1 Batería de 9 voltios

1 Table para el armazón del robot

Código Fuente

//Variables
int analogo0 = A0;
int analogo1 = A1;
int val0;//variable para leer el valor del pin analógico
int val1;//variable para leer el valor del pin analógico
int E1 = 5;    //velocidad del motor M1 
int E2 = 6;    //velocidad del motor M2
int M1 = 4;    //Control de dirección M1 
int M2 = 7;    //Control de dirección M2
void setup()
{
Serial.begin(19200);//velocidad del puerto serial
}
 
void loop()
{
val0 = analogRead(analogo0);//lee el valor del pin analógico A0 y lo asigna a val0
val1 = analogRead(analogo1);//lee el valor del pin analógico A1 y lo asigna a val1
//Montramos el valor obtenido en el puerto serial
Serial.print("Pin analogico 0: ");
Serial.println(val0);
//Montramos el valor obtenido en el puerto serial
Serial.print("Pin analogico 1: ");
Serial.println(val1);
//Compara si la variable val0 es mayor a 200
if(val0>200){
analogWrite (E1,255);//El valor 255 es la mayor potencia del motor
digitalWrite(M1,LOW);//LOW o HIGH es la dirección del motor 
  }
  else {
    analogWrite (E1,0);//El valor 0 apaga el motor  
    }
///
if(val1>200){
analogWrite (E2,255);//El valor 255 es la mayor potencia del motor
digitalWrite(M2,LOW);//LOW o HIGH es la dirección del motor 
  }
  else {
analogWrite (E2,0);//El valor 0 apaga el motor 
  }    
delay(100);//espera el servo para llegar a la posición
}

//Variables

int analogo0 = A0;

int analogo1 = A1;

int val0;//variable para leer el valor del pin analógico

int val1;//variable para leer el valor del pin analógico

int E1 = 5; //velocidad del motor M1

int E2 = 6; //velocidad del motor M2

int M1 = 4; //Control de dirección M1

int M2 = 7; //Control de dirección M2

void setup()

{

Serial.begin(19200);//velocidad del puerto serial

}

void loop()

{

val0 = analogRead(analogo0);//lee el valor del pin analógico A0 y lo asigna a val0

val1 = analogRead(analogo1);//lee el valor del pin analógico A1 y lo asigna a val1

//Montramos el valor obtenido en el puerto serial

Serial.print("Pin analogico 0: ");

Serial.println(val0);

//Montramos el valor obtenido en el puerto serial

Serial.print("Pin analogico 1: ");

Serial.println(val1);

//Compara si la variable val0 es mayor a 200

if(val0>200){

analogWrite (E1,255);//El valor 255 es la mayor potencia del motor

digitalWrite(M1,LOW);//LOW o HIGH es la dirección del motor

}

else {

analogWrite (E1,0);//El valor 0 apaga el motor

}

///

if(val1>200){

analogWrite (E2,255);//El valor 255 es la mayor potencia del motor

digitalWrite(M2,LOW);//LOW o HIGH es la dirección del motor

}

else {

analogWrite (E2,0);//El valor 0 apaga el motor

}

delay(100);//espera el servo para llegar a la posición

}

Circuito robot seguidor de luz

Fotos del robot

Puedes comprar arduino romeo en DFROBOT.COM

SUSCRIBETE A NUESTROS BOLETINES, RECIBE EN TU CORREO LAS NOTICIAS MÁS DESTACADAS, SÓLO INGRESANDO TU CORREO ELECTRÓNICO

[wysija_form id=”1″]

Detector de notas musicales con arduino

Secretos de MS-DOS: Un ingeniero de Microsoft revela su oculta capacidad gráfica

Control de acceso con módulo firgerprint y notificaciones por telegram

Creando un Sistema de Alarma de Temperatura con Raspberry Pi Pico

Recibe Notificaciones de WhatsApp al Abrir una Puerta con ESP32 y CallMeBot

Airbnb y su vergonzosa política de pagos: Un robo descarado para los argentinos

RogerBit

"The Power Of The Bit"

Romeo: una placa de control Arduino para robótica con Driver incluidos

ESPECIFICACIONES

RoMeo Pinout

Antes de empezar

Aplicando potencia

Software

Servo Power Select Jumper

Jumper Pin de control del motor

Ejemplo de uso de botones 1-5

Control de velocidad de motor doble de CC

Configuración de hardware

Asignación de pines

Modo de control PWM

Puedes comprar arduino romeo en DFROBOT.COM

Deja una respuesta Cancelar la respuesta