1

Práctica 10. Control de Motor DC

Universidad de Guanajuato, División de Ciencias e Ingenierías
Arquitectura de Microcontroladores
Profesor: Dr. Eduardo Montes Ramírez
Fonseca Uribe Oswaldo Emmanuel 1
Muñoz González Raúl Gilberto 2

Resumen—Durante la práctica, se montó un complejo circuito Motor DC (baja potencia)

en una caja, con el cual se lograba controlar el movimiento y
dirección de un motor de corriente directa.
I. C IRCUITO E LECTRÓNICO
La figura 1 muestra el circuito simulado en la plataforma
Tinkercad, mismo que se construyó durante la práctica en el
laboratorio.
Driver para motor L297
Pantalla LCD (16x2)
Módulo I2C para LCD
Teclado matricial 4 × 4
Cable C22 (varios colores)
Los motores tienen una característica importante, que son
reversibles, o sea, que podemos invertir el sentido del giro
de su eje con solo cambiar la polaridad de su conexión. Y la
mejor forma de conmutar la polaridad fácilmente, es utilizando
un Puente H (su nombre es debido a que esquemáticamente
es parecido a una letra H).
Este es un circuito electrónico que se usa para permitir a un
motor DC girar en ambos sentidos, lo vemos en la figura 2

Figura 1: Circuito de la práctica simulado

II. O BJETIVOS
Cambiar el sentido de giro con un joystick (parar en
posición neutral).
Al inciso anterior, con ayuda del mismo joystick contro-
lar la velocidad del motor por PWM.
Al inciso anterior, mediante la pantalla LCD, desplegar
el sentido de giro del motor y si este va en condición
rápida, lenta o se encuentra detenido.
Mediante el teclado matricial, usar un código de 2 dígitos
para encender el motor, otro código distinto de 2 dígitos
para apagarlo y otro código de 2 dígitos para cambiar
el sentido de giro. Es necesario desplegar en la pantalla
LCD los dígitos ingresados, sentido de giro o si este
detenido.
III. M ATERIALES Y M ONTAJE E XPERIMENTAL
Materiales utilizados en la práctica:
Computadora Portátil
Placa de Arduino UNO R3 y cable de alimentación USB
Protoboard
1 Lic. en Física oe.fonsecauribe@ugto.mx
2 Ing. Química Sustentable rg.munozgonzalez@ugto.mx
Figura 2: Puente H, construido con 4 interruptores deslizantes
Los interruptores SW 1 y SW 2 pueden conmutar la tensión
positiva de la batería.
Los interruptores SW 3 y SW 4 conmutan la tensión negativa
de la batería.
En la figura 3 podemos ver como estos interruptores necesitan
ser accionados para, en el caso 3a hacer girar el motor en
sentido de las manecillas del reloj y en el caso 3b hacer girar
el motor en sentido antihorario.
El secreto de la inversión de giro del motor DC está
en que los interruptores funcionen en forma sincronizada.
Para ello usaremos transistores, que pueden funcionar como
interruptores, pueden hacer ese trabajo en forma más eficiente
y veloz, y los circuitos integrados, tales como los drivers
L293D y L298N, minimizan el espacio que ocuparían los
transistores y sus resistencias de polarización, a veces hasta
incluyen los diodos de protección de los transistores.
En el caso de esta práctica, usaremos el driver L293D
cuyos pines se muestran en la figura 4
 2

(a) Primer caso: la pareja de interruptores SW 3 y SW 2 colocan

la polaridad indicada en la imagen inferior (negativo a la izquierda y
positivo a la derecha), el motor girará en sentido horario.

Figura 5: Usamos uno de los dos puentes H del circuito

integrado

(b) Segundo caso: la pareja de interruptores SW 1 y SW 4 colocan

la polaridad indicada en la imagen inferior (positivo a la izquierda y
negativo a la derecha), el motor girará en sentido antihorario. En los pines 3 y 6 conectaremos nuestro motor de corriente
directa.
Figura 3: Inversion de giro del motor DC usando el puente H

