Dentro de los últimos años los microcontroladores han estado al alcance de nuestras manos. Estos circuitos integrados graban instrucciones las cuales se introducen mediante un lenguaje de programación, esto permite al usuario interactuar con circuitos electrónicos de manera más directa a diferencia de una computadora. Así es como desarrollaremos un robot con la capacidad de evadir todo objeto que se encuentre en su camino. Los objetos serán detectados por medio de sensores, éstos envían señales eléctricas cuando se accionan. La finalidad es que al detectar el objeto frente a él se dirija hacia el lado opuesto de donde se encuentra el objeto.

1. Robot Evasor de Obstáculos Vol. 1 Agosto - Diciembre 2018
1
Robot Evasor de Obstáculos
Maestro: M.C. Aurelio Ramírez Granados.
Judith Anakaren Torres Moreno 1625208, Ana Gabriela Parra Antúnez 1583697, David Rodríguez
Villarreal 1630983,
UANL-FCFM
Universidad Autónoma de Nuevo León
Facultad de Ciencias Físico Matemáticas
San Nicolás de los Garza, Nuevo León, México
Resumen: Dentro de los últimos años los
microcontroladores han estado al alcance de nuestras
manos. Estos circuitos integrados graban instrucciones
las cuales se introducen mediante un lenguaje de
programación, esto permite al usuario interactuar con
circuitos electrónicos de manera más directa a
diferencia de una computadora. Así es como
desarrollaremos un robot con la capacidad de evadir
todo objeto que se encuentre en su camino. Los objetos
serán detectados por medio de sensores, éstos envían
señales eléctricas cuando se accionan. La finalidad es
que al detectar el objeto frente a él se dirija hacia el lado
opuesto de donde se encuentra el objeto.
Palabras claves: Arduino uno, alimentación de
baterías, protoboard, sensores mecánicos.
Material
 1 kit Chasis Móvil
 1 Tarjeta Arduino
 1 Protoboard Chico
 1 CI Puente H L293D /SN754410NE
 Cables
 Alambre
 4 tornillos con tuerca 2.56 7/16”
 2 tortillos con tuercas 1/8” x 1
 1 Portapilas de 4 pilas AA
 4 baterías AA
 Sensor ultrasónico
 2 motores de corriente continua
Dispositivos electrónicos
Sensor ultrasónico
Su funcionamiento es simple, envía una señal
ultrasónica inaudible y envía el tiempo que demoro ésta
en la ida y el regreso hasta el obstáculo más cercano
detectado. Generalmente está conformado por dos
cilindros, uno de ellos es quien emite la señal
ultrasónica, mientras que el otro la recibe.
Tiene un ángulo de medición efectivo de 15° y
detecta objetos y obstáculos a distancias de entre 2 cm a
400 cm. Su precisión es de 3mm. La velocidad de la
señal que emite este sensor equivale a la velocidad del
sonido, es decir, es de 340 m/s. [3]
Éste, como ya lo comentamos, entrega el tiempo
que transcurre entre la emisión y la recepción de la
señal ultrasónica, con esto podemos deducir que el
tiempo es dependiente de la distancia, ya que si el
objeto está más lejos la señal tardará más en ir y venir.
Aplica una de las ecuaciones básicas de física, como lo
podemos ver en la Ecuación 1:
d=vt, (1)
Es decir que la distancia es igual a la velocidad del
objeto en movimiento, multiplicado por el tiempo
transcurrido en llegar. Es importante tener en cuenta
que el tiempo que recibimos es calculado de ida y
vuelta por lo que el resultado de la distancia se divide
entre 2; es este el valor que nos envía el sensor.
Diagrama 1: Conexión lógica del sensor en el
arduino

