L298N

El módulo L298N para control de Motores en un dispositivo que

proporciona corriente necesario para el control de motores dc y
Julio Garavito Armero. motores paso a paso para aplicaciones de robótica.

L298N
Leidy Tatiana Agudelo
CARACTERÍSICAS
1104
 Circuito integrado principal: L298N.
 Corriente pico de operación: 4 amperios.
 Corriente constante de operación: 2 amperios.
  Bajo voltaje de saturación en los trasmisores de salida. }

 Corte de operación por sobrecalentamiento. Y ahora vamos a crear las funciones para mover los motores. Primero para moverlos
 Voltaje de alimentación de motores hasta 46 volts. hacia delante a plena potencia:

 Excelente inmunidad al ruido. void Adelante ()

 Ideal para conectar motores en aplicaciones de robótica.
{
Comenzamos asignando los pines que vamos a usar y declarándolos como salida:
//Direccion motor A
// Motor A
digitalWrite (IN1, HIGH);
int ENA = 10;
digitalWrite (IN2, LOW);
int IN1 = 9;
analogWrite (ENA, 255); //Velocidad motor A
int IN2 = 8;
//Direccion motor B

digitalWrite (IN3, HIGH);

// Motor B
digitalWrite (IN4, LOW);
int ENB = 5;
analogWrite (ENB, 255); //Velocidad motor B
int IN3 = 7;
}
int IN4 = 6;
Y ahora para moverse en el sentido contrario a la mitad de potencia:

