Control de motores CC con el controlador de motor DRV8833 y Arduino

Sin duda, L293D y L298N son los controladores de motor elegidos para proyectos Arduino. Son confiables y se han utilizado en cientos, si no miles, de proyectos. Sin embargo, tienen una gran desventaja: utilizan transistores bipolares (BJT), lo que los hace extremadamente ineficientes.

El problema con los BJT es que tienen una caída de voltaje cuando se encienden. La energía de esta tensión tiene que ir a alguna parte, y así es. se desprende en forma de calor. Esto puede provocar una pérdida significativa de energía con el tiempo y, en algunos casos, provocar un sobrecalentamiento del conductor. Esto puede ser una desventaja importante para proyectos que deben ejecutarse durante un período de tiempo más largo.

Afortunadamente, los controladores de motor modernos como el DRV8833 realmente brillan en términos de eficiencia. En lugar de BJT, el DRV8833 utiliza MOSFET. Los MOSFET tienen una caída de voltaje casi insignificante, lo que significa que casi todo el voltaje de la fuente de alimentación se entrega al motor. Por esta razón, el DRV8833 no sólo es más eficiente energéticamente que los controladores de motor basados ​​en BJT, sino que también genera mucho menos calor, lo que hace que su uso sea más seguro durante períodos de tiempo más prolongados.

Profundicemos y descubramos las extraordinarias capacidades del controlador de motor DRV8833.

Controlador de motor DRV8833

En el corazón del módulo hay un CI de controlador H-Bridge integrado de Texas Instruments optimizado para aplicaciones de accionamiento de motor: el DRV8833.

El DRV8833 cuenta con dos controladores de puente H NMOS, lo que le permite controlar dos motores de CC con escobillas, un motor paso a paso bipolar, solenoides y otras cargas inductivas.

Funciona en un rango de voltaje de 2,7 V a 10,8 V y puede entregar continuamente hasta 1,2 A por canal. Además, puede soportar picos de corriente de hasta 2 A por canal durante unos segundos.

El DRV8833 también tiene una serie de funciones de protección como: B. Bloqueo por subtensión, protección contra sobrecorriente y sobretemperatura, proporcionando un alto nivel de confiabilidad. Cada uno de estos eventos desactiva los MOSFET H-Bridge. Una vez corregida una condición de error, el dispositivo reanuda su funcionamiento.

También cuenta con un modo de ahorro de energía que permite ahorrar energía, especialmente cuando los motores no están en uso.

Todas estas características lo convierten en una excelente opción para accionar motores pequeños de bajo voltaje.

Especificaciones técnicas

Aquí están las especificaciones:

Puede encontrar más información en la siguiente hoja de datos.

Configuración de pines del controlador del motor DRV8833

El controlador DRV8833 tiene un total de 12 pines que lo conectan con el mundo exterior. La asignación de pines es la siguiente:

Conozcamos cada pin individualmente.

Pines de alimentación

A diferencia de la mayoría de los controladores de motor, el DRV8833 solo tiene una conexión de fuente de alimentación (ya que el voltaje del motor coincide con el voltaje lógico).

VCC Y Tierra Aquí es donde se conecta la fuente de alimentación que acciona los motores. El voltaje puede estar entre 2,7V y 10,8V.

pines de salida

Los pines de salida del controlador del motor DRV8825, a saber SALIDA1, OUT2, OUT3Y OUT4están convenientemente ubicados en un lado del módulo, lo que permite una fácil conexión.

El motor A debe conectarse a OUT1 y OUT2, mientras que el motor B debe conectarse a OUT3 y OUT4. Puede conectar cualquier motor de CC con escobillas con un voltaje de 2,7 V a 10,8 V a estos pines.

Tenga en cuenta que el DRV8833 puede suministrar continuamente 1,2 A por canal (pico de 2 A) a un par de motores de CC.

Pines de entrada de control

Cada motor tiene dos entradas de control; EN 1 Y EN 2 son las entradas de control para el motor A, mientras que EN 3 Y IN4 son para el motor B. Con estas entradas de control se puede controlar tanto la velocidad como el sentido de rotación del motor.

Control de dirección:

La dirección de rotación del motor se puede controlar aplicando lógica ALTA (5 V) o lógica BAJA (tierra) a estas entradas. La siguiente tabla de verdad muestra cómo las entradas afectan las salidas del controlador.