Con esto hecho, el circuito es el mencionado, la figura 1,

montado para comodidad y vista, en una caja para zapatos
como se muestra en la figura 6.

(a) Vista interna de las conexiones dentro de la caja.

Figura 4: Asignación de pines del circuito integrado L293D

Se requiere cambiar el sentido de giro del motor DC y

su velocidad por medio de una salida PWM de Arduino,
para ello, vamos a utilizar solo la parte izquierda del driver,
en específico, los pines 1 al 7. La manera en que los piner
estarán conectados se muestra en la figura 5

El pin 1 irá a la salida PWM de Arduino para controlar la (b) Vista externa con solo los componentes interactuables.
velocidad. Los pines 2 y 7 lograran la inversión del giro del Figura 6: Montaje del circuito en una caja de zapatos.
motor, segun la siguiente tabla:
ENABLE 1A 2A Función
H L H Giro a la derecha Como nota, y como se resalta en la figura 1, el motor lleva
H H L Giro a la izquierda una fuente separada al resto de componentes alimentados con
H L L Detención la placa Arduino UNO, esto debido a que consume mucha
H H H Detención
L X X Detención corriente, pero sus tierras están conectadas de forma común
mediante los pines del circuito integrado a tierra, ya que están
Tabla I: L = LOW, H = HIGH, X = No interesa conectados.
 3

IV. C ÓDIGO como regular la velocidad con el joystick. Mientras el LCD

A continuación se presenta el código creado para la práctica, ya para este punto es algo sencillo de programar y usar.
éste está programado por partes para observar correctamente
cada uno de los objetivos por separado:
Usaremos una ventana de 494 a 530 en la entrada analógica
para determinar que nuestro joystick está .en reposo", esta
IV-A. Objetivo 1, 2 y 3 es un ±18 al reposo de 512. Con esto, determinamos
1. Cambiar el sentido de giro con un joystick (parar también que, mayor a este número (joystick a la derecha), el
en posición neutral). 2. Al inciso anterior, con ayuda motor deberá girar a la derecha y menor que él, a la izquierda.
del mismo joystick controlar la velocidad del motor por
PWM. 3. Al inciso anterior, mediante la pantalla LCD,
desplegar el sentido de giro del motor y si este va en #include <LCD.h>
#include <LiquidCrystal_I2C.h> //Libreria
condición rápida, lenta o se encuentra detenido. para manejar el modulo I2C y el LCD
#include <Wire.h> //Libreria para ubicar los
La razón de colocarlos juntos es debido a que los tres pines analogicos del I2C
objetivos usan el joystick, además de mostrar un código
completo y que no está cortado para mostrar solo ciertas partes LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6,
7); //Creamos un objeto LCD de 16x2
del mismo.
Para estos objetivos notemos las variables a utilizar, así // Conexiones del driver L293D para un motor
como algo importante a la hora de usar el joystick; como DC
lo muestra la figura 7a, se reciben valores de 0 a 1023 de int enA = 3;
parte del joystick, ya que son dos potenciometros, uno para la int in1 = 6;
int in2 = 7;
dirección X y otro para la dirección Y, que se deben llevar a
una entrada analógica de la placa Arduino, ademas de colocar // Entrada analogica (Joystick)
su respectiva alimentación y tierra, además de que contiene un int Joy = 0;
botón que no se usará en esta práctica, esto vidto en la figura int Vel = 0;
7b.
void setup() {
//****************LCD****************
lcd.setBacklightPin(3,POSITIVE);
lcd.setBacklight(HIGH);
lcd.begin(16,2);
lcd.clear();
//****************LCD****************

//**********PRACTICA 10**********
lcd.setCursor(0,0);
lcd.print(" Practica 10: ");
lcd.setCursor(0,1);
lcd.print("Control motor DC");
(a) Valores del Joystick de los ejes X y Y en la entrada analógica de delay(500);
arduino. lcd.setBacklight(1);
delay(500);
lcd.setBacklight(0);
delay(500);
lcd.setBacklight(1);
delay(500);
lcd.setBacklight(0);
delay(500);
lcd.setBacklight(1);
lcd.clear();
lcd.setCursor(0,0);
lcd.print(" Joystick ");
delay(500);
lcd.clear();

// Colocando los pines para L293D en modo

(b) Pinout del circuito del Joystick salida
pinMode(enA, OUTPUT);
Figura 7 pinMode(in1, OUTPUT);
pinMode(in2, OUTPUT);
Entonces, para cumplir los objetivos, no solo imlpica // Iniciamos con el motor detenido
la programación correcta de los pines que van al circuito digitalWrite(in1, LOW);
L239D, sino también tener una noción correcta de cuando y digitalWrite(in2, LOW);
 4

} }
if(Vel > 170){
void loop() { lcd.print(" Rapido");
Joy = analogRead(A0); }
// Joystick en medio
while (Joy > 494 && Joy < 530){ lcd.write(byte(1));
// Motor detenido y a minima velocidad
digitalWrite(in1, LOW); lcd.setCursor(0,1);
digitalWrite(in2, LOW); lcd.print("Velocidad: ");
analogWrite(enA, 0); lcd.print(Vel);

lcd.setCursor(0,0); delay(50);
lcd.print("Detenido"); Joy = analogRead(A0);
delay(50);
Joy = analogRead(A0); }
} lcd.clear();
lcd.clear(); }

