El control de 2 motores con el

TB6612FNG + Arduino TH
Cerrado martes, 10 de abril de 2012

En primer lugar : Lo sé ... fuimos al agua con la ilustración del motor.

En artículos anteriores hemos hablado de cómo controlar motores con
simples transistores . Y ... con PWM se podía controlar la velocidad. Pero eso es sólo
un motor , y sólo se puede ir en una dirección. Hoy vamos a hablar acerca del controlador de
motor dual TB6612FNG, específicamente la junta TB6612FNG ruptura de Sparkfun .
El TB6612FNG no es sólo un controlador de motor dual, es un doble puente H . Un puente H
es básicamente una configuración específica de transistores que le permiten cambiar la
dirección de la corriente . Así conectado a un motor, que significa que puede tener que girar
en ambas direcciones, y con PWM de entrada, puede utilizar el Arduino para hacerlos girar a
cualquier velocidad. Debido a que el TB6612FNG tiene 2 puentes H, no sólo se puede hacer un
robot vaya hacia delante y hacia atrás, sino también dar la vuelta haciendo que cada giro de la
rueda en una dirección diferente.
Estadísticas rápidas en este chico : Es capaz de suministrar hasta 13 V y 1,2 A (3,2 pico)
Conectarlo
Como se puede deducir de la ilustración de este tipo requiere un par de pines del Arduino para
ponerlo en marcha. Y es probable que se ve muy complicado al principio. Pero no es tan
malo. El primero que hay que notar, sin embargo, es que usted no necesita una fuente de
alimentación externa para sus motores ( el TB6612FNG puede trabajar con 2,5 a 13V ), el
pasador de 5v en el Arduino no puede fuente de energía suficiente para conducir 2 motores, y
se podía dañar su Arduino si lo hace.
Pero ¿por qué se utiliza tantos pasadores es por varias razones. En primer lugar, hay un
pasador de espera, si este perno se mantiene baja, los motores son, básicamente, desconectadas
de la fuente. Y ... Cada motor también tiene 3 pines de control de la dirección, 2, y uno para la
velocidad.
Código
El código para esto es muy básico. Hemos creado una función para la que hace que el control de
la TB6612FNG de su Arduino más fácil, pero también se puede cambiar para arriba y hacerlo a
su propia manera.
Como ya he mencionado anteriormente, cada motor tiene 3 pines de control de la dirección, 2,
y uno para la velocidad. Cuando un pin dirección es alto y el otro es bajo, el motor girará en una
dirección, darles la vuelta y se hace girar la otra dirección (tanto de alta o baja y se detiene el
motor). El pasador de PWM le permite analogWrite a esta clavija para controlar la velocidad de
la que un motor. andlogWrite 0 y se detiene el motor, 255, y va a ir a toda velocidad.
//motor A connected between A01 and A02

//motor B connected between B01 and B02

int STBY = 10; //standby

//Motor A

int PWMA = 3; //Speed control

int AIN1 = 9; //Direction

int AIN2 = 8; //Direction

//Motor B

int PWMB = 5; //Speed control

int BIN1 = 11; //Direction

int BIN2 = 12; //Direction