void Atras ()
void setup ()
{
{
//Direccion motor A
// Declaramos todos los pines como salidas
digitalWrite (IN1, LOW);
pinMode (ENA, OUTPUT);
digitalWrite (IN2, HIGH);
pinMode (ENB, OUTPUT);
analogWrite (ENA, 128); //Velocidad motor A
pinMode (IN1, OUTPUT);
//Direccion motor B
pinMode (IN2, OUTPUT);
digitalWrite (IN3, LOW);
pinMode (IN3, OUTPUT);
digitalWrite (IN4, HIGH);
pinMode (IN4, OUTPUT);
analogWrite (ENB, 128); //Velocidad motor B
} Y una función más para pararlos:

Y ahora vamos a girar cada motor en un sentido, cada uno con una velocidad además: void Parar ()

void Derecha () {

{ //Direccion motor A

//Direccion motor A digitalWrite (IN1, LOW);

digitalWrite (IN1, HIGH); digitalWrite (IN2, LOW);

digitalWrite (IN2, LOW); analogWrite (ENA, 0); //Velocidad motor A

analogWrite (ENA, 200); //Velocidad motor A //Direccion motor B

//Direccion motor B digitalWrite (IN3, LOW);

digitalWrite (IN3, LOW); digitalWrite (IN4, LOW);

digitalWrite (IN4, HIGH); analogWrite (ENB, 0); //Velocidad motor A

analogWrite (ENB, 100); //Velocidad motor A }

} Vamos a combinar estas funciones en el loop, haciendo que cada una se ejecute durante un
periodo de tiempo:

void loop ()
void Izquierda ()
{
{
Adelante ();
//Direccion motor A
delay (5000);
digitalWrite (IN1, LOW);
Atras ();
digitalWrite (IN2, HIGH);
delay (3000);
analogWrite (ENA, 50); //Velocidad motor A
Derecha ();
//Direccion motor B
delay (2000);
digitalWrite (IN3, HIGH);
Izquierda ();
digitalWrite (IN4, LOW);
delay (2000);
analogWrite (ENB, 150); //Velocidad motor A
Parar ();
}
delay (4000);
}
PROYECTO O APLICACIÓN
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 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.
La entrada de tensión Vin admite tensiones entre 3V y 35V, y justo a su
derecha en la imagen tenemos el pin que debemos conectar a GND.
El resto de conexiones se usan de una u otra forma dependiendo si vamos a
manejar dos motores de continua o un motor paso a paso. En esta sesión nos
vamos a centrar en el control de motores DC.
Las salidas para los motores A y B nos darán la energía para mover los
motores. Tened en cuenta la polaridad al conectarlos, para que cuando más
tarde hagamos que se muevan adelante, funcionen como deberían. Si no
fuera así, no tendríamos más que invertir las conexiones.
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.

La tercera conexión de ese grupo V lógico puede funcionar de dos maneras: El esquema de montaje que vamos a utilizar va a ser el siguiente, aunque
podéis usar los pines que queráis siempre que respetemos que los que
conectemos a ENA y ENB sean PWM.

Si el jumper del regulador está cerrado activaremos el regulador de tensión

del L298N, y en V lógico tendremos una salida de 5V, que podremos usar
para lo que queramos, por ejemplo para alimentar una placa Arduino.

Si el quitamos el jumper desactivaremos el regulador, necesitaremos

alimentar la parte lógica del módulo, así que tendremos que meter una
tensión de 5V por la conexión V lógico para que el módulo funcione.

¡Cuidado! Si introducimos corriente por V lógico con el jumper de

regulación puesto podríamos dañar el módulo.

Además el regulador sólo funciona con tensiones hasta 12V en Vin, por
encima de este valor tendremos que quitar el jumper y alimentar la parte
lógica del módulo desde otra fuente.
Julio Garavito Armero.
L293D
Leidy Tatiana Agudelo
1104

L293D
  Corriente pico de salida: 1 A por canal (no repetitiva).
 Encapsulado: DIP de 16 pines.
 Alta inmunidad al ruido eléctrico.
 Protección contra exceso de temperatura.
 Diodos de protección (flyback) incorporados.

PROGRAMACIÓN
//Testeando Motores con L293D
//Definimos pins
//Motor A
int enableA = 5;
int motorA1 = 6;
int motorA2 = 7;
//Motor B
int enableB = 8;
int motorB1 = 9;
int motorB2 = 10;
El circuito integrado L293D incluye en su interior 4 drivers o medio void setup() {

puente H. La corriente máxima que el L293D puede manejar es de 600 Serial.begin (9600);
mA con voltajes desde 4.5 volts a 36 volts. //configuración
pinMode (enableA, OUTPUT);
pinMode (motorA1, OUTPUT);
Todas las entradas del circuito Integrado L293D son compatibles con pinMode (motorA2, OUTPUT);
TTL, por lo que pueden manejarse con la mayoría de los micro
pinMode (enableB, OUTPUT);
controladores y circuitos lógicos del mercado. La salida de los drivers pinMode (motorB1, OUTPUT);
puede activarse y desactivarse en pares, mediante señales de pinMode (motorB2, OUTPUT);

habilitación. }
void loop() {
//activamos motor A
Serial.println («Activamos motores»);
digitalWrite (enableA, HIGH);
digitalWrite (enableB, HIGH);
delay (1000);

//Nos movemos
CARACTERÍSTICAS Serial.println («Hacia delante»);
digitalWrite (motorA1, LOW);
 Alimentación: 45 a 36 VDC digitalWrite (motorA2, HIGH);
digitalWrite (motorB1, LOW);
 Corriente de salida: 600 mA. digitalWrite (motorB2, HIGH);
 //Durante 3 segundos digitalWrite (dirmotorB2,LOW);
analogWrite (enableB, velocidad);
delay (3000); }
void derecha(){
Serial.println («Hacia atrás«); digitalWrite (dirmotorA1,LOW);// gira motor A izquierda
digitalWrite (motorA1,HIGH); digitalWrite (dirmotorA2,HIGH);
digitalWrite (motorA2,LOW); analogWrite (enableA, velocidad);
digitalWrite (MotorB1,HIGH); digitalWrite (dirmotorB1,LOW);// gira motor B izquierda
digitalWrite (MotorB2,LOW); digitalWrite (dirmotorB2,HIGH);
//Durante 3 segundos analogWrite (enableB,velocidad);
}
delay (3000); void paro(){
Serial.println («Paramos motores»); digitalWrite (dirmotorA1,HIGH);// para motor A
//stop digitalWrite (dirmotorA2,HIGH);
digitalWrite (enableA, LOW); analogWrite (enableA, 0);
digitalWrite (enableB, LOW); digitalWrite (dirmotorB1,HIGH);// para motor B
delay (3000); digitalWrite (dirmotorB2,HIGH);
} analogWrite (enableB, 0);
Pero podemos mejorar esta programación. Escribiremos código para controlar mediante }
ordenador el robot con 2 motores CC desde el puerto serie. // comenzamos parando los motores
// declaración de variables void setup(){
char val; int i;
int enableA = 5; //velocidad motor A for(i=5;i<11;i++){
int dirmotorA1 = 6; // direccion motor a pinMode(i, OUTPUT); //poner pin 5,6,7,8,9,10,11 de salida
int dirmotorA2= 7; // direccion motor a }
int enableB = 8; //velocidad motor B Serial.begin(9600);
int dirmotorB1 = 9; // direccion motor b paro();
int dirmotorB2= 10; // direccion motor b }
int velocidad = 120; // Y el bucle principal
//Métodos para el control adelante, atras, derecha void loop() {
// izquierda y stop if( Serial.available() ) {
void adelante(){ val = Serial.read();
digitalWrite (dirmotorA1,HIGH);// gira motor A derecha }
digitalWrite (dirmotorA2,LOW); switch (val) {
analogWrite (enableA, velocidad); case ‘s’:
digitalWrite (dirmotorB1,LOW);// gira motor B izquierda paro();
digitalWrite (dirmotorB2,HIGH); break;
analogWrite (enableB, velocidad); case ‘a’:
} adelante();
void atras(){ break;
digitalWrite (dirmotorA1,LOW);// gira motor A izquierda case ‘r’:
digitalWrite (dirmotorA2,HIGH); atras();
analogWrite (enableA, velocidad); break;
digitalWrite (dirmotorB1,HIGH);// gira motor B derecha case ‘i’:
digitalWrite (dirmotorB2,LOW); izquierda();
analogWrite (enableB, velocidad); break;
} case ‘d’:
void izquierda(){ derecha();
digitalWrite (dirmotorA1,HIGH);// gira motor A derecha break;
digitalWrite (dirmotorA2,LOW); }
analogWrite (enableA, velocidad); }
digitalWrite (dirmotorB1,HIGH);// gira motor B derecha
 estadoPulsadorSubir = digitalRead (pinPulsadorSubir);
PROYECTO }
}