// Joystick a la izquierda A continuación las fotografías del circuito funcionando, con

digitalWrite(in1, LOW);
digitalWrite(in2, HIGH); el Joystick:

while (Joy < 494){

Vel = abs(494 - Joy);

Vel = map(Vel, 1, 494, 0, 255);
analogWrite(enA, Vel);

lcd.setCursor(0,0);

if(Vel < 85){

lcd.print(" Lento");
} (a) Joystick a velocidad media y a la izquierda
if(Vel >= 85 && Vel <= 170){
lcd.print(" Medio");
}
if(Vel > 170){
lcd.print(" Rapido");
}

lcd.write(byte(0));

lcd.setCursor(0,1);
lcd.print("Velocidad: ");
lcd.print(Vel); (b) Joystick a velocidad rápida y a la izquierda
delay(50);
Joy = analogRead(A0);

}
lcd.clear();

// Joystick a la derecha
digitalWrite(in1, HIGH);
digitalWrite(in2, LOW);
(c) Joystick entre 494 y 530, detenido
while (Joy > 530){
Figura 8: Fotografías del circuito, cumpliendo el objetivo del
Vel = abs(541 - Joy); uso del joystick
Vel = map(Vel, 1, 494, 0, 255);
analogWrite(enA, Vel);

lcd.setCursor(0,0); IV-B. Objetivo 4

if(Vel < 85){ Mediante el teclado matricial, usar un código de 2

lcd.print(" Lento"); dígitos para encender el motor, otro código distinto de
} 2 dígitos para apagarlo y otro código de 2 dígitos para
if(Vel >= 85 && Vel <= 170){ cambiar el sentido de giro. Es necesario desplegar en la
lcd.print(" Medio"); pantalla LCD los dígitos ingresados, sentido de giro o si
 5

este detenido. delay(500);

lcd.setBacklight(1);
delay(500);
Nos remontamos a la práctica pasada, con el uso del lcd.setBacklight(0);
teclado matricial, en este caso para usar ciertos çódigos"para delay(500);
así determinar el encendido, apagado y dirección del motor. lcd.setBacklight(1);
Como extra, también se añadió la posibilidad de cambiar con lcd.clear();
números ingresados, la velocidad del motor. lcd.setCursor(0,0);
#include <Keypad.h> lcd.print(" Teclado ");
delay(500);
// Caracteres Especiales lcd.clear();
byte left[8] = {
B00000, // Caracteres Especiales
B11110, lcd.createChar(0, left);
B10000, lcd.createChar(1, right);
B10010, }
B10111,
B10010, void loop(){
B11110, // Lectura del Teclado
}; Tecla = Teclado.getKey();

byte right[8] = { if(Tecla) {

B00000, Num[Indice] = Tecla;
B01111, Indice++;
B00001, lcd.print(Tecla);
B01001, }
B11101, if(Indice == 1 ){
B01001, if (!strcmp(Num,"A")){
B01111, lcd.clear();
}; lcd.setCursor(0,0);
lcd.print(" Encendido y ");
//****************Keypad************** lcd.setCursor(0,1);
const byte Filas = 4; lcd.print(" Direccion ");
const byte Columnas = 4; delay(1000);
char Teclas[Filas][Columnas] = { Indice = 0;
{’1’,’2’,’3’,’A’}, Select = false;
{’4’,’5’,’6’,’B’}, lcd.clear();
{’7’,’8’,’9’,’C’}, memset(Num,0,sizeof(Num));
{’*’,’0’,’#’,’D’}, }
}; if (!strcmp(Num,"B")){
byte pinesFilas[Filas] = {13,12,11,10}; lcd.clear();
byte pinesColumnas[Columnas] = {9,8,5,4}; lcd.setCursor(0,0);
Keypad Teclado = Keypad(makeKeymap(Teclas), lcd.print(" Selector de ");
pinesFilas, pinesColumnas, Filas, lcd.setCursor(0,1);
Columnas); lcd.print(" Velocidad ");
char Tecla; delay(1000);
bool Select; Indice = 0;
bool On; Select = true;
//****************Keypad************** lcd.clear();
memset(Num,0,sizeof(Num));
//Codigos para el motor }
char Num[3]; }
char Enc[3] = "13";
char Izq[3] = "64"; if(Indice == 2 && Select == false){
char Der[3] = "87"; if (!strcmp(Num,Enc)){
char Apg[3] = "29"; lcd.setCursor(0,1);
byte Indice = 0; lcd.print("Motor Encendido");
analogWrite(enA, 255);
void setup(){ digitalWrite(in1, HIGH);
//**********PRACTICA 10********** digitalWrite(in2, LOW);
lcd.setCursor(0,0); delay(1000);
lcd.print(" Practica 10: "); Indice = 0;
lcd.setCursor(0,1); lcd.clear();
lcd.print("Control motor DC"); On = true;
delay(500); memset(Num,0,sizeof(Num));
lcd.setBacklight(1); }
delay(500); if (!strcmp(Num,Apg)){
lcd.setBacklight(0); lcd.setCursor(0,1);
 6

lcd.print("Motor Apagado");
analogWrite(enA, 0);
digitalWrite(in1, LOW);
digitalWrite(in2, LOW);
delay(1000);
Indice = 0;
lcd.clear();
On = false;
memset(Num,0,sizeof(Num));
}
if (!strcmp(Num,Izq) && On == true){ (a) Inicio del uso del teclado
lcd.setCursor(0,1);
lcd.print("Dir Izquierda");
digitalWrite(in1, LOW);
digitalWrite(in2, HIGH);
delay(1000);
Indice = 0;
lcd.clear();
memset(Num,0,sizeof(Num));
}
if (!strcmp(Num,Der) && On == true){
lcd.setCursor(0,1); (b) Al presionar A, podemos introducir los códigos.
lcd.print("Dir Derecha");
digitalWrite(in1, HIGH);
digitalWrite(in2, LOW);
delay(1000);
Indice = 0;
lcd.clear();
memset(Num,0,sizeof(Num));
}
if (strcmp(Num,Enc)&&strcmp(Num,Apg)){
Indice = 0; (c) Al presionar "B", podemos introducir la velocidad deseada para la
lcd.clear(); dirección antes introducida.
memset(Num,0,sizeof(Num));
}
if (strcmp(Num,Izq)&&strcmp(Num,Der)
&&On==false){
Indice = 0;
lcd.clear();
memset(Num,0,sizeof(Num));
}

} (d) Código "13"para encender el motor, la dirección inicial es hacia la

derecha.
if(Indice == 3 && Select == true){
if(atoi(Num)>255){
lcd.setCursor(0,1);
lcd.print("Vel no valida");
delay(1000);
Indice = 0;
lcd.clear();
memset(Num,0,sizeof(Num));
} (e) Código "64"para cambiar el motor a la dirección izquierda con la
lcd.setCursor(0,1); velocidad ya establecida antes.
lcd.print("Velocidad: ");
for(int i=0; i<3; i++)
lcd.print(Num[i]); Figura 9: Fotografías del circuito, cumpliendo el objetivo del
analogWrite(enA, atoi(Num));
delay(1000); uso del teclado
Indice = 0;
lcd.clear();
memset(Num,0,sizeof(Num));
}
}

Y a continuación, todas las fotografías del circuito funcio-

nando usando el teclado:
 7

[5] Print ASCII characters on LCD 16×2 using Arduino. (2021,

July 15). PIJA Education. Retrieved October 19, 2022, from
https://pijaeducation.com/arduino/lcd-16x2-with-arduino-uno/print-
ascii-characters-on-lcd-16x2-using-arduino/

[6] Serial.print(Value,HEX); (2017, June 9). Arduino Forum. Retrieved

October 19, 2022, from https://forum.arduino.cc/t/serial-print-value-
hex/463868

[7] Convert char array to single int? (2011, May 23). Stack Over-
(a) Código "87"para cambiar el motor a la dirección derecha con la flow. https://stackoverflow.com/questions/6093414/convert-char-array-to-
velocidad ya establecida antes. single-int

(b) Código "29"para apagar el motor.

Figura 10: Resto de fotografías del circuito, cumpliendo el
objetivo del uso del teclado

V. C ONCLUSIONES
V-A. Fonseca Uribe Oswaldo Emmanuel
Esta práctica integradora nos sirve no solo para combinar
varios elementos ya introducidos anteriormente, sino que
podemos aplicarlos en algo tan interesante como la polaridad
de un motor a traves de usar un circuito integrado, como el
L239D, o el reto de un montaje como lo fue en la caja, ya que
el uso de los microcontroladores implica la implementación
en interfaces sencillas y amables a cualquier usuario, ya que
su finalidad es la de simplificar la vida con ellos.

V-B. Muñoz González Raúl Gilberto

La última práctica que no es propuesta respecto a un área
en específico, nos hace usar varios componentes que no se
habían utilizado, lo cual es muy complementario y demuestra
el nivel de avance que se ha tenido durante el curso. Así
como demostrar la utilidad de los microcontroladores en la
vida diaria, en entretenimiento, calculadoras, etc. Por lo que
fue algo bastante interesante y complementario.

R EFERENCIAS
[1] Arduino. (2022). Arduino Reference.
https://www.arduino.cc/reference/en/?}_gl=1*11hrmjr*_ga*MTU0MDY3
NzA5MC4xNjYwNzAwNDA2*_ga_NEXN8H46L5*MTY2MDcwMDQw
NS4xLjEuMTY2MDcwMDQyMC40NS4wLjA.

[2] A Guide to Arduino & the I2C Protocol (Two Wire). (s.f.).
Arduino Documentation. Recuperado 21 de septiembre de 2022,
de https://docs.arduino.cc/learn/communication/wire

[3] The complete table of ASCII characters. (n.d.). The Complete Table of
ASCII Characters, Codes, Symbols and Signs. Retrieved October 19,
2022, from https://theasciicode.com.ar

[4] LiquidCrystal - createChar() - Arduino Referen-

ce. (n.d.). Retrieved October 19, 2022, from
https://www.arduino.cc/reference/en/libraries/liquidcrystal/createchar/