Vehículo evita obstáculos

Vicente Fernández Povedano

Corrección 10/04/20

1 de 17
ÍNDICE

1. Materiales empleados
2. Control de motores L298N Puente H
3. Sensor ultrasonidos HC-SR04
4. Sistemas de alimentación de Arduino
5. Programación para su funcionamiento

2 de 17
3 de 17
1. Materiales empleados

- Arduino Uno( en este caso la versión no original)

- Cables protoboard

- Protoboard pequeña

- Controlador de motores L298N Puente H

- Sensor ultrasónico HC-SR04

- 4 Ruedas

- Chasis

- 4 Motores

-Tuercas y tornillos de diferentes medidas

- Batería

2. Control de motores L298N Puente H

2.1 Introducción
El módulo controlador de motores L298N H-bridge nos permite controlar la velocidad
y la dirección de dos motores de corriente continua o un motor paso a paso de una
forma muy sencilla, gracias a los 2 los dos H-bridge que monta.
Ya hemos hablado de ellos antes, pero básicamente un puente-H o H-bridge es un
componente formado por 4 transistores que nos permite invertir el sentido de la
corriente, y de esta forma podemos invertir el sentido de giro del motor.
El rango de tensiones en el que trabaja este módulo va desde 3V hasta 35V, y una
intensidad de hasta 2A. A la hora de alimentarlo hay que tener en cuenta que la

4 de 17
 electrónica del módulo consume unos 3V, así que los motores reciben 3V menos que
la tensión con la que alimentemos el módulo.
Además el L298N incluye un regulador de tensión que nos permite obtener del
módulo una tensión de 5V, perfecta para alimentar nuestro Arduino. Eso sí, este
regulador sólo funciona si alimentamos el módulo con una tensión máxima de 12V
Es un módulo que se utiliza mucho en proyectos de robótica, por su facilidad de uso
y su reducido precio.

2.2 Explicación de su funcionamiento en todos los casos.

Los pines IN1 e IN2 nos sirven para controlar el sentido de giro del motor A, y los
pines IN3 e IN4 el del motor B. Funcionan de forma que si IN1 está a HIGH e IN2 a LOW,
el motor A gira en un sentido, y si está IN1 a LOW e IN2 a HIGH lo hace en el otro. Y lo
mismo con los pines IN3 e IN4 y el motor B.
Para controlar la velocidad de giro de los motores tenemos que quitar los jumpers y usar los
pines ENA y ENB. Los conectaremos a dos salidas PWM de Arduino de forma que le
enviemos un valor entre 0 y 255 que controle la velocidad de giro. Si tenemos los jumpers
colocados, los motores girarán a la siempre a la misma velocidad.
El esquema de montaje que vamos a utilizar va a ser el siguiente, aunque podemos usar los
pines que queráis siempre que respetemos que los que conectemos
a ENA y ENB sean PWM

2.3 Esquema de funcionamiento Esquema eléctrico

5 de 17
2.4 Programación del IDE de Arduino para que funcionen los motores en
todos los casos.
Comenzamos asignando los pines que vamos a usar y declarándolos como salida:
// Motor A
int ENA = 10;
int IN1 = 9;
int IN2 = 8;

// Motor B
int ENB = 5;
int IN3 = 7;
int IN4 = 6;

void setup ()
{
// Declaramos todos los pines como salidas
pinMode (ENA, OUTPUT);
pinMode (ENB, OUTPUT);
pinMode (IN1, OUTPUT);
pinMode (IN2, OUTPUT);
pinMode (IN3, OUTPUT);
pinMode (IN4, OUTPUT);
}
Y ahora vamos a crear las funciones para mover los motores. Primero para moverlos hacia
delante a plena potencia:
void Adelante ()
{
//Direccion motor A
digitalWrite (IN1, HIGH);
digitalWrite (IN2, LOW);
analogWrite (ENA, 255); //Velocidad motor A
//Direccion motor B
digitalWrite (IN3, HIGH);
digitalWrite (IN4, LOW);
analogWrite (ENB, 255); //Velocidad motor B
}
Y ahora para moverse en el sentido contrario a la mitad de potencia:
void Atras ()
{
//Direccion motor A
digitalWrite (IN1, LOW);
digitalWrite (IN2, HIGH);
analogWrite (ENA, 128); //Velocidad motor A
//Direccion motor B
digitalWrite (IN3, LOW);
digitalWrite (IN4, HIGH);
analogWrite (ENB, 128); //Velocidad motor B
}
Y ahora vamos a girar cada motor en un sentido, cada uno con una velocidad además:

6 de 17
void Derecha ()
{
//Direccion motor A
digitalWrite (IN1, HIGH);
digitalWrite (IN2, LOW);
analogWrite (ENA, 200); //Velocidad motor A
//Direccion motor B
digitalWrite (IN3, LOW);
digitalWrite (IN4, HIGH);
analogWrite (ENB, 100); //Velocidad motor A
}

void Izquierda ()
{
//Direccion motor A
digitalWrite (IN1, LOW);
digitalWrite (IN2, HIGH);
analogWrite (ENA, 50); //Velocidad motor A
//Direccion motor B
digitalWrite (IN3, HIGH);
digitalWrite (IN4, LOW);
analogWrite (ENB, 150); //Velocidad motor A
}
Y una función más para pararlos:
void Parar ()
{
//Direccion motor A
digitalWrite (IN1, LOW);
digitalWrite (IN2, LOW);
analogWrite (ENA, 0); //Velocidad motor A
//Direccion motor B
digitalWrite (IN3, LOW);
digitalWrite (IN4, LOW);
analogWrite (ENB, 0); //Velocidad motor A
}
Vamos a combinar estas funciones en el loop, haciendo que cada una se ejecute durante un
periodo de tiempo:
void loop ()
{
Adelante ();
delay (5000);
Atras ();
delay (3000);
Derecha ();
delay (2000);
Izquierda ();
delay (2000);
Parar ();
delay (4000);
}

7 de 17
3. Sensor ultrasónico HC-SR04

3.1 Introducción
Un sensor de ultra sonidos es un dispositivo para medir distancias. Su
funcionamiento se base en el envío de un pulso de alta frecuencia, no audible por el
ser humano. Este pulso rebota en los objetos cercanos y es reflejado hacia el sensor,
que dispone de un micrófono adecuado para esa frecuencia.

Midiendo el tiempo entre pulsos, conociendo la velocidad del sonido, podemos

estimar la distancia del objeto contra cuya superficie impacto el impulso de
ultrasonidos

Los sensores de ultrasonidos son sensores baratos, y sencillos de usar. El rango de

medición teórico del sensor HC-SR04 es de 2cm a 400 cm, con una resolución de
0.3cm. En la práctica, sin embargo, el rango de medición real es mucho más limitado,
en torno a 20cm a 2 metros.

Los sensores de ultrasonidos son sensores de baja precisión. La orientación de la

superficie a medir puede provocar que la onda se refleje, falseando la medición.
Además, no resultan adecuados en entornos con gran número de objetos, dado que el
sonido rebota en las superficies generando ecos y falsas mediciones. Tampoco son
apropiados para el funcionamiento en el exterior y al aire libre.

8 de 17
 3.2 Funcionamiento

El sensor se basa simplemente en medir el tiempo entre el envío y la recepción de un pulso

sonoro. Sabemos que la velocidad del sonido es 343 m/s en condiciones de temperatura 20
ºC, 50% de humedad, presión atmosférica a nivel del mar. Transformando unidades resulta

Es decir, el sonido tarda 29,2 microsegundos en recorrer un centímetro. Por tanto, podemos
obtener la distancia a partir del tiempo entre la emisión y recepción del pulso mediante la
siguiente ecuación.

El motivo de dividir por dos el tiempo (además de la velocidad del sonido en las unidades
apropiadas, que hemos calculado antes) es porque hemos medido el tiempo que tarda el
pulso en ir y volver, por lo que la distancia recorrida por el pulso es el doble de la que d
queremos medir.

3.3 Esquemas

-Esquema eléctrico:

9 de 17
 -Esquema montaje:

3.4 Ejemplo Código

const int EchoPin = 5;

const int TriggerPin = 6;

void setup() {
Serial.begin(9600);
pinMode(TriggerPin, OUTPUT);
pinMode(EchoPin, INPUT);
}

void loop() {
int cm = ping(TriggerPin, EchoPin);
Serial.print("Distancia: ");
Serial.println(cm);
delay(1000);
}