Control de velocidad:

Si desea controlar la velocidad, puede usar la modulación de ancho de pulso (PWM) en el pin normalmente alto. Si no se requiere control de velocidad, simplemente configúrelo en ALTO o BAJO.

Pin del modo de suspensión

El DORMIR El pin (marcado EEP en la pantalla del tablero) controla el modo de suspensión del DRV8833. Configurar este pin en un nivel bajo pondrá el DRV8833 en modo de ahorro de energía, mientras que configurarlo en un nivel alto lo activará nuevamente.

En este modo, los puentes H están desactivados, la bomba de carga del controlador de puerta se detiene, se restablece toda la lógica interna, se detienen todos los relojes internos y se ignoran todas las entradas. Es importante tener en cuenta que el controlador del motor requiere una pequeña cantidad de tiempo (hasta 1 milisegundo) para volver a estar completamente operativo después de regresar del modo de suspensión.

De forma predeterminada, el pin SLEEP del tablero está hacia arriba. Entonces, si no planeas usar el modo de ahorro de energía, simplemente puedes dejarlo desconectado.

Hay un puente de soldadura J1 en la parte posterior del módulo DRV8833.

De forma predeterminada, J1 está cerrado, lo que conecta un pullup integrado al pin SLEEP, manteniendo así el DRV8833 habilitado. Sin embargo, abrir J1 desconectará el pullup integrado del pin SLEEP. Esta acción habilita el menú desplegable en el chip, lo que significa que el DRV8833 permanece deshabilitado de forma predeterminada. Entonces, si elige abrir J1, recuerde que tendrá que encender el DRV8833 manualmente si es necesario.

Pluma de detección de errores

El ERROR El pin (etiquetado como ULT en la pantalla de la placa) es una salida de drenaje abierto que el chip reduce cuando ocurre una condición de sobrecorriente, sobretemperatura o subtensión.

De forma predeterminada, este pin permanece en estado flotante. Entonces, si desea monitorear las condiciones de error en el controlador, necesita conectar una resistencia pull-up externa (o usar una entrada de microcontrolador que tenga su pull-up incorporado habilitado).

Limitación actual

El DRV8833 puede limitar activamente la corriente que fluye a través de los motores. Esto generalmente se logra conectando una resistencia entre el pin AISEN y tierra para establecer el límite para el Motor A y otra resistencia entre el pin BISEN y tierra para establecer el límite para el Motor B.

Sin embargo, esta placa de conexión DRV8833 en particular conecta estos pines de detección de corriente directamente a tierra, desactivando efectivamente la función de limitación de corriente.

Cableado de un módulo DRV8833 a un Arduino

Ahora que sabemos todo sobre el módulo, ¡podemos empezar a conectarlo a nuestro Arduino!

Primero conecte la fuente de alimentación del motor. El pin VCC es la fuente de alimentación para los motores y debe conectarse a una fuente de alimentación adecuada según los requisitos de su motor (2,7 V a 10,8 V). En nuestro experimento, utilizamos motores con engranajes de CC, también llamados motores «TT», que se encuentran comúnmente en robots con tracción en dos ruedas. Están diseñados para 3 a 12 V. Por tanto, conectaremos una fuente de alimentación externa de 5V al pin VCC.

Ahora conecte las entradas de control del DRV8833 (IN1, IN2, IN3 e IN4) a los cuatro pines de salida digital (10, 9, 6 y 5) del Arduino. Tenga en cuenta que todos estos pines son compatibles con PWM.

Conecte un motor al terminal A (OUT1 y OUT2) y el otro al terminal B (OUT3 y OUT4). Puede reemplazar las conexiones de su motor. Técnicamente no existe una forma correcta o incorrecta.

Si desea monitorear las condiciones de falla, puede conectar el pin FALLO a un pin digital en el Arduino. Recuerde usar una resistencia pull-up externa o habilitar la resistencia pull-up incorporada en el Arduino para este pin, ya que es una salida de drenaje abierto.

Finalmente, asegúrese de que su circuito y el Arduino tengan una conexión a tierra común.

La siguiente tabla enumera los conectores de clavijas para conectar el controlador del motor DRV8833 al Arduino:

La siguiente imagen muestra cómo se construye el circuito.

código de ejemplo de arduino

El siguiente esquema muestra cómo controlar la velocidad y la dirección de rotación de un par de motores de CC utilizando el controlador de motor DRV8833 y puede servir como base para futuros experimentos y proyectos prácticos.

El boceto mueve un par de motores de CC a diferentes velocidades y direcciones.

// Define the control inputs
#define MOT_A1_PIN 10
#define MOT_A2_PIN 9
#define MOT_B1_PIN 6
#define MOT_B2_PIN 5

void setup(void)
{
  // Set all the motor control inputs to OUTPUT
  pinMode(MOT_A1_PIN, OUTPUT);
  pinMode(MOT_A2_PIN, OUTPUT);
  pinMode(MOT_B1_PIN, OUTPUT);
  pinMode(MOT_B2_PIN, OUTPUT);

  // Turn off motors - Initial state
  digitalWrite(MOT_A1_PIN, LOW);
  digitalWrite(MOT_A2_PIN, LOW);
  digitalWrite(MOT_B1_PIN, LOW);
  digitalWrite(MOT_B2_PIN, LOW);

  // Initialize the serial UART at 9600 baud
  Serial.begin(9600);
}

void loop(void)
{
  // Generate a fixed motion sequence to demonstrate the motor modes.

  // Ramp speed up.
  for (int i = 0; i < 11; i++) {
    spin_and_wait(25*i, 25*i, 500);
  }
  // Full speed forward.
  spin_and_wait(255,255,2000);

  // Ramp speed into full reverse.
  for (int i = 0; i < 21 ; i++) {
    spin_and_wait(255 - 25*i, 255 - 25*i, 500);
  }

  // Full speed reverse.
  spin_and_wait(-255,-255,2000);

  // Stop.
  spin_and_wait(0,0,2000);

  // Full speed, forward, turn, reverse, and turn for a two-wheeled base.
  spin_and_wait(255, 255, 2000);
  spin_and_wait(0, 0, 1000);
  spin_and_wait(-255, 255, 2000);
  spin_and_wait(0, 0, 1000);
  spin_and_wait(-255, -255, 2000);
  spin_and_wait(0, 0, 1000);
  spin_and_wait(255, -255, 2000);
  spin_and_wait(0, 0, 1000);
}

/// Set the current on a motor channel using PWM and directional logic.
///
/// param pwm    PWM duty cycle ranging from -255 full reverse to 255 full forward
/// param IN1_PIN  pin number xIN1 for the given channel
/// param IN2_PIN  pin number xIN2 for the given channel
void set_motor_pwm(int pwm, int IN1_PIN, int IN2_PIN)
{
  if (pwm < 0) {  // reverse speeds
    analogWrite(IN1_PIN, -pwm);
    digitalWrite(IN2_PIN, LOW);

  } else { // stop or forward
    digitalWrite(IN1_PIN, LOW);
    analogWrite(IN2_PIN, pwm);
  }
}

/// Set the current on both motors.
///
/// param pwm_A  motor A PWM, -255 to 255
/// param pwm_B  motor B PWM, -255 to 255
void set_motor_currents(int pwm_A, int pwm_B)
{
  set_motor_pwm(pwm_A, MOT_A1_PIN, MOT_A2_PIN);
  set_motor_pwm(pwm_B, MOT_B1_PIN, MOT_B2_PIN);

  // Print a status message to the console.
  Serial.print("Set motor A PWM = ");
  Serial.print(pwm_A);
  Serial.print(" motor B PWM = ");
  Serial.println(pwm_B);
}

/// Simple primitive for the motion sequence to set a speed and wait for an interval.
///
/// param pwm_A  motor A PWM, -255 to 255
/// param pwm_B  motor B PWM, -255 to 255
/// param duration delay in milliseconds
void spin_and_wait(int pwm_A, int pwm_B, int duration)
{
  set_motor_currents(pwm_A, pwm_B);
  delay(duration);
}

Explicación del código:

El código Arduino es bastante simple. No se requieren bibliotecas para su funcionamiento. El boceto comienza declarando los pines de Arduino que están conectados a los pines de control del DRV8833.

// Define the control inputs
#define MOT_A1_PIN 10
#define MOT_A2_PIN 9
#define MOT_B1_PIN 6
#define MOT_B2_PIN 5

