Neste tutorial, vais aprender a controlar um motor de passo com o driver de microstepping TB6560 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 2 exemplos de código. No primeiro exemplo, vou mostrar-te como usar este driver de motor de passo sem uma biblioteca Arduino. No segundo exemplo, vamos explorar a biblioteca AccelStepper. 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 necessários
Componentes de hardware
| TB6560 stepper motor driver | × 1 | Amazon | |
 | NEMA 23 stepper motor | × 1 | Amazon |
 | Arduino Uno Rev3 | × 1 | Amazon |
| Power supply (24 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 excelente 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 TB6560 driver de microstepping é baseado no chip Toshiba TB6560AHQ e pode ser usado para controlar motores de passo bipolares de duas fases.
Com uma corrente máxima contínua de 3 A, o driver TB6560 pode controlar motores de passo bastante grandes, como um NEMA 23. Certifica-te de não ligar motores de passo com uma corrente nominal superior a 3 A ao driver.
O chip tem várias funções de segurança integradas, como proteção contra sobrecorrente, desligamento por subtensão e proteção contra sobreaquecimento. No entanto, não possui proteção contra inversão de polaridade, por isso certifica-te de ligar a fonte de alimentação corretamente. Podes encontrar mais especificações na tabela abaixo.
Especificações do TB6560
| Tensão de operação | 10 – 35 VDC, 24 VDC recomendado |
| Corrente máxima de saída | 3 A por fase, 3,5 A pico |
| Resolução de microstep | completo, 1/2, 1/8 e 1/16 |
| Proteção | Desligamento por baixa tensão, proteção contra sobreaquecimento e sobrecorrente |
| Dimensões | 75 x 50 x 35 mm |
| Espaçamento dos furos | 69 x 43 mm, ⌀ 3,5 mm |
| Custo | Check price |
Para mais informações, podes consultar o datasheet/manual abaixo:
Note que o TB6560 é 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 TB6560, por isso podes facilmente atualizar o teu sistema mais tarde.
Usei os drivers DM556 para a minha CNC caseira e têm funcionado muito bem durante vários anos.
TB6560 vs TB6600
Ao procurar um driver TB6560, provavelmente encontrarás também o driver TB6600 um pouco mais caro. Este driver pode ser controlado com o mesmo código/ligação, mas existem 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 |
As principais diferenças são a tensão máxima mais alta, corrente máxima maior e microstepping até 1/32. Se quiseres controlar motores maiores ou precisares de maior resolução, recomendo o TB6600.
Ligação – Conectar TB6560 ao motor de passo e Arduino
O diagrama de ligação abaixo mostra como conectar o driver TB6560 ao Arduino e a um motor de passo.
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 juntos ao terra.
As ligações também estão indicadas na tabela abaixo:
Ligações do TB6560
| TB6560 | Ligação |
|---|---|
| VCC | 10 – 35 VDC |
| GND | Terra da fonte de alimentação |
| EN- | Não ligado |
| EN+ | Não ligado |
| CW- | GND do Arduino |
| CW+ | Pino 2 do Arduino |
| CLK- | GND do Arduino |
| CLK+ | 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 (EN- e EN+) 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 como ligar 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 rodar o eixo do motor de passo manualmente e nota a resistência.
- Agora escolhe um par de fios aleatório do motor e toca as extremidades nuas uma na outra.
- A seguir, enquanto manténs as extremidades juntas, tenta rodar o eixo do motor novamente.
Se sentires muita resistência, encontraste um par de fios ligados à mesma bobina. O outro par está ligado à segunda bobina.
Se ainda conseguires rodar o eixo livremente, tenta outro par de fios. Agora liga as duas bobinas aos pinos indicados no diagrama de ligação 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 TB6560
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 TB6560 permite resoluções mais altas ao permitir posições intermediárias de passo. Isto é conseguido energizando as bobinas com níveis intermediários de corrente.
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 a configuração de microstep ou modo de excitação do TB6560 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!
Tabela de microsteps
| S3 | S4 | Resolução de microstep |
|---|---|---|
| OFF | OFF | Passo completo |
| ON | OFF | 1/2 passo |
| ON | ON | 1/8 passo |
| OFF | ON | 1/16 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 TB6560
Podes ajustar a corrente que vai para o motor durante o funcionamento configurando os dip switches SW1, SW2, SW3 e S1. Recomendo começar com um nível de corrente de 1 A. Se o motor perder passos ou bloquear, podes aumentar a corrente depois.
Tabela de corrente
| (A) | SW1 | SW2 | SW3 | S1 |
|---|---|---|---|---|
| 0,3 | OFF | OFF | ON | ON |
| 0,5 | OFF | OFF | ON | OFF |
| 0,8 | OFF | ON | OFF | ON |
| 1 | OFF | ON | OFF | OFF |
| 1,1 | OFF | ON | ON | ON |
| 1,2 | ON | OFF | OFF | ON |
| 1,4 | OFF | ON | ON | OFF |
| 1,5 | ON | OFF | ON | ON |
| 1,6 | ON | OFF | OFF | OFF |
| 1,9 | ON | ON | OFF | ON |
| 2 | ON | OFF | ON | OFF |
| 2,2 | ON | ON | ON | ON |
| 2,6 | ON | ON | OFF | OFF |
| 39 | ON | ON | ON | OFF |
A corrente de paragem é a corrente usada para manter o eixo do motor parado. Deves defini-la o mais baixa possível para minimizar o aquecimento desnecessário do motor. Aumenta este valor se o motor não conseguir manter a posição.
Tabela de corrente de paragem
| Corrente de paragem | S2 |
|---|---|
| 20 % | ON |
| 50 % | OFF |
A configuração de decaimento está relacionada com a forma como o chip do driver lida com a força contraeletromotriz (back EMF) do motor. O datasheet do TB6560 da Toshiba fornece explicações e diagramas sobre esta configuração. Normalmente deixo o modo de decaimento em 0 %. Podes experimentar esta configuração para ver o que funciona melhor no teu sistema.
Como referência, o driver TB6600 tem uma configuração fixa de decaimento de 40 %.
Tabela de configuração de decaimento
| S5 | S6 | |
|---|---|---|
| 0 % Normal | OFF | OFF |
| 25 % | ON | OFF |
| 50 % | OFF | ON |
| 100 % Modo rápido | ON | ON |
No resto deste tutorial, vou usar o driver em modo 1/8 microstepping com corrente de funcionamento de 1 A, corrente de paragem de 20 % e configuração de decaimento de 0 %.
Exemplo de código Arduino para TB6560
Agora que ligaste o driver e configuraste os dip switches, é hora de conectar o Arduino ao computador e carregar algum código. Podes carregar o seguinte exemplo no teu Arduino usando o Arduino IDE. Para este exemplo específico, não precisas instalar nenhuma biblioteca.
Este sketch controla a velocidade, o número de revoluções 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 TB6560 stepper motor driver and Arduino without a library.Homepage*/ // 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:
O sketch começa por definir os pinos de passo (CLK-) e direção (CW-). 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, sempre que mencionares dirPin, o compilador substituirá pelo valor 2 durante a compilação.
Também defini uma constante stepsPerRevolution . Como configurei o driver para modo 1/8 microstepping, defini 1600 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
Na secção setup() do código, todos os pinos de controlo do motor são declarados como OUTPUT digitais com a função pinMode().
void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
}
Na secção loop() do código, deixamos o motor girar uma revolução lentamente na direção CW e uma revolução rapidamente na direção CCW. Depois, o motor gira 5 revoluções em cada direção a alta velocidade. Então, como controlas a velocidade, direção de rotação e número de revoluções?
// 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, definir o pino DIR em HIGH fará o motor girar CW ou CCW.
Controlar o número de passos ou revoluções:
Neste sketch de exemplo, o for loops controla o número de passos que o motor de passo dará. O código dentro do ciclo for resulta num passo (micro) do motor. Como o código no ciclo é executado 1600 vezes (stepsPerRevolution), isso resulta numa revolução. Nos dois últimos ciclos, o código é executado 8000 vezes, o que resulta em 8000 passos (micro) ou 5 revoluções.
Nota que podes alterar o segundo termo no ciclo 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 IDE do Arduino.
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.
Exemplo de código 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 frente e para trás com uma velocidade de 1000 passos por segundo e uma aceleração de 500 passos por segundo ao quadrado.
Note que continuo a usar o driver em modo 1/8 microstepping. Se estiveres a usar uma configuração diferente, experimenta ajustar as definições de velocidade e aceleração.
/* Example sketch to control a stepper motor with TB6560 stepper motor driver, AccelStepper library and Arduino: acceleration and deceleration.Homepage*/ // 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 TB6560 ao Arduino e o tipo de interface do motor. O motor interface type deve ser definido como 1 quando se usa um driver de passo e direção.
// 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 do motor e as ligações apropriadas.
Neste caso, chamei o motor de passo ‘stepper’, mas podes usar outros nomes, como ‘z_motor’ ou ‘liftmotor’, etc. Exemplo: AccelStepper liftmotor = AccelStepper(motorInterfaceType, stepPin, dirPin);. O nome que deres ao motor será usado depois para definir velocidade, posição e aceleração desse motor. Podes criar várias 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 secçã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 bloqueia, 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 para o driver de motor de passo A4988:
Conclusão
Neste artigo mostrei-te como controlar um motor de passo com o driver TB6560 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:
- TB6600 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
Note que os comentários são moderados para evitar spam.