int ping(int TriggerPin, int EchoPin) {

long duration, distanceCm;

10 de 17
 digitalWrite(TriggerPin, LOW); //para generar un pulso limpio ponemos a LOW 4us
delayMicroseconds(4);
digitalWrite(TriggerPin, HIGH); //generamos Trigger (disparo) de 10us
delayMicroseconds(10);
digitalWrite(TriggerPin, LOW);

duration = pulseIn(EchoPin, HIGH); //medimos el tiempo entre pulsos, en microsegundos

distanceCm = duration * 10 / 292/ 2; //convertimos a distancia, en cm

return distanceCm;
}

4. Sistemas de alimentación de Arduino

4.1 Diferencia energía, potencia e intensidad

Se denomina energía eléctrica a la forma de energía que resulta de la existencia de

una diferencia de potencial entre dos puntos, lo que permite establecer una corriente
eléctrica entre ambos cuando se los pone en contacto por medio de un conductor eléctrico

La potencia eléctrica es la proporción por unidad de tiempo, o ritmo, con la cual la energía
eléctrica es transferida por un circuito eléctrico. Es decir, la cantidad de energía
eléctrica entregada o absorbida por un elemento en un momento determinado

La intensidad de corriente es la cantidad de carga eléctrica que pasa a través del

conductor por unidad de tiempo (por segundo), por lo tanto el valor de la intensidad
instantánea.

4.2 Consumo componentes

Motor 9 DC(x4) Controlador Sensor HC-SR04 Placa Arduino

11 de 17
 motores
4000 mAh 2000 mAh 15 mAh 46 mAh
x4=16000mAh

4.3 Consumo Total

Consumo motores+ consumo controlador+ consumo ultrasonidos+ consumo arduino=
(16000+2000+15+46)mAh= 18061mA
4.4 Sistemas para alimentar arduino

Pila 9V
Tienen la ventaja de ser fáciles de encontrar y usar. Además hay disponibles cables y
portapilas, que incluso incorporan un conector jack tipo Arduino, lo que hace que sean
fáciles de usar.

Como desventajas, las pilas de 9V disponen de baja densidad energética. Una pila
tiene una capacidad típica de 500-600mAh. Además, son proporcionan una intensidad de
corriente máxima muy baja, en torno a 300mA, útil solo para proyectos pequeños.

Por otro lado, 9V es una tensión inadecuada para la mayoría de actuadores. Resulta
excesiva para la mayoría de motores DC y servos, mientras que no es suficiente para
grandes motores brushless y paso a paso, que funcionan con 12V y, además, requieren
mucho más intensidad.

El precio es reducido, pero tienen la gran desventaja de no ser dispositivos recargables, lo

que, unido a su baja carga, hacen que a largo plazo no resulten económicas.

En resumen, una opción para pequeños montajes o pruebas sencillas, pero que en
seguida queda corto en características, por lo que requeriremos opciones superiores.

12 de 17
 PILAS AA DE 1.5V

Podemos encontrar con facilidad porta pilas, cables y otras soluciones para incorporar
cuatro pilas AA como forma de alimentación en nuestros proyectos.

Las pilas AA tienen la ventaja de ser fáciles de encontrar. Además, el voltaje de 6V es

perfecto para alimentar motores de DC y servos.

La carga es superior a las pilas de 9V. Cuatro pilas AA convencionales proporcionan

800-1500 mAh mientras que, en el caso de usar pilas AA alcalinas la capacidad es de
1700-2800mA.

La intensidad máxima que podemos obtener supera 1A, pudiendo llegar a extraer
hasta 2A. Pero debemos tener en cuenta que, debido a las curvas de descarga, la
cantidad de carga que podemos extraer de la pila se reduce cuanto más rápido la
drenamos.

El precio de las pilas es barato, pero al no ser recargables a largo plazo no resulta
económico.

En resumen, otra opción sencilla, válida para pequeños proyectos y robots

Banco de Baterías de 5V
Tienen como ventaja que proporcionan 5V regulados, por lo que podemos alimentar
Arduino a través del USB, sin preocuparnos de la necesidad de regular el voltaje.

Muchos de estos bancos, de hecho, incorporan una única batería de litio 18650, más un
pequeño circuito que eleva y regula el voltaje a 5V. En estos casos podemos incluso sustituir
una batería por otra, empleando la misma caja, mientras cargamos la batería descargada.

El voltaje de 5V es adecuado para alimentar una gran variedad de componentes,

