Instituto Tecnológico de Orizaba

Materia:
“Instrumentación”
Maestro:
Villa fuerte Salcedo Rubén Abiud
Tema:
“Coche de control remoto programado mediante
arduino y controlado por el celular”
Presenta:
Cerón Tzompaxtle José Mauricio, Soto Nepomuceno María
de los Ángeles, Vidal Acacihua Emmanuel, Ordoñez
Fomperosa Sebastián, Arellano Pérez Luis Javier, Pérez
Ramos Benjamín de Jesús, Reyes Antonio Marcelino,
Velazquez Ramos Luis Javier, Quitl Malpica Lissette
Stephania
Horario:
11:00-12:00 hrs.
Fecha:
11/02/19

“Coche de control remoto programado mediante

arduino y controlado por el celular”
Introducción:
Con este sencillo y fácil proyecto pretendemos que através de la electrónica (analógica y
digital) pongan en práctica lo aprendido y sirva de introducción al fascinante mundo de la
robótica o e nuestro caso la instrumentación. El “robot” que se propone, es un dispositivo
móvil con cuatro ruedas, dos movidas por un motor que será la tracción de las llantas
traseras, y las llantas delanteras serán las que comandaras la dirección del coche. Estos
motores girarán o no mediante una señal procedente de un teléfono móvil con Android.

El funcionamiento será el siguiente:

Descargaremos una aplicación de la app store llamada “Arduino Bluetooth RC Car” que
instalaremos en el móvil. En esta aplicación aparece un botón para conectar este con el
arduino del coche mediante Bluetooth, una vez conectado, podemos pulsar el resto de
botones: adelante, derecha e izquierda, cada uno de estos motores acciona respectivamente,
el motor de tracción o el motor de dirección. Hay otro botón para parar el coche y otro para
desconectar conexión Bluetooth. Hemos simplificado al máximo la circuitería.

Marco teórico

Arduino:
Arduino Uno es una placa con un micro controlador basada en el ATmega328P (hoja de
datos). Tiene 14 pines de entrada / salida digital (de los cuales 6 se pueden usar como
salidas PWM), 6 entradas analógicas, un cristal de cuarzo de 16 MHz, una conexión USB,
un conector de alimentación, un encabezado ICSP y un botón de reinicio. Contiene todo lo
necesario para soportar el micro controlador; simplemente conéctelo a una computadora
con un cable USB o enciéndalo con un adaptador de CA a CC o una batería para comenzar.
Puede jugar con su UNO sin preocuparse demasiado por hacer algo mal, en el peor de los
casos puede reemplazar el Chip por unos pocos dólares y empezar de nuevo.

"Uno" significa uno en italiano y se eligió para marcar el lanzamiento de Arduino Software
(IDE) 1.0. La placa Uno y la versión 1.0 de Arduino Software (IDE) fueron las versiones de
referencia de Arduino, ahora evolucionaron a versiones más recientes. La tarjeta Uno es la
primera de una serie de tarjetas Arduino USB y el modelo de referencia para la plataforma
Arduino; Para obtener una lista extensa de tableros actuales, pasados o desactualizados,
consulte el índice de tableros Arduino.
 Especificaciones técnicas
Micro controlador ATmega328P
Voltaje de funcionamiento: 5V
Voltaje de entrada (recomendado): 7-12V
Voltaje de entrada (límite): 6-20 V
Pernos de E / S digitales 14 (de los cuales 6
proporcionan salida PWM)
PWM Digital I / O Pins 6
Clavijas de entrada analógicas 6
Corriente DC por Pin de E / S 20 mA
Corriente DC para 3.3V Pin 50 mA
Memoria Flash de 32 KB (ATmega328P) de los
cuales 0.5 KB utilizados por el cargador de
arranque
SRAM 2 KB (ATmega328P)
EEPROM 1 KB (ATmega328P)
Velocidad del reloj 16 MHz
LED_BUILTIN 13
Longitud 68.6 mm
Ancho 53.4 mm
Peso 25 g

Puente H:
Un Puente en H es un circuito electrónico que generalmente se usa para permitir a un motor
eléctrico DC girar en ambos sentidos, avance y retroceso. Son ampliamente usados
en robótica y como convertidores de potencia. Los puentes H están disponibles
como circuitos integrados, pero también pueden construirse a partir de componentes
discretos.

Estructura del puente H (marcado en rojo)

El término "puente H" proviene de la típica representación gráfica del circuito. Un puente
H se construye con 4 interruptores (mecánicos o mediante transistores). Cuando los
interruptores S1 y S4 (ver primera figura) están cerrados (y S2 y S3 abiertos) se aplica una
tensión positiva en el motor, haciéndolo girar en un sentido. Abriendo los interruptores S1
y S4 (y cerrando S2 y S3), el voltaje se invierte, permitiendo el giro en sentido inverso del
motor

Los 2 estados básicos

