Neste tutorial, vais aprender a controlar um motor de passo com o driver de microstepping TB6600 e Arduino. Este driver é fácil de usar e pode controlar motores de passo grandes como um 3 A NEMA 23.
Incluí um diagrama de ligação e 3 exemplos de código. No primeiro exemplo, vou mostrar-te como usar este driver de motor de passo sem uma biblioteca Arduino.
Este exemplo pode ser usado para fazer o motor girar continuamente. No segundo exemplo, vamos ver como controlar a velocidade, o número de voltas e a direção de rotação do motor de passo.
Finalmente, vamos analisar a AccelStepper biblioteca. Esta biblioteca é bastante fácil de usar e permite adicionar aceleração e desaceleração ao movimento do motor de passo.
Após cada exemplo, explico detalhadamente como o código funciona, para que não tenhas problemas em modificá-lo conforme as tuas necessidades.
Materiais
Componentes de hardware
| TB6600 stepper motor driver | × 1 | Amazon | |
 | NEMA 23 stepper motor | × 1 | Amazon |
 | Arduino Uno Rev3 | × 1 | Amazon |
| Power supply (24/36 V) | × 1 | Amazon | |
| Jumper wires | × 4 | Amazon | |
| USB cable type A/B | × 1 | Amazon |
Ferramentas
| Wire stripper | Amazon | ||
| Small screwdriver | Amazon | ||
| Self-adjusting crimping pliers (recomendado)* | Amazon | ||
| Wire ferrules assortment (recomendado)* | Amazon |
*Hackaday escreveu um ótimo artigo sobre os benefícios de usar terminais de cabo (também conhecidos como mangas de extremidade).
Software
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Sobre o driver
O TB6600 driver de microstepping é baseado no circuito integrado Toshiba TB6600HG e pode ser usado para controlar motores de passo bipolares de duas fases.
Com uma corrente máxima contínua de 3,5 A, o driver TB6600 pode controlar motores de passo bastante grandes, como um NEMA 23. Certifica-te de não ligar motores com uma corrente nominal superior a 3,5 A ao driver.
O driver tem várias funções de segurança integradas, como proteção contra sobrecorrente, desligamento por subtensão e proteção contra sobreaquecimento.
Podes encontrar mais especificações na tabela abaixo. Note que as especificações e dimensões exatas podem variar ligeiramente entre fabricantes. Sempre consulta o datasheet do teu driver antes de ligar a alimentação.
Especificações do TB6600
| Tensão de operação | 9 – 42 V |
| Corrente máxima de saída | 4,5 A por fase, 5,0 A pico1 |
| Resolução de microstep | completo, 1/2, 1/4, 1/8 e 1/162 |
| Proteção | Desligamento por baixa tensão, proteção contra sobreaquecimento e sobrecorrente |
| Dimensões | 96 x 72 x 28/36 mm |
| Espaçamento dos furos | 88, ⌀ 5 mm |
| Custo | Check price |
1 Estas são as especificações do CI TB6600HG; o driver em si tem uma corrente máxima de 3,5 A e pico de 4,0 A.
2 Ver comentário sobre drivers TB6600 falsificados/atualizados abaixo.
Para mais informações, podes consultar o datasheet e o manual abaixo:
Drivers TB6600 falsificados ou ‘atualizados’
Recentemente desmontei um dos drivers TB6600 que encomendei e descobri que não usava realmente um chip TB6600HG. Em vez disso, usava um chip muito menor TB67S109AFTG, também da Toshiba. O desempenho e as especificações destes chips são semelhantes, mas o TB6600HG tem uma corrente de pico mais alta (até 5 A) e é um chip muito maior com melhor dissipação de calor.
Há uma forma muito simples de verificar se o teu driver usa um chip TB6600HG ou TB67S109AFTG, o TB6600HG suporta até 1/16 de microstepping (ver datasheet), enquanto o TB67S109AFTG suporta até 1/32. A principal razão para os fabricantes terem mudado para este outro chip é provavelmente o preço. Abaixo encontras links para os chips em LCSC.com que mostram que o TB67S109AFTG é cerca de 1,50 $ mais barato.
TB6600HG: https://lcsc.com/product-detail/Motor-Drivers_TOSHIBA_TB6600HG_TB6600HG_C66042.html
TB67S109AFTG: https://lcsc.com/product-detail/Motor-Drivers_TOSHIBA_TB67S109AFTG_TB67S109AFTG_C92125.html
Podes comprar drivers TB6600 genuínos na Amazon, como este 4-axis driver board mas a maioria usa o chip TB67S109AFTG. Podes identificar o chip TB6600HG pelas ligações que saem da PCB e porque só suporta até 1/16 de microstepping.
Jim de embeddedtronicsblog fez alguns testes nos drivers TB67S109AFTG e descobriu que os motores de passo funcionavam melhor do que com os drivers TB6600. Então, deves optar por um TB6600 genuíno ou pelo ‘upgrade’? Eu diria que depende se realmente precisas da corrente alta ou preferes até 1/32 de microstepping.
Podes encontrar o datasheet do TB67S109AFTG abaixo.
Alternativas
Note que o TB6600 é um driver analógico. Nos últimos anos, drivers digitais como o DM556 ou DM542 tornaram-se muito mais acessíveis. Drivers digitais geralmente oferecem melhor desempenho e operação mais silenciosa. Podem ser ligados e controlados da mesma forma que o TB6600, facilitando uma atualização futura do sistema.
Usei os drivers DM556 na minha CNC caseira e têm funcionado muito bem durante vários anos.
TB6600 vs TB6560
Ao comprar um driver TB6600, provavelmente encontrarás também o driver TB6560 TB6560, um pouco mais barato. Este driver pode ser controlado com o mesmo código/ligação, mas há algumas diferenças importantes.
| TB6560 | TB6600 | |
|---|---|---|
| Tensão de operação | 10 – 35 VDC, 24 VDC recomendado | 9 – 42 VDC, 36 VDC recomendado |
| Corrente máxima de saída | 3 A por fase, 3,5 A pico | 3,5 A por fase, 4 A pico |
| # Configurações de corrente | 14 | 8 |
| Resolução de microstep | completo, 1/2, 1/8 e 1/16 | completo, 1/2, 1/4, 1/8, 1/16 e 1/32* |
| Frequência do clock | 15 kHz | 200 kHz |
| Custo | Check price | Check price |
*Drivers usando chip TB67S109AFTG.
As principais diferenças são a tensão máxima mais alta, corrente máxima maior e até 1/32 de microstepping. O TB6600 também tem um dissipador melhor e um formato geral mais agradável. Se quiseres controlar motores maiores ou precisares de maior resolução, recomendo o TB6600.
Ligação – Conectar TB6600 ao motor de passo e Arduino
Ligar o driver TB6600 a um Arduino e motor de passo é bastante simples. O diagrama de ligação abaixo mostra as conexões necessárias.
Neste tutorial, vamos ligar o driver numa configuração de cátodo comum. Isso significa que ligamos todos os lados negativos dos sinais de controlo ao terra.
As ligações estão também indicadas na tabela abaixo:
Ligações do TB6600
| TB6600 | Ligação |
|---|---|
| VCC | 9 – 42 VDC |
| GND | Terra da fonte de alimentação |
| ENA- | Não ligado |
| ENA+ | Não ligado |
| DIR- | GND do Arduino |
| DIR+ | Pino 2 do Arduino |
| PUL- | GND do Arduino |
| PUL+ | Pino 3 do Arduino |
| A-, A+ | Bobina 1 do motor de passo |
| B-, B+ | Bobina 2 do motor de passo |
Note que deixámos os pinos de enable (ENA- e ENA+) desligados. Isso significa que o pino de enable está sempre em LOW e o driver está sempre ativado.
Como determinar a ligação correta do motor de passo?
Se não conseguires encontrar o datasheet do teu motor de passo, pode ser difícil saber qual fio ligar onde. Eu uso o seguinte truque para identificar as ligações de motores bipolares de 4 fios:
O único que precisas identificar são os dois pares de fios ligados às duas bobinas do motor. Os fios de uma bobina ligam-se a A- e A+ e os da outra a B- e B+, a polaridade não importa.
Para encontrar os dois fios de uma bobina, faz o seguinte com o motor desligado:
- Tenta girar o eixo do motor de passo à mão e nota a resistência.
- Agora escolhe um par de fios aleatório do motor e toca as extremidades descascadas uma na outra.
- A seguir, enquanto manténs as extremidades juntas, tenta girar o eixo do motor novamente.
Se sentires muita resistência, encontraste um par de fios da mesma bobina. Se o eixo girar livremente, tenta outro par. Agora liga as duas bobinas aos pinos indicados no diagrama acima.
Se ainda estiver confuso, deixa um comentário abaixo; mais informações também podem ser encontradas no RepRap.org wiki
Configurações de microstep do TB6600
Motores de passo normalmente têm um passo de 1,8° ou 200 passos por revolução, referindo-se a passos completos. Um driver de microstepping como o TB6600 permite resoluções mais altas ao permitir posições intermédias de passo, energizando as bobinas com níveis de corrente intermédios.
Por exemplo, conduzir um motor em modo 1/2 passo dará ao motor de 200 passos por revolução 400 microsteps por revolução.
Podes alterar as configurações de microstep do TB6600 ligando ou desligando os dip switches no driver. Vê a tabela abaixo para detalhes. Certifica-te de que o driver não está ligado à alimentação ao ajustar os dip switches!
Por favor nota que estas configurações são para drivers de 1/32 microstepping com o chip TB67S109AFTG. Quase todos os drivers TB6600 que podes comprar atualmente usam este chip. Normalmente também encontras uma tabela com as configurações de microstep e corrente no corpo do driver.
Tabela de microstep
| S1 | S2 | S3 | Resolução de microstep |
|---|---|---|---|
| ON | ON | ON | NC |
| ON | ON | OFF | Passo completo |
| ON | OFF | ON | 1/2 passo |
| OFF | ON | ON | 1/2 passo |
| ON | OFF | OFF | 1/4 passo |
| OFF | ON | OFF | 1/8 passo |
| OFF | OFF | ON | 1/16 passo |
| OFF | OFF | OFF | 1/32 passo |
De modo geral, uma configuração de microstep menor resulta numa operação mais suave e silenciosa. No entanto, limita a velocidade máxima que podes alcançar ao controlar o driver com um Arduino.
Configurações de corrente do TB6600
Podes ajustar a corrente que vai para o motor durante o funcionamento configurando os dip switches S4, S5 e S6. Recomendo começar com um nível de corrente de 1 A. Se o motor perder passos ou bloquear, podes sempre aumentar a corrente depois.
Tabela de corrente
| Corrente (A) | Corrente de pico | S4 | S5 | S6 |
|---|---|---|---|---|
| 0,5 | 0,7 | ON | ON | ON |
| 1,0 | 1,2 | ON | OFF | ON |
| 1,5 | 1,7 | ON | ON | OFF |
| 2,0 | 2,2 | ON | OFF | OFF |
| 2,5 | 2,7 | OFF | ON | ON |
| 2,8 | 2,9 | OFF | OFF | ON |
| 3,0 | 3,2 | OFF | ON | OFF |
| 3,5 | 4,0 | OFF | OFF | OFF |
Código de exemplo básico para TB6600 com Arduino
Com o seguinte sketch, podes testar a funcionalidade do driver do motor de passo. Ele simplesmente faz o motor rodar a uma velocidade fixa.
Podes carregar o código no teu Arduino usando o Arduino IDE. Para este exemplo específico, não precisas instalar nenhuma biblioteca.
No próximo exemplo, vamos ver como controlar a velocidade, o número de voltas e a direção de rotação do motor de passo.
Podes copiar o código clicando no botão no canto superior direito do campo de código.
/* Example sketch to control a stepper motor with TB6600 stepper motor driver
and Arduino without a library: continuous rotation.
More info: https://www.makerguides.com */
// Define stepper motor connections:
#define dirPin 2
#define stepPin 3
void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
// Set the spinning direction CW/CCW:
digitalWrite(dirPin, HIGH);
}
void loop() {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(500);
digitalWrite(stepPin, LOW);
delayMicroseconds(500);
}
Como podes ver, o código é muito curto e simples. Não precisas de muito para fazer um motor de passo girar!
Explicação do código
O sketch começa por definir os pinos de passo (PUL+) e direção (DIR+). Eu liguei-os aos pinos 3 e 2 do Arduino.
A instrução #define é usada para dar um nome a um valor constante. O compilador substituirá todas as referências a esta constante pelo valor definido quando o programa for compilado. Assim, em todo o lado onde mencionares dirPin, o compilador substituirá pelo valor 2 quando o programa for compilado.
// Define stepper motor connections: #define dirPin 2 #define stepPin 3
Na setup() seção do código, todos os pinos de controlo do motor são declarados como OUTPUT digitais com a função pinMode(pin, mode). Também defini a direção de rotação do motor de passo colocando o pino de direção em HIGH. Para isso usamos a função digitalWrite(pin, value).
void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
// Set the spinning direction CW/CCW:
digitalWrite(dirPin, HIGH);
}
Na loop() seção do código, fazemos o driver executar um passo enviando um pulso para o pino de passo. Como o código na seção loop é repetido continuamente, o motor de passo começará a girar a uma velocidade fixa.
void loop() {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(500);
digitalWrite(stepPin, LOW);
delayMicroseconds(500);
}
No próximo exemplo, vais ver como podes alterar a velocidade do motor.
2. Código de exemplo para controlar rotação, velocidade e direção
O seguinte sketch controla a velocidade, o número de voltas e a direção de rotação do motor de passo.
/* Example sketch to control a stepper motor with TB6600 stepper motor driver
and Arduino without a library: number of revolutions, speed and direction.
More info: https://www.makerguides.com */
// Define stepper motor connections and steps per revolution:
#define dirPin 2
#define stepPin 3
#define stepsPerRevolution 1600
void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
}
void loop() {
// Set the spinning direction clockwise:
digitalWrite(dirPin, HIGH);
// Spin the stepper motor 1 revolution slowly:
for (int i=0; i < stepsPerRevolution; i++) {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(2000);
digitalWrite(stepPin, LOW);
delayMicroseconds(2000);
}
delay(1000);
// Set the spinning direction counterclockwise:
digitalWrite(dirPin, LOW);
// Spin the stepper motor 1 revolution quickly:
for (int i=0; i < stepsPerRevolution; i++) {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(1000);
digitalWrite(stepPin, LOW);
delayMicroseconds(1000);
}
delay(1000);
// Set the spinning direction clockwise:
digitalWrite(dirPin, HIGH);
// Spin the stepper motor 5 revolutions fast:
for (int i=0; i < 5 * stepsPerRevolution; i++) {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(500);
digitalWrite(stepPin, LOW);
delayMicroseconds(500);
}
delay(1000);
// Set the spinning direction counterclockwise:
digitalWrite(dirPin, LOW);
// Spin the stepper motor 5 revolutions fast:
for (int i=0; i < 5 * stepsPerRevolution; i++) {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(500);
digitalWrite(stepPin, LOW);
delayMicroseconds(500);
}
delay(1000);
}
Como o código funciona
Além de definir as ligações do motor de passo, também defini uma constante stepsPerRevolution . Como defini o driver para o modo 1/8 microstepping, defini 1600 passos por revolução (para um motor padrão de 200 passos por revolução). Altera este valor se o teu setup for diferente.
// Define stepper motor connections and steps per revolution: #define dirPin 2 #define stepPin 3 #define stepsPerRevolution 1600
A setup() seção é igual à anterior, só que ainda não definimos a direção de rotação.
Na loop() seção do código, fazemos o motor girar uma revolução lentamente no sentido horário (CW) e uma revolução rapidamente no sentido anti-horário (CCW). Depois, fazemos o motor girar 5 voltas em cada direção a alta velocidade. Então, como controlas a velocidade, direção de rotação e número de voltas?
// Set the spinning direction clockwise:
digitalWrite(dirPin, HIGH);
// Spin the stepper motor 1 revolution slowly:
for(int i=0; i < stepsPerRevolution; i++)
{
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(2000);
digitalWrite(stepPin, LOW);
delayMicroseconds(2000);
}
Controlar a direção de rotação
Para controlar a direção de rotação do motor de passo, definimos o pino DIR (direção) como HIGH ou LOW. Para isso usamos a função digitalWrite(). Dependendo de como ligaste o motor, colocar o pino DIR em HIGH fará o motor girar CW ou CCW.
Controlar o número de passos ou voltas
Neste sketch de exemplo, o for loops controla o número de passos que o motor de passo dará. O código dentro do for loop resulta num passo (micro) do motor. Como o código no loop é executado 1600 vezes (stepsPerRevolution), isso resulta numa revolução. Nos dois últimos loops, o código dentro do for é executado 8000 vezes, o que resulta em 8000 passos (micro) ou 5 voltas.
Nota que podes alterar o segundo termo no for para o número de passos que quiseres. for(int i=0; i<800; i++) resultaria em 800 passos ou meia revolução.
Controlar a velocidade
A velocidade do motor de passo é determinada pela frequência dos pulsos que enviamos ao pino STEP. Quanto maior a frequência, mais rápido o motor roda. Podes controlar a frequência dos pulsos alterando delayMicroseconds() no código. Quanto menor o delay, maior a frequência e mais rápido o motor roda.
Instalar a biblioteca AccelStepper
A biblioteca AccelStepper, escrita por Mike McCauley, é uma excelente biblioteca para usar no teu projeto. Uma das vantagens é que suporta aceleração e desaceleração, além de ter muitas outras funções úteis.
Podes descarregar a versão mais recente desta biblioteca aqui:
Podes instalar a biblioteca indo a Sketch > Include Library > Add .ZIP Library… no Arduino IDE.
Outra opção é navegar para Tools > Manage Libraries… ou pressionar Ctrl + Shift + I no Windows. O Gestor de Bibliotecas abrirá e atualizará a lista de bibliotecas instaladas.
Podes procurar por ‘accelstepper’ e procurar a biblioteca do Mike McCauley. Seleciona a versão mais recente e clica em Instalar.
3. Código de exemplo AccelStepper
Com o seguinte sketch, podes adicionar aceleração e desaceleração aos movimentos do motor de passo, sem código complicado. No exemplo seguinte, o motor vai rodar para a frente e para trás a uma velocidade de 1000 passos por segundo e uma aceleração de 500 passos por segundo ao quadrado.
Nota que ainda estou a usar o driver em modo 1/8 microstepping. Se estiveres a usar outra configuração, experimenta ajustar a velocidade e aceleração.
/* Example sketch to control a stepper motor with TB6600 stepper motor driver,
AccelStepper library and Arduino: acceleration and deceleration.
More info: https://www.makerguides.com */
// Include the AccelStepper library:
#include "AccelStepper.h"
// Define stepper motor connections and motor interface type.
// Motor interface type must be set to 1 when using a driver:
#define dirPin 2
#define stepPin 3
#define motorInterfaceType 1
// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin);
void setup() {
// Set the maximum speed and acceleration:
stepper.setMaxSpeed(1000);
stepper.setAcceleration(500);
}
void loop() {
// Set the target position:
stepper.moveTo(8000);
// Run to target position with set speed and acceleration/deceleration:
stepper.runToPosition();
delay(1000);
// Move back to zero:
stepper.moveTo(0);
stepper.runToPosition();
delay(1000);
}
Explicação do código
O primeiro passo é incluir a biblioteca com #include <AccelStepper.h>.
// Include the AccelStepper library: #include "AccelStepper.h"
O passo seguinte é definir as ligações do TB6600 ao Arduino e o tipo de interface do motor. O tipo de interface deve ser definido como 1 quando usas um driver de passo e direção. Podes encontrar os outros tipos de interface here.
// Define stepper motor connections and motor interface type. Motor interface type must be set to 1 when using a driver: #define dirPin 2 #define stepPin 3 #define motorInterfaceType 1
Depois, precisas criar uma nova instância da classe AccelStepper com o tipo de interface e ligações apropriadas.
Neste caso, chamei o motor de passo ‘stepper’, mas podes usar outros nomes, como ‘z_motor’ ou ‘liftmotor’, etc. AccelStepper liftmotor = AccelStepper(motorInterfaceType, stepPin, dirPin);. O nome que dás ao motor será usado depois para definir a velocidade, posição e aceleração desse motor em particular. Podes criar múltiplas instâncias da classe AccelStepper com nomes e pinos diferentes. Isso permite controlar facilmente 2 ou mais motores de passo ao mesmo tempo.
// Create a new instance of the AccelStepper class: AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin);
No setup(), além da velocidade máxima, precisamos definir a aceleração/desaceleração. Para isso usamos a função setMaxSpeed() e setAcceleration().
void setup() {
// Set the maximum speed and acceleration:
stepper.setMaxSpeed(1000);
stepper.setAcceleration(500);
}
Na seção loop do código, fazemos o motor rodar um número pré-definido de passos. A função stepper.moveTo() é usada para definir a posição alvo (em passos). A função stepper.runToPostion() move o motor (com aceleração/desaceleração) até à posição alvo e bloqueia até lá chegar. Como esta função é bloqueante, não deves usá-la se precisares controlar outras coisas ao mesmo tempo.
// Set the target position: stepper.moveTo(8000); // Run to target position with set speed and acceleration/deceleration: stepper.runToPosition();
Se quiseres ver mais exemplos para a biblioteca AccelStepper, consulta o meu tutorial sobre How to control a stepper motor with A4988 driver and Arduino.
Conclusão
Neste artigo, mostrei-te como controlar um motor de passo com o driver TB6600 e Arduino. Espero que tenhas achado útil e informativo.
Se quiseres aprender mais sobre outros drivers de motor de passo, os artigos abaixo podem ser úteis:
- TB6560 Stepper Motor Driver with Arduino Tutorial
- How to control a stepper motor with A4988 driver and Arduino
- 28BYJ-48 Stepper Motor with ULN2003 Driver and Arduino Tutorial
- How to control a Stepper Motor with Arduino Motor Shield Rev3
- Control a Stepper Motor with an IR Remote
Também temos um artigo sobre How To Use the TB6600 Stepper Motor Driver with ESP32 se quiseres trabalhar com um microcontrolador ESP32 em vez disso.
Se tiveres alguma dúvida, deixa um comentário abaixo.