como motores DC, servos, así como una gran cantidad de dispositivos (sensores, tiras LED,
displays… )

13 de 17
Estos bancos son, por supuesto, recargables. La capacidad de energía es alta,
pudiendo encontrar bancos de hasta 17.000 mAh (aunque nuevamente no os creáis por
completo las capacidades que ponen en los anuncios)

Como desventaja, es una opción algo cara frente a otras opciones disponibles.
Además, la intensidad máxima es reducida, típicamente inferior a 2A, lo que le hace inviable
para proyectos grandes.

En resumen, un banco de baterías USB es una buena solución de movilidad, como

batería para llevar encima que nos permita hacer pruebas y montajes de forma sencilla (y
mucho mejor que una batería de 9V)

Baterías de polimero litio (LiPo)

Las baterías de Polimero Litio (Lipo) son la opción más avanzada para alimentar
nuestros proyectos.

Las baterías LiPo se presentan en varios voltajes, en función del número de celdas. Así las
LiPo de 2 celdas (2S) proporcionan 7.4V-8.4, y las de 3 celdas (3S) proporcionan 11.1-12.6V.
Ambos voltajes son adecuados para alimentar un Arduino.

Las baterías LiPo presentan la densidad de energía más alta de las opciones planteadas.
Podemos encontrar baterías con capacidades desde 500 a 5000mAh.

Además, las baterías LiPo tienen la ventaja de proporcionar enormes intensidades. Es

posible encontrar baterías 20-25C, lo que se traduce en intensidades de descarga de 50 a
100A, requerida por los motores más grandes.

Las baterías LiPo también son la opción más cara, aunque al ser recargables resultan
económicas a largo plazo, más aún si tenemos en cuenta sus características eléctricas

14 de 17
La mayor desventaja de estas baterías es la dificultad y cuidado que hay que tener en su
uso. Manipular de forma indebida una batería LiPo puede ser extremadamente
peligroso, por las gran cantidad de energía que almacenan.

La carga de este tipo de baterías tiene que realizarse mediante cargadores especiales, y no
deberían dejarse sin supervisión durante el proceso. Hasta el almacenamiento de estas
baterías debe realizarse en condiciones controladas.

En resumen, las baterías LiPo son la solución más potente para alimentar nuestros
proyectos, pero los requisitos de manipulación y carga la hacen adecuada sólo para
usuarios avanzados y los proyectos complejos, como grandes robots, quadricópteros, y
otro tipo de grandes vehículos

5. Programación para el funcionamiento del Robot

int TRIG = 3;
int ECHO = 4; //definimos las entradas para el sensor

int in1 = 6;
int in2 = 7; //definimos motores 1 y 2 que estarán colocados en paralelos y colocados en el lado
izquierdo.
int EnA = 10; //definimos la salida para controlar la velocidad del motor 1

int in3 = 8;
int in4 = 9; //definimos motores 3 y 4 que estarán colocados en paralelos y colocados en el lado
derecho.
int EnB = 11;

long tiempo;
long distancia;

void setup() {
pinMode(in1, OUTPUT);
pinMode(in2, OUTPUT);

pinMode(in3, OUTPUT);
pinMode(in4, OUTPUT);

pinMode (TRIG, OUTPUT);

pinMode (ECHO, INPUT);
}

void loop() {

15 de 17
digitalWrite (TRIG, LOW);
delayMicroseconds (10);

digitalWrite (TRIG, HIGH);

delayMicroseconds(10);
tiempo=pulseIn (ECHO, HIGH);
distancia = int (0.017 * tiempo);
delay (1000);

if(distancia>=45)
{
analogWrite(EnA,80);
digitalWrite(in1, HIGH);
digitalWrite(in2, LOW);

analogWrite(EnA,80);
digitalWrite(in3, HIGH);
digitalWrite(in4, LOW);

delay(100);

else
{
analogWrite(EnA,0);
digitalWrite(in1, LOW);
digitalWrite(in2, LOW);

analogWrite(EnB,0);
digitalWrite(in3, LOW);
digitalWrite(in4, LOW);

analogWrite(EnA,80);
digitalWrite(in1, HIGH);
digitalWrite(in2, LOW);

analogWrite(EnB,80);
digitalWrite(in3, LOW);
digitalWrite(in4, LOW);

delay(500);

}
}

16 de 17
17 de 17