El controlador de motor / Puente H

Si desea implementar proyectos con motores que necesitan más potencia o que deben tener velocidad variable, por lo general se utilizan módulos con el conocido Puente-H. Estos módulos se pueden encontrar bajo el término genérico de Controlador de motor o Paso a paso DC.

En muchos casos, especialmente si los busca en tiendas en línea, los encontrará como los llamados Doble puente H o puentes en H Dual. Pero, ¿qué es un Puente-H y cómo se utiliza exactamente? Estos fundamentos y muchas otras preguntas sobre el uso de estos componentes se aclaran en esta publicación de blog.

El hardware y el software de este blog

Los componentes de tabla 1 sirven como hardware de referencia para este blog, pero en principio se puede utilizar cualquier puente en H o microcontrolador.

Mesa 1: Hardware para prueba

Para poder replicar este blog, necesita el siguiente software y bibliotecas:

• IDE de Arduino (https://www.arduino.cc/en/Main/Software), es mejor descargar la última versión aquí.

El Puente-H o el regulador de cuatro cuadrantes

Si empieza a buscar el Puente-H en Internet, normalmente encontrará dos definiciones. La primera es el circuito puente, y la otra es el controlador de cuatro cuadrantes. Ambas son Puentes-H, pero se diferencian en algunos detalles. Estrictamente hablando, un controlador de motor o un motor paso a paso de DC no es un Puente- H, sino un controlador de cuatro cuadrantes. El motivo de esto, se debe aclarar con una comparación.

El puente H - circuito de puente

El primer Puente-H de este blog será el circuito de puente. Esto también se conoce en los términos especializados como circuito H o cuarto, medio o puente completo. También se lo denomina incorrectamente en algunos foros como un puente de medición de Wheatstone, pero esto no es correcto. También los hay, pero con eso se refiere a algo más.

El Puente-H, denominado a continuación circuito puente, debe su nombre a la disposición de los componentes eléctricos, en su mayoría resistencias, observe la ilustración 1.

Ilustración 1: Estructura básica del circuito del puente, de Wikipedia MovGP0

Si toma el circuito que se observa en la imagen superior como base, un circuito puente no es más que una conexión en paralelo de dos divisores de voltaje. Sin embargo, hay una rama entre los dos divisores de voltaje, por lo que el circuito base es como una "H" y por este motivo se genera el nombre puente-H.

Este puente se puede utilizar para voltaje CC y CA, pero depende de si desea medir resistencias, condensadores o bobinas. Otra propiedad del circuito puente es que, dependiendo de la configuración de las resistencias, no solo puede variar la corriente y el voltaje, ¡sino también puede cambiar la polaridad! Dependiendo de cuántas resistencias sean variables, el circuito puente también se llama cuarto (una resistencia), medio (dos resistencias) o puente completo (todas las resistencias).

El inconveniente en este segmento, es que no es tan fácil cambiar las resistencias de un motor tan rápido.

El Puente-H: regulador de cuatro cuadrantes

Con respecto al problema anterior, pasamos directamente al siguiente H-Bridge de nuestro blog. Esto también se denomina controlador de cuatro cuadrantes y asume exactamente la tarea necesaria para controlar un motor. Este puente en H, en lo sucesivo denominado controlador de cuatro cuadrantes, se puede encontrar en muchos dispositivos con motor. Se utiliza desde el vehículo más pequeño hasta, por ejemplo, el ICE de Deutsche Bahn.

Si observa detenidamente el regulador de cuatro cuadrantes, consulte Figura 2, la estructura básica es similar al circuito puente.

Ilustración 2: Estructura básica del regulador de cuatro cuadrantes, de Wikipedia Biezl

La diferencia es que las resistencias del circuito puente han sido reemplazadas por MOSFET y diodos de bloqueo (diodo de recuperación de autoinducción). El motor está ubicado en la interconexión de los dos circuitos en paralelo. Similar a cambiar las resistencias del circuito puente, esto puede cambiar la polaridad. El voltaje y la corriente deben configurarse correctamente en los terminales de conexión.

Esto ya explica mejor cómo funciona aproximadamente el controlador de cuatro cuadrantes. Ahora se debe especificar la razón del nombre del regulador de cuatro cuadrantes. Dependiendo de cómo se conmuten los MOSFET (T1 a T4), se puede usar uno de los cuatro estados, los cuadrantes, se pueden utilizar para el motor. La Tabla 2 enumera los cuatro cuadrantes, con los MOSFET para T1 a T4, la Ilustración 2 se entiende.

Mesa 2: Los cuatro cuadrantes:

Dependiendo de los MOSFET conmutados, puede elegir cualquier dirección de rotación y el tipo de aceleración del motor. Como ya se escribió anteriormente, el voltaje y la corriente deben provenir de la fuente de voltaje y no se pueden cambiar en el controlador de cuatro cuadrantes.

El conductor del motor en la práctica

Ahora que se ha explicado la teoría, el controlador de motor se debe ensamblar y utilizar en la práctica. Los componentes para esto se pueden encontrar en la tabla 1. En principio, todos nuestros microcontroladores a excepción del ESP-01 son adecuados para esta tarea.

El primer paso es el Nano V3.0. No importa si ahora está utilizando el cable USB, observe la Ilustración 3 del Nano, o a través de una fuente de alimentación externa, por ejemplo, también a través de los 5 V disponibles del controlador de motor que se utiliza aquí, consulte la Ilustración 4, operar. Los motores siempre deben ser alimentados por una batería o una batería recargable.

Ilustración 3: Nano con alimentación USB

 Ilustración 4: Nano con alimentación de 5V del puente H

Tenga en cuenta que si utiliza voltajes superiores a 12 V en el controlador del motor, se debe quitar el puente de 5 V en el controlador del motor y se requiere una fuente de voltaje separada para el microcontrolador.

Para una demostración simple de cómo conducir un motor pequeño, puede Codigo 1 usar.

//-----------------------------------------------------
// Controlling a DC-Motor with Nano V3.0
// Autor: Joern Weise
// License: GNU GPl 3.0
// Created: 23. Feb 2021
// Update: 23. Feb 2021
//-----------------------------------------------------

//PWM and motor configuration
// Motor A
const int motor1Pin1 = 9;
const int motor1Pin2 = 8;
const int enable1Pin = 10;

void setup() {
Serial.begin(115200);
while (!Serial) {
; //Wait until serial is available
}
Serial.println("Motor control with NANO V3.0");
Serial.println("(c) Joern Weise for AZ-Delivery");
Serial.println("--------------------");
Serial.println("Set outputs");

//Set pins as outputs
pinMode(motor1Pin1, OUTPUT);
pinMode(motor1Pin2, OUTPUT);
pinMode(enable1Pin, OUTPUT);

Serial.println("Setup finished");
}

void loop() {
Serial.println("----- Motor clockwise speedup-----");
digitalWrite(motor1Pin1,HIGH);
// A = HIGH and B = LOW means the motor will turn right
digitalWrite(motor1Pin2,LOW);
for (int i=0; i<256; i+=5)
{
Serial.println("Speed:" + String(i));
analogWrite(enable1Pin, i);
delay(100);
}

Serial.println("----- Motor clockwise break-----");
for (int i=255; i>0; i-=5)
{
Serial.println("Speed:" + String(i));
analogWrite(enable1Pin, i);
delay(100);
}

Serial.println("----- Motor counterclockwise speedup-----");
digitalWrite(motor1Pin1,LOW);
// A = HIGH and B = LOW means the motor will turn right
digitalWrite(motor1Pin2,HIGH);
for (int i=0; i<256; i+=5)
{
Serial.println("Speed:" + String(i));
analogWrite(enable1Pin, i);
delay(100);
}
Serial.println("----- Motor counterclockwise break-----");
for (int i=255; i>0; i-=5)
{
Serial.println("Speed:" + String(i));
analogWrite(enable1Pin, i);
delay(100);
}
}

Código 1: Código de demostración para Nano V3.0

En principio, el código no hace mucho que sea sorprendente. Se encarga de encender el motor una vez en el sentido de las agujas del reloj y lo acelera hasta su máxima velocidad. Inmediatamente después, el motor se frena de nuevo hasta detenerse. Para mostrar que esto no solo funciona en una dirección, se vuelve a realizar el mismo control en sentido contrario a las agujas del reloj.

Una vez que se ha ejecutado la función loop, el proceso comienza de nuevo. Para que pueda comprender rápidamente lo que está sucediendo, se han agregado muchos comentarios al código fuente.

Eso nos lleva a la familia ESP en este punto. Independientemente de si se trata de un controlador de la familia ESP32 o ESP8266, la conexión también es casi idéntica aquí. El cableado de la fuente de alimentación con cable USB, consulte Ilustración 5, o con la conexión de 5V del controlador de motor, observe Ilustración 6, también se hace rápidamente.

Una palabra más sobre la placa de controlador de motor L298N utilizada aquí. En comparación con las placas L293D, que también son adecuadas, aquí ya está instalado un disipador de calor para corrientes más altas y, por lo tanto, motores más grandes. Después de que usamos inicialmente un convertidor de nivel lógico para los microcontroladores Espressif para ajustar el voltaje de salida en los GPIO de 3.3V de los ESP a 5V, descubrimos en experimentos adicionales que el voltaje en el pin de habilitación del MotorDriver es una especie de referencia el voltaje para las señales PWM es; Entonces, un ciclo de trabajo del 100% entrega el voltaje de salida completo para los motores incluso a 3.3V. Por tanto, se puede prescindir de la LLC.

Ilustración 5: Microcontrolador de la familia ESP32 con alimentación USB

Ilustración 6: Microcontrolador de la familia ESP32 con alimentación de 5V

En este punto, también, se debe quitar el puente de 5V para voltajes superiores a 12V en el controlador del motor y se requiere una fuente de voltaje separada para el microcontrolador.

Desafortunadamente, no podemos tomar completamente el ejemplo de Nano V3.0, consulte Codigo 2, porque la señal PWM tiene que ser programada de manera diferente y también usamos otros pines.

//-----------------------------------------------------
// Controlling a DC-Motor with ESP
// Autor: Joern Weise
// License: GNU GPl 3.0
// Created: 23. Feb 2021
// Update: 23. Feb 2021
//-----------------------------------------------------

//PWM and motor configuration
// Motor A
const int motor1Pin1 = 27;
const int motor1Pin2 = 26;
const int enable1Pin = 14;
const int motor1channel = 0;

// Setting PWM properties
const int freq = 30000;
const int resolution = 8;

void setup() {
Serial.begin(115200);
while (!Serial) {
; //Wait until serial is available
}
Serial.println("Motor control with ESP");
Serial.println("(c) Joern Weise for AZ-Delivery");
Serial.println("--------------------");
Serial.println("Set outputs");

//Set pins as outputs
pinMode(motor1Pin1, OUTPUT);
pinMode(motor1Pin2, OUTPUT);
pinMode(enable1Pin, OUTPUT);

Serial.println("Configurate motorchannel");
ledcSetup(motor1channel, freq, resolution);
//Configurate PWM for motor 1
ledcAttachPin(enable1Pin, motor1channel);
//Attach channel 1 to motor 1
Serial.println("Setup finished");
}

void loop() {
Serial.println("----- Motor clockwise speedup-----");
digitalWrite(motor1Pin1,HIGH);
// A = HIGH and B = LOW means the motor will turn right
digitalWrite(motor1Pin2,LOW);
for (int i=0; i<256; i+=5)
{
Serial.println("Speed:" + String(i));
ledcWrite(motor1channel, i);
delay(100);
}
Serial.println("----- Motor clockwise break-----");
for (int i=255; i>0; i-=5)
{
Serial.println("Speed:" + String(i));
ledcWrite(motor1channel, i);
delay(100);
}

Serial.println("----- Motor counterclockwise speedup-----");
digitalWrite(motor1Pin1,LOW);
// A = HIGH and B = LOW means the motor will turn right
digitalWrite(motor1Pin2,HIGH);
for (int i=0; i<256; i+=5)
{
Serial.println("Speed:" + String(i));
ledcWrite(motor1channel, i);
delay(100);
}
Serial.println("----- Motor counterclockwise break-----");
for (int i=255; i>0; i-=5)
{
Serial.println("Speed:" + String(i));
ledcWrite(motor1channel, i);
delay(100);
}
}

Código 2: Código de demostración para MicroController der ESP32-Familie

Al igual que con el Nano V3.0,  se han agregado muchos comentarios a este código para que pueda observar rápidamente donde es lo que está sucediendo. Preste especial atención a la función de configuración, en la que se declara el PWM. A través de "ledcSetup (motor1channel, freq, resolution);" se declara un canal PWM con una resolución de 8 bits y una frecuencia de 30 kHz. Inmediatamente después, "ledcAttachPin (iPWMPin, motor1channel);" el canal PWM se vincula al pin de salida. 

Como puede observar, controlar un motor utilizando un Puente-H o, mejor aun, un controlador de motor no es muy complicado. El principio del control es simple, puramente la lógica de cuando el motor debe hacer lo que debe ser procesado adecuadamente en su código. Un ejemplo simple de esto se puede encontrar en la publicación del blog Controlling a Robot with MQTT - [Part 3]. Este Puente-H es necesario para que los motores giren a cualquier velocidad y dirección. Ya puede revisar los otros artículos sobre el tema principal de los coches robot, donde seguramente encontrará de nuevo un Puente-H o un controlador de motor.

Ya puedes esperar las próximas aportaciones al tema de enfoque del robot Coches, donde seguramente volverás a encontrar un puente H o un controlador de motor.

Este y otros proyectos los puede encontrar en GitHub
https://github.com/M3taKn1ght/Blog-Repo.