void setup(){

pinMode(STBY, OUTPUT);

pinMode(PWMA, OUTPUT);

pinMode(AIN1, OUTPUT);

pinMode(AIN2, OUTPUT);

pinMode(PWMB, OUTPUT);

pinMode(BIN1, OUTPUT);

pinMode(BIN2, OUTPUT);

void loop(){

move(1, 255, 1); //motor 1, full speed, left

 move(2, 255, 1); //motor 2, full speed, left

delay(1000); //go for 1 second

stop(); //stop

delay(250); //hold for 250ms until move again

move(1, 128, 0); //motor 1, half speed, right

move(2, 128, 0); //motor 2, half speed, right

delay(1000);

stop();

delay(250);

void move(int motor, int speed, int direction){

//Move specific motor at speed and direction

//motor: 0 for B 1 for A

//speed: 0 is off, and 255 is full speed

//direction: 0 clockwise, 1 counter-clockwise

digitalWrite(STBY, HIGH); //disable standby

boolean inPin1 = LOW;

boolean inPin2 = HIGH;

if(direction == 1){

inPin1 = HIGH;

inPin2 = LOW;
 }

if(motor == 1){

digitalWrite(AIN1, inPin1);

digitalWrite(AIN2, inPin2);

analogWrite(PWMA, speed);

}else{

digitalWrite(BIN1, inPin1);

digitalWrite(BIN2, inPin2);

analogWrite(PWMB, speed);

void stop(){

//enable standby

digitalWrite(STBY, LOW);

}
CONTROLAR DOS
MOTORES DC CON
ARDUINO Y DRIVER
TB6612FNG
SHARE ON:

— 18 AGOSTO, 2016

¿QUÉ ES UN TB6612FNG ?
El TB6612FNG es un controlador (driver) de motores que nos permite manejar dos motores de
corriente continua desde Arduino, variando tanto la velocidad como el sentido de giro.
 El TB6612FNG puede ser considerado una versión mejorada del L298N. Al igual que esté,
internamente está formado por dos puentes-H, junto con la electrónica necesaria para simplificar su
uso, y eliminar posibles cortocircuito por errores de uso.

Sin embargo, en el caso del TB6612FNG los puentes-H están formados por transistores
MOSFET, en lugar de transistores BJT como en el L298N. Esto permite que el TB6612FNG tiene
mejor eficiencia y menores dimensiones que el L298N.

El TB6612FNG también permite controlar intensidades de corriente superiores, siendo capaz

de suministrar 1.2A por canal de forma continua, y 3.2A de pico. Recordar que el L298N tiene una
intensidad máxima teórica de 2A, pero las pérdidas hace que en la práctica sólo pueda suministrar
0.8-1A.

Además, el TB6612FNG no tiene la caída de tensión que sí tiene el L298N debido a sus
transistores BJT, que podían llegar a ser superiores a 3V. En su lugar, el TB6612FNG se comporta
como una pequeña resistencia de 0.5 Ohm.

Como puntos negativos, el TB6612FNG puede proporcionar tensiones inferiores, de hasta

13.5V (frente a los 35V del L298N). Además, es algo más difícil de montar, ya que las placas con
L298N frecuentemente incorporan placas de conexión, que permiten conectar de forma sencilla el
motor.

Finalmente, la protección contra corrientes inducidas son algo más limitadas que las del L298N,
por lo que podemos tener algún reinicio de Arduino cuando alimentamos cargas medianas o grandes.

El TB6612FNG dispone de dos canales, por lo que es posible controlar dos motores de corriente
continua de forma independiente. También puede controlar un único motor paso a paso aunque, en
general, preferiremos usar controladores específicos.

En cada canal podemos controlar el sentido de giro y la velocidad, para lo cual admite una señal
PWM de frecuencia máxima de 100 kHz (muy por debajo del rango normal de PWM en Arduino)

El TB6612FNG dispone de protecciones térmicas, de inversión de corriente en la fuente de

suministro de los motores, condensadores de filtrado en ambas líneas de alimentación, detección de
bajo voltaje, y protecciones contra las corrientes inducidas en los motores.

El TB6612FNG también incorpora un modo de Standby, que desactiva por completo el

controlador, entrando en un modo de ahorro de energía.

El controlador TB6612FNG puede ser empleado en proyectos de electrónica y robótica. Es

ampliamente usado en proyectos electrónico y robótica, por su sencillez de uso, bajo coste, y buena
calidad precio

PRECIO
El controlador TB6612FNG es un dispositivo barato. En un principio el TB6612FNG era más
caro que el L298N, pero los precios descendieron y en la actualidad el TB6612FNG es más barato
que el L298N.
 Podemos encontrar un TB6612FNG por 1,10€ en vendedores internacionales de AliExpress o
eBay.

ESQUEMA DE MONTAJE
El esquema de montaje no es demasiado complicado. Por un lado, suministramos la tensión que
alimentará el motor desde una fuente de alimentación externa, mediante el pin VM. La tensión
máxima es de 15V.

Además, tenemos que alimentar la electrónica del módulo mediante el pin VCC. El rango de
tensión para VCC es 2.7 a 5.5V.

Para el control del módulo Los pines AIN1, AIN2 Y PWMA controlan el canal A, mientras que
los pines BIN1, BIN2, y PWMB controlan el canal B.

Finalmente, el pin STBY controla el modo Standby. Debemos ponerlo en HIGH para activar el
motor. Podemos conectarlo a un pin digital de Arduino, si queremos poder activar el modo Standby,
o conectarlo a VCC si queremos dejarlo permanentemente desconectado.
La conexión, vista desde Arduino quedaría de la siguiente forma.
EJEMPLOS DE CÓDIGO
El código necesario es similar al que vimos al ver el L298N. Igualmente, conviene que
agrupemos el código en funciones que podamos reutilizar, o el código crecerá rápidamente.

El siguiente código permite desplazar y girar un vehículo, actuando sobre ambos motores.
Empleamos el modo Standby para reducir el consumo cuando esté parado, alargando la batería.

1 const int pinPWMA = 6;

2 const int pinAIN2 = 7;

3 const int pinAIN1 = 8;

4 const int pinBIN1 = 9;

5 const int pinBIN2 = 10;

6 const int pinPWMB = 11;

7 const int pinSTBY = 12;

9 const int waitTime = 2000; //espera entre fases

10 const int speed = 200; //velocidad de giro

11

12 const int pinMotorA[3] = { pinPWMA, pinAIN2, pinAIN1 };

13 const int pinMotorB[3] = { pinPWMB, pinBIN1, pinBIN2 };

14

15 enum moveDirection {

16 forward,

17 backward

18 };

19

20 enum turnDirection {

21 clockwise,

22 counterClockwise

23 };
24

25 void setup()

26 {

27 pinMode(pinAIN2, OUTPUT);

28 pinMode(pinAIN1, OUTPUT);

29 pinMode(pinPWMA, OUTPUT);

30 pinMode(pinBIN1, OUTPUT);

31 pinMode(pinBIN2, OUTPUT);

32 pinMode(pinPWMB, OUTPUT);

33 }

34

35 void loop()

36 {

37 enableMotors();

38 move(forward, 180);

39 delay(waitTime);

40

41 move(backward, 180);

42 delay(waitTime);

43

44 turn(clockwise, 180);

45 delay(waitTime);

46

47 turn(counterClockwise, 180);

48 delay(waitTime);

49

50 fullStop();

51 delay(waitTime);

52 }

53

54 //Funciones que controlan el vehiculo

55 void move(int direction, int speed)

56 {
57 if (direction == forward)

58 {

59 moveMotorForward(pinMotorA, speed);

60 moveMotorForward(pinMotorB, speed);

61 }

62 else

63 {

64 moveMotorBackward(pinMotorA, speed);

65 moveMotorBackward(pinMotorB, speed);

66 }

67 }

68

69 void turn(int direction, int speed)

70 {

71 if (direction == forward)

72 {

73 moveMotorForward(pinMotorA, speed);

74 moveMotorBackward(pinMotorB, speed);

75 }

76 else

77 {

78 moveMotorBackward(pinMotorA, speed);

79 moveMotorForward(pinMotorB, speed);

80 }

81 }

82

83 void fullStop()

84 {

85 disableMotors();

86 stopMotor(pinMotorA);

87 stopMotor(pinMotorB);

88 }

89
90 //Funciones que controlan los motores

91 void moveMotorForward(const int pinMotor[3], int speed)

92 {

93 digitalWrite(pinMotor[1], HIGH);

94 digitalWrite(pinMotor[2], LOW);

95

96 analogWrite(pinMotor[0], speed);

97 }

98

99 void moveMotorBackward(const int pinMotor[3], int speed)

100 {

101 digitalWrite(pinMotor[1], LOW);

102 digitalWrite(pinMotor[2], HIGH);

103

104 analogWrite(pinMotor[0], speed);

105 }

106

107 void stopMotor(const int pinMotor[3])

108 {

109 digitalWrite(pinMotor[1], LOW);

110 digitalWrite(pinMotor[2], LOW);

111

112 analogWrite(pinMotor[0], 0);

113 }

114

115 void enableMotors()

116 {

117 digitalWrite(pinSTBY, HIGH);

118 }

119

120 void disableMotors()

121 {

122 digitalWrite(pinSTBY, LOW);

123 }

En un proyecto complejo, estas funciones estarían integradas en los objetos que integran nuestro
modelo.

//bluetooth hc-06
int ledPin = 12; // usamos un pin de salida al LED
int state = 0; // Variable lectrura serial

void setup() {
pinMode(ledPin, OUTPUT); //Declara pin de Salida
digitalWrite(ledPin, LOW); //Normalmente Apagado
Serial.begin(9600);
}

void loop() {
//si el modulo a manda dato, guardarlo en estado.
if(Serial.available() > 0){
state = Serial.read();
} // esta parte del código es para solo 1 Carácter o Unidad.

// si el estado es 0 ese sería Apagado “OFF”

if (state == '0') {
digitalWrite(ledPin, LOW);
Serial.println("LED: off");
}

// de lo contrario si el estado es 1 ese sería Encendido “ON”

else
if (state == '1') {
digitalWrite(ledPin, HIGH);
Serial.println("LED: on");
}