2. Robot Evasor de Obstáculos Vol. 1 Agosto - Diciembre 2018
2
Puente H L293D
Es un circuito electrónico que permite controlar un
motor eléctrico de Corriente continua con un micro
controlador.
Un motor de corriente continua determina su
dirección de giro en función de la tensión entre sus
terminales, es decir si conectamos la terminal 1 del
motor al Positivo de la pila y la terminal 2 del motor al
Negativo de la pila, obtendremos un sentido de giro
determinado, si lo conectamos en forma opuesta
obtendremos el sentido de giro contrario. Para lograr
esto nos apoyamos con este puente. [4]
Diagrama 2. Diagrama de conexión
Para lograr el control de dos motores
simultáneamente, conectamos la terminal del primer
motor (M1) a los pines 3 y 6, mientras que para el
segundo motor (M2) en los pines 11 y 14. Podemos
observar en el Diagrama 2 que el pin 16 es utilizado
para la alimentación del voltaje, que es aquí donde
estará conectado la tensión que alimentara a los
motores.
Controlamos el giro del motor, con ayuda del
Arduino mandando pulsos altos y bajos en los pines 2 y
7, controlando las salidas de los pines 3 y 6. Podemos
representar este control con la siguiente tabla.
Enable Pin 1 Pin 2 Pin 7 Sentido de Giro
1 0 0 Freno Libre
1 0 1 Derecha
1 1 0 Izquierda
1 1 1 Freno brusco
Tabla 1. Manejo de pulsos
Ilustración 2. Diagrama lógico de conexiones
Servomotor SG90
Un servomotor es tipo de motor especial que permite
controlar la posición del eje en un determinado
momento. Está diseñado para moverse una cierta
cantidad de grados y enseguida mantenerse fijo en esa
posición. Se caracterizan, como podemos ver, por
permitir un movimiento controlado y por entregar
mayor torsión. [1]
De manera interna, frecuentemente, es un
mecanismo reductor. Por tanto nos proporcionan un alto
par y un alto grado de precisión. En desventaja, las
velocidades de giro son pequeñas en comparación de
los motores de corriente continua.
Los servos son capaces de admitir una tensión de
alimentación entre 4.8V y 7.2V; el valor más adecuado
es 6V. Con tensiones mayores de 6.5V, los servos
empiezan a oscilar demasiado, es esto los que los hace
útiles.
Tienen una velocidad de 0.1 seg / 60° con 4.8V y
0.08 seg / 60° con 6V; un par de torsión de 1.4 kg x cm.
[2]

3. Robot Evasor de Obstáculos Vol. 1 Agosto - Diciembre 2018
3
Ilustración 3. Servomotor con kit de giro de
inclinación.
Ensamble
Primeramente se tienen que realizar las instalaciones
básicas y físicas. Armar el chasis, colocándole los
motores con las ruedas, el switch interruptor de
alimentación de voltaje, el portapilas y la rueda loca
bajo el chasis.
Aquí mismo fijamos el protoboard, ya con el
Circuito Integrado, el Puente H L293D, para comenzar
con la interconexión de los dispositivos electrónicos con
el Arduino.
Ss
Proseguimos con el siguiente procedimiento de
conexión.
1. Realizamos las conexiones de Alimentación de
Puente H, es decir alimentamos los pines de
voltaje y aterrizamos los pines de GND
(Tierra).
2. Conectamos los motores, como lo comentamos
anteriormente, M1 en los pines 3 y 6, mientras
que M2 en 11 y 14.
3. Colocamos de una vez las baterías, con el
objetivo de colocar encima el Arduino.
4. Colocamos las conexiones del servomotor en
el protoboard para voltaje y tierra, mientras
que el cable de control lo colocamos en el
arduino en un Pin Digital, como lo podemos
ver la Ilustración 5.
5. Finalmente el sensor ultrasónico, de igual
manera en protoboard para voltaje y Tierra, y
los otros 2 cables a otros dos Pines Digitales,
como se observa en la Ilustración 6.
Ilustración 4. Armado de Chasis
Ilustración 5. Conexiones del servomotor al Arduino