del circuito
Con la nomenclatura que estamos usando, los interruptores S1 y S2 nunca podrán estar
cerrados al mismo tiempo, porque esto cortocircuitaría la fuente de tensión. Lo mismo
sucede con S3 y S4.

Imagen que muestra gráficamente un “Puente H”

Aplicaciones:

Como hemos dicho el puente H se usa para invertir el giro de un motor, pero también puede
usarse para frenarlo (de manera brusca), al hacer un corto entre las bornas del motor, o
incluso puede usarse para permitir que el motor frene bajo su propia inercia, cuando
desconectamos el motor de la fuente que lo alimenta. En el siguiente cuadro se resumen las
diferentes acciones.

Tiene otras aplicaciones como generar un voltaje de salida AC a partir de controlar con
dos PWM invertidos los Transistores s1, s2 y s3, s4. generando un voltaje alterno que se
puede tomar diferentes frecuencias dependiendo del Duty-cycle que tomen las PWM. un
ejemplo de esta configuración es el uso de un peltier para obtener una temperatura
requerida en función de las PWM.
Materiales:

Material Costo
Arduino Uno $160
Puente H $80
Puerto Bluetooth $165
Cables conectores $80
Coche de juguete $1,000
Baterías $100
Total: $1,585

Como herramientas ocuparemos:

 Un desarmador pequeño de cruz y uno plano
 Pinzas y cinta de aislar
 Un cúter o una pinza pela cables
 Cautín
 Un cargador de baterías
Desarrollo:

Primero que nada debemos de desarmar nuestro

coche y quitarle la circuitería original que trae
para implementar la que realizaremos en este
proyecto.

Como segundo paso debemos de programar el

arduino para que nos haga las funciones que
necesitamos para que nuestro coche opere a la
perfección, a continuación les mostraremos el código
que utilizamos para este proyecto:
#define in1 5 //L298n Motor Driver pins.
#define in2 6
#define in3 10
#define in4 11
#define LED 13
int command; //Int to store app command state.
int Speed;
int Speedsec;
int Turnradius = 200; // This controls the radius of a turn, the higher the smaller the turn. This should
not exceed
// 255
void setup() {
pinMode(in1, OUTPUT);
pinMode(in2, OUTPUT);
pinMode(in3, OUTPUT);
pinMode(in4, OUTPUT);
pinMode(LED, OUTPUT); //Set the LED pin.
Serial.begin(9600); //Set the baud rate to your Bluetooth module.
}
void loop() {
if (Serial.available() > 0) {
command = Serial.read();
Stop(); //Initialize with motors stoped.
switch (command) {
case 'F':
forward();
break;
case 'B':
back();
break;
case 'L':
left();
break;
case 'R':
right();
break;
case 'G':
forwardleft();
break;
case 'I':
forwardright();
break;
case 'H':
backleft();
break;
case 'J':
backright(); void left() {
break; analogWrite(in3, Speed);
case '0': analogWrite(in2, Speed);
Speed = 128; }
break;
case '1': void right() {
Speed = 140; analogWrite(in4, Speed);
break; analogWrite(in1, Speed);
case '2': }
Speed = 153; void forwardleft() {
break; analogWrite(in1, Speedsec);
case '3': analogWrite(in3, Speed);
Speed = 165; }
break; void forwardright() {
case '4': analogWrite(in1, Speed);
Speed = 178; analogWrite(in3, Speedsec);
break; }
case '5': void backright() {
Speed = 191; analogWrite(in2, Speed);
break; analogWrite(in4, Speedsec);
case '6': }
Speed = 204;
break; void backleft() {
case '7': analogWrite(in2, Speed);
Speed = 216; analogWrite(in4, Speedsec);
break; }
case '8':
Speed = 229; void Stop() {
break; analogWrite(in1, 0);
case '9': analogWrite(in2, 0);
Speed = 242; analogWrite(in3, 0);
break; analogWrite(in4, 0);
case 'q': }
Speed = 255;
break; void Auto() {
case 'W': //LED pin on or off. //Reserved for future use
digitalWrite(LED, HIGH); }
break; void Manual() {
case 'w': //Reserved for future use
digitalWrite(LED, LOW); }
break;
case 'X':
Auto();
break;
case 'x':
Manual();
break;
}
Speedsec = Speed - Turnradius;
}
}

void forward() {
analogWrite(in1, Speed);
analogWrite(in3, Speed);
}

void back() {
analogWrite(in2, Speed);
analogWrite(in4, Speed);
}
El siguiente paso es conectar el arduino con los demás componentes siguiendo nuestro
diagrama propuesto.
Ahora ya tenemos casi finalizado nuestro proyecto, lo único que resta por hacer es
colocarle las baterías que alimentaran nuestro circuito y le darán la potencia a nuestros
motores.

Bibliografía:
https://es.wikipedia.org/wiki/Puente_H_(electr%C3%B3nica)

https://store.arduino.cc/usa/arduino-uno-rev3