Activar el Enable1 para arrancar Motor 1, y luego usar I1 e I2 con valores if ( estadoPulsadorSubir == LOW && estadoPulsadorBajar == HIGH )
invertidos. El motor arranca y se para a los 3 segundos. Transcurrido un {
segundo se activa de nuevo el Enable1 y al intercambiar los valores de I1 e while (estadoPulsadorSubir==HIGH)
I2 el giro del motor se inicia y en la dirección contraria. {
digitalWrite(E1, HIGH); //Activamos giro de subida
digitalWrite(I1, LOW); //Se inicia la subida
Programa
digitalWrite(I2, HIGH); //Activamos giro de subida
//Control del sentido de giro de un motor de CC estadoPulsadorBajar = digitalRead (pinPulsadorSubir);
}
#define E1 10 // Enable Pin para el motor 1 }
#define I1 8 // Control pin 8 para el motor 1
digitalWrite(E1, LOW); //Motor desactivado
#define I2 9 // Control pin 9 para el motor 1
}
int estadoPulsadorSubir=0;
int estadoPulsadorBajar=0;
int pinPulsadorSubir=1;
int pinPulsadorBajar=2;

void setup()
{
for (int i=8; i<=11; i++)
pinMode (i, OUTPUT);
pinMode (pinPulsadorSubir, INPUT);
pinMode (pinPulsadorBajar, INPUT);
}
void loop()
{
estadoPulsadorSubir = digitalRead (pinPulsadorSubir); //Leer estado del pusador de subida
estadoPulsadorBajar = digitalRead (pinPulsadorBajar); //Leer estado del pusador de bajada

if ( estadoPulsadorSubir == HIGH && estadoPulsadorBajar == LOW )

{
while (estadoPulsadorSubir==HIGH)
{
digitalWrite(E1, HIGH); //Activamos giro de subida
digitalWrite(I1, HIGH); //Se inicia la subida

digitalWrite(I2, LOW); //Activamos giro de subida

 ESP8266

Se trata de un chip integrado con conexión WiFi y compatible con el

protocolo TCP/IP. El objetivo principal es dar acceso a cualquier
microcontrolador a una red.

Julio Garavito Armero. Características

ESP8266  Microcontrolador Cadence Tensilica Xtensa LX106 a 80 ó 160 MHz
 Hasta 4 MB de memoria flash externa al microcontrolador
Leidy Tatiana Agudelo  80 kB de memoria RAM
 10 puertos de entrada salida digital
1104  Compatibilidad con diferentes protocolos de comunicación (I2C, SPI,
I2S, 1-Wire, UART)
 Interfaz de red WiFi B, G y N con encriptación WEP ó WPA/WPA2 y
protocolos TCP/IPv4

PROYECTO
#4 Servidor NTP sin conexión a Internet print(payload)

Cuando el ESP8266 está conectado a Internet, es muy cómodo y sck:send("HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\n<h1>
sencillo utilizar el protocolo NTP para sincronizar la hora interna. Yo Hello, NodeMCU.</h1>")
mismo he programado una librería para realizar esta función. Lo end)
puedes encontrar en GitHub. (
conn:on("sent", function(sck) sck:close() end)
Cuando no existe la posibilidad de conectarse a Internet, es necesario
utilizar otras fuentes como GPS, relojes de tiempo real (RTC) o end)
receptores de señales de radio DCF77.
-- connect to WiFi access point (DO NOT save config to flash)
Pero imagínate que tenemos un sistema compuesto por una red de
wifi.setmode(wifi.STATION)
microcontroladores que, por la razón que sea, no quieres o no
puedes conectar a Internet. Si quieres sincronizar la hora entre todos station_cfg={}
ellos tienes que buscar la manera de que obtengan la información
horaria de algún modo. station_cfg.ssid = "SSID"

Este proyecto con ESP8266 permite que obtenga la hora real mediante station_cfg.pwd = "password"
un receptor GPS, por ejemplo, y otros dispositivos se conecten a él station_cfg.save = false
para sincronizarse utilizando el protocolo estándar NTP.
wifi.sta.config(station_cfg)

-- register event callbacks for WiFi events

wifi.sta.eventMonReg(wifi.STA_CONNECTING, function(previous_state)

if(previous_state==wifi.STA_GOTIP) then
CÓDIGOS DE PROGRAMACIÓN
print("Station lost connection with access point. Attempting to
reconnect...")

else
-- a simple HTTP server
print("STATION_CONNECTING")
srv = net.createServer(net.TCP)
end
srv:listen(80, function(conn)
end)
conn:on("receive", function(sck, payload)
-- manipulate hardware like with Arduino

pin = 1

gpio.mode(pin, gpio.OUTPUT)

gpio.write(pin, gpio.HIGH)

print(gpio.read(pin))