La sección de configuración del código inicializa el hardware. Configura todos los pines de control del motor como SALIDA digital y los establece en BAJO para desactivar inicialmente ambos motores. Luego, la comunicación en serie se inicializa con una velocidad de baudios de 9600.

void setup(void)
{
  // Set all the motor control inputs to OUTPUT
  pinMode(MOT_A1_PIN, OUTPUT);
  pinMode(MOT_A2_PIN, OUTPUT);
  pinMode(MOT_B1_PIN, OUTPUT);
  pinMode(MOT_B2_PIN, OUTPUT);

  // Turn off motors - Initial state
  digitalWrite(MOT_A1_PIN, LOW);
  digitalWrite(MOT_A2_PIN, LOW);
  digitalWrite(MOT_B1_PIN, LOW);
  digitalWrite(MOT_B2_PIN, LOW);

  // Initialize the serial UART at 9600 baud
  Serial.begin(9600);
}

La sección de bucle del código genera una secuencia de movimiento fija para demostrar los modos del motor.

Comienza aumentando gradualmente la velocidad de los motores, luego alcanza la velocidad máxima, vuelve a desacelerar e invierte la dirección a la velocidad máxima y finalmente se detiene.

// Ramp speed up.
for (int i = 0; i < 11; i++) {
  spin_and_wait(25*i, 25*i, 500);
}
// Full speed forward.
spin_and_wait(255,255,2000);

// Ramp speed into full reverse.
for (int i = 0; i < 21 ; i++) {
  spin_and_wait(255 - 25*i, 255 - 25*i, 500);
}

// Full speed reverse.
spin_and_wait(-255,-255,2000);

// Stop.
spin_and_wait(0,0,2000);

Después de detenerse, se demuestra una operación de giro para una base de robot de dos ruedas, donde una rueda se mueve hacia adelante y la otra hacia atrás, lo que hace que el robot gire. Una vez demostrados todos estos movimientos, se repite el bucle.

// Full speed, forward, turn, reverse, and turn for a two-wheeled base.
spin_and_wait(255, 255, 2000);
spin_and_wait(0, 0, 1000);
spin_and_wait(-255, 255, 2000);
spin_and_wait(0, 0, 1000);
spin_and_wait(-255, -255, 2000);
spin_and_wait(0, 0, 1000);
spin_and_wait(255, -255, 2000);
spin_and_wait(0, 0, 1000);

Hay tres funciones personalizadas utilizadas en este boceto: set_motor_pwm(), set_motor_currents()Y spin_and_wait().

El set_motor_pwm() La función ajusta la corriente en un canal del motor usando PWM y lógica direccional. Si el pwm Si el valor es negativo, el motor gira en una dirección. Si el pwm Si el valor es 0 o positivo, el motor se detendrá o girará en la otra dirección.

void set_motor_pwm(int pwm, int IN1_PIN, int IN2_PIN)
{
  if (pwm < 0) {  // reverse speeds
    analogWrite(IN1_PIN, -pwm);
    digitalWrite(IN2_PIN, LOW);

  } else { // stop or forward
    digitalWrite(IN1_PIN, LOW);
    analogWrite(IN2_PIN, pwm);
  }
}

El set_motor_currents() La función utiliza la función anterior para configurar las corrientes para ambos motores. Imprime los valores PWM actuales para cada motor en el monitor serie.

void set_motor_currents(int pwm_A, int pwm_B)
{
  set_motor_pwm(pwm_A, MOT_A1_PIN, MOT_A2_PIN);
  set_motor_pwm(pwm_B, MOT_B1_PIN, MOT_B2_PIN);

  // Print a status message to the console.
  Serial.print("Set motor A PWM = ");
  Serial.print(pwm_A);
  Serial.print(" motor B PWM = ");
  Serial.println(pwm_B);
}

El spin_and_wait() La función establece la velocidad y espera un cierto tiempo antes de pasar al siguiente comando. Utiliza el set_motor_currents() Función para configurar los valores PWM para ambos motores y luego esperar los especificados duration en milisegundos.

void spin_and_wait(int pwm_A, int pwm_B, int duration)
{
  set_motor_currents(pwm_A, pwm_B);
  delay(duration);
}