El control de 2 motores con el TB6612FNG + Arduino Cerrado martes, 10 de abril de
TH
2012
En primer lugar : lugar : Lo sé ... fuimos f uimos al agua con la ilustración del motor. En artículos anteriore anteriores s 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 la junta TB6612FNG 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 : chico : Es capaz de suministrar hasta 13 V 13 V y y 1,2 A 1,2 A (3,2 (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 A liExpress 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; 8 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"); } }