4. Robot Evasor de Obstáculos Vol. 1 Agosto - Diciembre 2018
4
Programación
Para poder crear una instancia de la funciones usamos
código C y para poder hacer uso de las fusiones de
arduino usamos C++ en el cual solo con incluir la
librería Arduino.h nos permite crear las funciones
declaradas en el codigo C
Código para controlar Ultrasónico
codigo c
class Sensor_ultrasonico_HCSR04
{
private:
int Echo;
int Trig;
long lduration;
long ldistance;
public:
Sensor_ultrasonico_HCSR04(int echo,int trig):
Echo(echo),Trig(trig){lduration=0;ldistance=0;};//Contr
uctor
void Inicializar_ultrasonico();
float Obtener_Distancia();
};
código c++
#include <Arduino.h> //Permite utilizar los comandos
de Arduino
#include "Sensor_ultrasonico_HCSR04.h"
void
Sensor_ultrasonico_HCSR04::Inicializar_ultrasonico()
{
pinMode(Trig, OUTPUT);
pinMode(Echo, INPUT);
}
float Sensor_ultrasonico_HCSR04::Obtener_Distancia()
{
digitalWrite(Trig, LOW);
delayMicroseconds(2);
digitalWrite(Trig, HIGH);
delayMicroseconds(10);
digitalWrite(Trig, LOW);
lduration = pulseIn(Echo, HIGH);
ldistance = (lduration/2) / 29.1;
return ldistance;
}
Código para controlar Motores
class Motor_DC
{
private:
int A;
int B;
int Pwm;
public:
Motor_DC(int a,int b,int pwm): A(a),
B(b),Pwm(pwm){}//Constructor
void Inicializar_Motor();
void Adelante(int Velocidad);
void Atras(int Velocidad);
void Stop();
};
código c++
#include <Arduino.h> //Permite utilizar los comandos
de Arduino
#include "Motor_DC.h"
void Motor_DC::Inicializar_Motor()
{
pinMode(A, OUTPUT);
pinMode(B, OUTPUT);
pinMode(Pwm, OUTPUT);
}
void Motor_DC::Atras(int Velocidad)
{
analogWrite(Pwm,Velocidad );
digitalWrite(A, HIGH);
digitalWrite(B, LOW);
}
void Motor_DC::Adelante(int Velocidad)
{
analogWrite(Pwm,Velocidad );
digitalWrite(A, LOW);
Ilustración 6. Conexiones del sensor ultrasónico a
Arduino

5. Robot Evasor de Obstáculos Vol. 1 Agosto - Diciembre 2018
5
digitalWrite(B, HIGH);
}
void Motor_DC::Stop()
{
analogWrite(0, Pwm);
digitalWrite(A, LOW);
digitalWrite(B, LOW);
}
Código para inicializar los motores
código c
#include "Motor_DC.h"
class Base_Robot
{
private:
public:
Motor_DC Motor_1;
Motor_DC Motor_2;
Base_Robot(int Pin_Motor_1A,int Pin_Motor_1B,int
PWM_1, int Pin_Motor_1C, int Pin_Motor_1D,int
PWM_2):
Motor_1(Pin_Motor_1A,Pin_Motor_1B,PWM_1),
Motor_2(Pin_Motor_1C,Pin_Motor_1D,PWM_2){}
void Inicializar_Robot();
void Adelante(int Velocidad_1,int Velocidad_2);
void Atras(int Velocidad_1,int Velocidad_2);
void Stop();
};
código c++
#include <Arduino.h> //Permite utilizar los comandos
de Arduino
#include "Base_Robot.h"
void Base_Robot::Inicializar_Robot()
{
Motor_1.Inicializar_Motor();
Motor_2.Inicializar_Motor();
}
void Base_Robot::Atras(int Velocidad_1,int
Velocidad_2)
{
Motor_1.Atras(Velocidad_1);
Motor_2.Atras(Velocidad_2);
}
void Base_Robot::Adelante(int Velocidad_1,int
Velocidad_2)
{
Motor_1.Adelante(Velocidad_1);
Motor_2.Adelante(Velocidad_2);
}
void Base_Robot::Stop()
{
Motor_1.Stop();
Motor_2.Stop();
}
Código del algoritmo evasor de obstaculos.
Código c
#include "Sensor_ultrasonico_HCSR04.h"
#include "Base_Robot.h"
#include <Servo.h>
class Evasor
{
private:
Base_Robot Robot;
Sensor_ultrasonico_HCSR04 S1;
Servo Servo_1;
int Pin_Servo;
public:
//Constructor
Evasor(
int Pin_Motor_1A,
int Pin_Motor_1B,
int PWM_1,
int Pin_Motor_1C,
int Pin_Motor_1D,
int PWM_2,
int echo_1,
int trig_1,
int pin_servo):
Robot(Pin_Motor_1A, Pin_Motor_1B, PWM_1,
Pin_Motor_1C, Pin_Motor_1D, PWM_2),
S1(echo_1,trig_1){Pin_Servo=pin_servo;}
void Inicializar();
void Modo_Evasor(int Velocidad,int Distancia);
void Izquierda(int Velocidad_1,int Velocidad_2);
void Derecha(int Velocidad_1,int Velocidad_2);
void Adelante(int Velocidad_1,int Velocidad_2);
void Stop();
};
Código c++
#include <Arduino.h> //Permite utilizar los comandos
de Arduino
#include "Evasor.h"
void Evasor::Inicializar()
{
Robot.Inicializar_Robot();
S1.Inicializar_ultrasonico();
Servo_1.attach(Pin_Servo); // attaches the servo on
pin 9 to the servo object}
}
void Evasor::Izquierda(int Velocidad_1,int
Velocidad_2)
{
Robot.Motor_1.Adelante(Velocidad_1);
Robot.Motor_2.Atras(Velocidad_2);
}
void Evasor::Derecha(int Velocidad_1,int Velocidad_2)
{

6. Robot Evasor de Obstáculos Vol. 1 Agosto - Diciembre 2018
6
Robot.Motor_2.Adelante(Velocidad_1);
Robot.Motor_1.Atras(Velocidad_2);
}
void Evasor::Adelante(int Velocidad_1,int
Velocidad_2)
{
Robot.Atras(Velocidad_1,Velocidad_2);
}
void Evasor::Stop()
{
Robot.Stop();
}
void Evasor::Modo_Evasor(int Velocidad,int Distancia)
{
float Distancia_1;
float Distancia_2;
float Distancia_3;
float Distancia_4;
Servo_1.write(90);
Distancia_1=S1.Obtener_Distancia();
if(Distancia_1 < Distancia)
{
Stop();
Servo_1.write(20);
delay(500);
Distancia_2=S1.Obtener_Distancia();
Servo_1.write(90);
delay(500);
Distancia_3=S1.Obtener_Distancia();
Servo_1.write(150);
delay(500);
Distancia_4=S1.Obtener_Distancia();
Servo_1.write(90);
if(Distancia_2>Distancia_4)
{
Izquierda(Velocidad,Velocidad);
delay(400);
Stop();
}
if(Distancia_2<Distancia_4)
{
Derecha(Velocidad,Velocidad);
delay(400);
Stop();
}
}
Adelante(Velocidad,Velocidad);
}
Código Arduino
#include "Evasor.h"
Evasor Robot_Evasor(13,12,11,10,9,8,7,6,5);
void setup()
{
Robot_Evasor.Inicializar();
}
void loop()
{
Robot_Evasor.Modo_Evasor(255,9);
}
Referencias
[1] González, A. G. (2 de Diciembre de 2016).
PANAMATEK. Obtenido de Conocimiento
Libre | De Panamá del Mundo:
http://panamahitek.com/que-es-y-como-
funciona-un-servomotor/
[2] Llamas, L. (6 de Junio de 2016). Luis Llamas.
Obtenido de
https://www.luisllamas.es/controlar-un-servo-
con-arduino/
[3] Mouser Electronics. (17 de Septiembre de 2013).
Mouser Electronics. Obtenido de
https://www.mouser.com/ds/2/813/HCSR04-
1022824.pdf
[4] Veloso, C. (9 de Marzo de 2016). ElectronTools.
Obtenido de
http://www.electrontools.com/Home/WP/2016/
03/09/como-funciona-el-puente-h-l293b/
Nombre completo del autor o de los autores
Ana Gabriela Parra Antúnez, Lic. en Ciencias
Computacionales, con desarrollo de conocimientos en el
ámbito de Redes y Telecomunicaciones.
Email:anagabriela2809@gmail.com
Judith Anakaren Torres Moreno, Lic. en Ciencias
Computacionales, email: judith.karen1997@gmail.com
David Rodríguez Villarreal, Lic. en Ciencias
Computacionales