Guia de como usar o Motor de Passo 28BYJ-48 com driver ULN2003 no Arduino

Tempo de leitura: 12 minutes

Este artigo inclui tudo o que você precisa saber sobre como controlar um motor de passo 28BYJ-48 com a placa de driver ULN2003 e Arduino. Eu incluí o datasheets, um diagrama de ligação e muitos códigos de exemplo!

Primeiro, damos uma olhada na biblioteca Arduino Stepper fácil de usar. Esta biblioteca é ótima quando você está começando, mas não tem muitos recursos extras.

Eu recomendo fortemente também dar uma olhada nos códigos de exemplo para a biblioteca AccelStepper no final deste tutorial. Esta biblioteca é bastante fácil de usar e pode melhorar muito o desempenho do seu hardware.

Após cada exemplo, eu analiso e explico como o código funciona, então você não deve ter problemas para modificá-lo para atender às suas necessidades.

Se você quiser saber mais sobre como controlar motores de passo maiores com mais torque e mais velocidade, dê uma olhada nos artigos abaixo. Nestes artigos eu ensino como controlar motores de passo NEMA 17, com drivers como o A4988.

Suprimentos

Componentes de hardware

  1. Motor de passo 28byj-48
  2. Placa de driver ULN2003
  3. Arduino Uno Rev 3
  4. Fios de ligação (macho para fêmea)
  5. ProtoBoard (opcional, torna a ligação mais fácil)
  6. Cabo USB tipo A/B
  7. Fonte de alimentação de 5 V (alimentar o motor de passo diretamente do Arduino pode danificá-lo!)

Informações sobre o motor de passo 28BYJ-48 e placa de driver ULN2003

O 28BYJ-48 é um dos motores de passo mais baratos que você pode encontrar. Embora não seja super preciso ou poderoso, é um ótimo motor para usar em projetos menores ou se você apenas deseja aprender sobre motores de passo.

Este motor é frequentemente usado para ajustar automaticamente as palhetas de uma unidade de ar condicionado. Ele tem uma caixa de câmbio embutida, o que lhe dá um torque extra e reduz a velocidade drasticamente.

Abaixo você pode encontrar as especificações para o motor de passo e o driver que são usados neste tutorial.

Especificações do motor de passo 28BYJ-48

Tensão nominal 5 V
Resistência da bobina 50 Ohms
Tipo de bobina Unipolar
Diâmetro – eixo 0.197″ (5.00 mm)
Comprimento – eixo e rolamento 0.394″ (10 mm)
Características Eixo plano
Tamanho / dimensão Round – 1.100″ dia (28.00 mm)
Espaçamento do orifício de montagem Eixo Achatado
Redução de marcha 1/64
Ângulo de passo Modo de meio passo (recomendado): 0,0879 °
Modo de passo completo: 0,176 °
Passos por revolução Modo de meio passo: 4096 (ver nota)
Modo de passo completo: 2048
Estilo de Terminal Cabos de fios com conector
Tipo de motor Motor de engrenagem de ímã permanente
Número de fases 4
Custo Aproximado 20 a 50R$

Para mais informações, você pode verificar a ficha técnica aqui.

Nota importante: os fabricantes geralmente especificam que os motores têm uma redução de marcha 64:1. Alguns membros dos Fóruns do Arduino notaram que isso não estava correto e então desmontaram alguns motores para verificar a relação de transmissão real. Eles determinaram que a relação de transmissão exata é de fato 63,68395:1, o que resulta em aproximadamente 4076 passos por volta completa (no modo de meio passo).

Não tenho certeza se todos os fabricantes usam exatamente a mesma caixa de câmbio, mas você pode simplesmente ajustar as etapas por revolução no código, para corresponder ao seu modelo.

O motor de passo de pequena redução da Adafruit Industries usa o mesmo formato do 28BYJ-48, mas tem uma relação de engrenagem diferente. Tem um conjunto de engrenagens de redução de aproximadamente 1/16, o que resulta em 513 passos por revolução (no modo de passo completo). Você pode baixar o datasheet aqui.

Para mais informações sobre o driver, você pode verificar a ficha técnica abaixo.

ULN2003 Datasheet

ULN2003 Driver PCB

Conectando o motor de passo 28BYJ-48 e a placa do driver ULN2003 ao Arduino UNO

O diagrama de ligação/esquema abaixo mostra como conectar a placa do driver ULN2003 ao motor de passo 28BYJ-48 e ao Arduino. As conexões também são fornecidas na tabela abaixo.

Ou via ProtoBoard

Esta ligação utiliza o 5V direto no Arduino (E apenas para teste rápido), se for usar coloque como o diagrama acima.

Usei um ProtoBoard e alguns fios de jumper para conectar a placa do driver a uma fonte de alimentação externa.

 

ULN2003 e 28BYJ-48 para conexões Arduino

ULN2003 Driver Board Conexão
IN1 Pino 8 Arduino
IN2 Pino 9 Arduino
IN3 Pino 10 Arduino
IN4 Pino 11 Arduino
Logic GND Arduino
Fonte de alimentação GND
+ Fonte de alimentação 5 V

Observação: é possível alimentar diretamente o motor de passo a partir da saída de 5 V do Arduino. No entanto, isso não é recomendado. Quando o motor de passo puxa muita corrente, você pode danificar o Arduino. Também descobri que, ao alimentar o Arduino apenas com alimentação USB, obtive um comportamento inconsistente e um desempenho ruim do motor de passo.

Recomendo alimentar a placa de driver/motor de passo com uma fonte de alimentação externa de 5 V, como esta. Ele deve vir com um conector DC fêmea, para que você possa conectá-lo facilmente a alguns fios (jumpers). Observe que você também precisa conectar o GND do Arduino ao pino – na placa do driver ULN2003.

Depois de fazer o upload do código, você também precisa ligar o Arduino, seja com um cabo USB tipo B ou por meio do conector de força de 5,5 mm.

O jumper próximo às conexões de energia na placa do driver pode ser usado para desconectar a energia do motor de passo.

 

Código de exemplo básico do Arduino para controlar um motor de passo 28BYJ-48

Você pode fazer o upload do seguinte código de exemplo para seu Arduino usando o IDE do Arduino.

Este exemplo usa a biblioteca Stepper.h, que deve vir pré-instalada com o IDE do Arduino. Este esboço gira o motor de passo 1 rotação em uma direção, pausa e, a seguir, gira 1 rotação na outra direção.

/* Sketch de exemplo para controlar um motor de passo 28BYJ-48 com placa de driver ULN2003 e Arduino UNO.*/
// Inclui a biblioteca Arduino Stepper.h:
#include <Stepper.h>
// Defina o número de etapas por rotação:
const int stepsPerRevolution = 2048;
// Ligação
// Pino 8 para IN1 no driver ULN2003
// Pino 9 para IN2 no driver ULN2003
// Pino 10 para IN3 no driver ULN2003
// Pino 11 para IN4 no driver ULN2003
// Crie um objeto de passo chamado 'myStepper', observe a ordem dos pinos:
Stepper myStepper = Stepper(stepsPerRevolution, 8, 10, 9, 11);
void setup() {
  // Defina a velocidade para 5 rpm:
  myStepper.setSpeed(5);
  
  Serial.begin(9600);
}
void loop() {
  // Etapa uma revolução em uma direção:
  Serial.println("sentido horário");
  myStepper.step(stepsPerRevolution);
  delay(500);
  
  // Faça uma revolução na outra direção:
  Serial.println("sentido anti-horário");
  myStepper.step(-stepsPerRevolution);
  delay(500);
}

 

Explicação do código:

O sketcho começa incluindo a biblioteca Stepper.h Arduino. Mais informações sobre essa biblioteca podem ser encontradas no site do Arduino.

// Inclui a biblioteca Arduino Stepper.h:
#include <Stepper.h>

A seguir, defini quantos passos o motor dá para girar 1 volta. Neste exemplo, usaremos o motor no modo de passo completo. Isso significa que são necessários 2048 passos para girar 360 graus (consulte as especificações do motor acima).

// Defina o número de etapas por rotação:
const int stepsPerRevolution = 2048;

Em seguida, você precisa criar uma nova instância da classe Stepper, que representa um motor de passo específico conectado ao Arduino. Para isso usamos a função Stepper (etapas, pino1, pino2, pino3, pino4) onde etapas é o número de etapas por revolução e pino1 a pino4 são os pinos aos quais o motor está conectado. Para obter a sequência de etapas correta, precisamos definir os pinos na seguinte ordem: 8, 10, 9, 11.

// Crie um objeto de passo chamado 'myStepper', observe a ordem dos pinos:
Stepper myStepper = Stepper(stepsPerRevolution, 8, 10, 9, 11);

Neste caso, chamei o motor de passo de ‘myStepper’, mas você também pode usar outros nomes, como ‘z_motor’ ou ‘liftmotor’ etc. Stepper liftmotor = Stepper(stepsPerRevolution, 8, 10, 9, 11);. Você pode criar vários objetos de motor de passo com diferentes nomes e pinos. Isso permite que você controle facilmente 2 ou mais motores de passo ao mesmo tempo.

Na configuração, você pode definir a velocidade em rpm com a função setSpeed (rpm). A velocidade máxima para um motor de passo 28byj-48 é de aproximadamente 10-15 rpm a 5V.

void setup() {
  // Defina a velocidade para 5 rpm:
  myStepper.setSpeed(5);
  
  Serial.begin(9600);
}

Na seção de loop do código, simplesmente chamamos a função step (steps) que gira o motor em um número específico de passos a uma velocidade determinada pela função setSpeed (rpm). Passar um número negativo para esta função inverte o sentido de rotação do motor.

void loop() {
  // Etapa uma revolução em uma direção:
  Serial.println("sentido horário");
  myStepper.step(stepsPerRevolution);
  delay(500);
  
  // Faça uma revolução na outra direção:
  Serial.println("sentido anti-horário");
  myStepper.step(-stepsPerRevolution);
  delay(500);
}

 

Códigos de exemplo para motor de passo 28BYJ-48 com Arduino e a biblioteca AccelStepper

Nos três exemplos a seguir, mostrarei como você pode controlar a velocidade, a direção e o número de etapas que o motor de passo deve executar. Nestes exemplos, estarei usando a biblioteca AccelStepper.

A biblioteca AccelStepper escrita por Mike McCauley é uma biblioteca incrível para usar em seu projeto. Uma das vantagens é que ele suporta aceleração e desaceleração, mas também tem muitas outras funções interessantes.

Você pode baixar a versão mais recente desta biblioteca aqui

Você pode instalar a biblioteca acessando Sketch > Include Library > Add .ZIP Library… no IDE do Arduino.

Outra opção é navegar para Tools > Manage Libraries… ou digite Ctrl + Shift + I no Windows. O Library Manager irá abrir e atualizar a lista de bibliotecas instaladas.

Você pode pesquisar por ‘accelstepper’ e procurar a biblioteca de Mike McCauley. Selecione a versão mais recente e clique em Instalar.

1. Código de exemplo de rotação contínua

O sketch a seguir pode ser usado para operar um ou mais motores de passo continuamente a uma velocidade constante. (Nenhuma aceleração ou desaceleração é usada).

Você pode copiar o código clicando no botão no canto superior direito do campo do código.

/* sketch de exemplo para controlar um motor de passo 28BYJ-48 com placa de driver ULN2003, AccelStepper e Arduino UNO: rotação contínua. */
// Incluir a biblioteca AccelStepper:
#include <AccelStepper.h>
// Definições dos pinos do motor:
#define motorPin1  8      // IN1 on the ULN2003 driver
#define motorPin2  9      // IN2 on the ULN2003 driver
#define motorPin3  10     // IN3 on the ULN2003 driver
#define motorPin4  11     // IN4 on the ULN2003 driver
// Definir o tipo de interface AccelStepper; Motor de 4 fios em modo de meio passo:
#define MotorInterfaceType 8
// Inicialize com a sequência de pinos IN1-IN3-IN2-IN4 para usar a biblioteca AccelStepper com motor de passo 28BYJ-48:
AccelStepper stepper = AccelStepper(MotorInterfaceType, motorPin1, motorPin3, motorPin2, motorPin4);
void setup() {
  // Defina os passos máximos por segundo:
  stepper.setMaxSpeed(1000);
}
void loop() {
  // Defina a velocidade do motor em etapas por segundo:
  stepper.setSpeed(500);
  // Aciona o motor com velocidade constante, conforme definido por setSpeed ():
  stepper.runSpeed();
}

Como funciona o código:

Novamente, a primeira etapa é incluir a biblioteca com #include <AccelStepper.h>.

// Incluir a biblioteca AccelStepper:
#include <AccelStepper.h>

A próxima etapa é definir as conexões ULN2003 para 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. Portanto, sempre que você mencionar motorPin1, o compilador o substituirá pelo valor 8 quando o programa for compilado.

// Definições dos pinos do motor:
#define motorPin1 8 // IN1 no driver ULN2003
#define motorPin2 9 // IN2 no driver ULN2003
#define motorPin3 10 // IN3 no driver ULN2003
#define motorPin4 11 // IN4 no driver ULN2003

A próxima etapa é especificar o tipo de interface do motor para a biblioteca AccelStepper. Neste caso, estaremos acionando um motor de passo de 4 fios no modo de meio passo, portanto, definimos o tipo de interface para ‘8’. Você pode encontrar os outros tipos de interface aqui. Se você quiser fazer o motor funcionar no modo de passo completo (menos passos por rotação), basta alterar de 8 para 4.

// Definir o tipo de interface AccelStepper; Motor de 4 fios em modo de meio passo:
#define MotorInterfaceType 8

Em seguida, você precisa criar uma nova instância da classe AccelStepper com o tipo de interface de motor e conexões apropriadas. Para obter a sequência de etapas correta, precisamos definir os pinos na seguinte ordem: motorPin1, motorPin3, motorPin2, motorPin4.

Neste caso, chamei o motor de passo de ‘stepper’, mas você também pode usar outros nomes, como ‘z_motor’ ou ‘liftmotor’ etc. AccelStepper liftmotor = AccelStepper(MotorInterfaceType, motorPin1, motorPin3, motorPin2, motorPin4);. Você pode criar vários objetos de motor de passo com diferentes nomes e pinos. Isso permite que você controle facilmente 2 ou mais motores de passo ao mesmo tempo.

// Inicialize com a sequência de pinos IN1-IN3-IN2-IN4 para usar a biblioteca AccelStepper com motor de passo 28BYJ-48:
AccelStepper stepper = AccelStepper(MotorInterfaceType, motorPin1, motorPin3, motorPin2, motorPin4);

Na seção de configuração do código, definimos a velocidade máxima em steps/second com a função setMaxSpeed(). Velocidades de mais de 1000 passos por segundo podem não ser confiáveis, então eu defino isso como o máximo. Observe que eu especifico o nome do motor de passo (‘stepper’), para o qual desejo definir a velocidade máxima. Se você tiver vários motores de passo conectados, poderá especificar uma velocidade diferente para cada motor: stepper2.setMaxSpeed (500);.

void setup() {
  // Defina os passos máximos por segundo:
  stepper.setMaxSpeed(1000);
}

No loop, primeiro definimos a velocidade na qual queremos que o motor funcione com a função setSpeed(). (você também pode colocar isso na seção de configuração do código).

stepper.runSpeed() controla o motor e quando um passo é devido, ele executa 1 passo. Isso depende da velocidade definida e do tempo desde a última etapa. Se você quiser mudar a direção do motor, você pode definir uma velocidade negativa: stepper.setSpeed(-400); gira o motor para o outro lado.

void loop() {
  // Defina a velocidade do motor em etapas por segundo:
  stepper.setSpeed(500);
  // Aciona o motor com velocidade constante, conforme definido por setSpeed():
  stepper.runSpeed();
}

No modo de meio passo, uma revolução leva 4.096 passos, então 500 passos/seg resultam em aproximadamente 7 rpm.

 

2. sketch para controlar o número de etapas ou revoluções

Com o seguinte sketch, você pode controlar a velocidade, a direção e o número de etapas/revoluções.

Neste caso, o motor de passo gira 1 volta no sentido horário com 500 passos/seg, então gira 1 volta no sentido anti-horário a 1000 passos/seg e, por último, gira 2 voltas no sentido horário a 1000 passos/seg.

/* Esboço de exemplo para controlar um motor de passo 28BYJ-48 com placa de driver ULN2003, AccelStepper e Arduino UNO: número de etapas/revoluções.*/
//Inclui a biblioteca AccelStepper:
#include <AccelStepper.h>
// Definições dos pinos do motor:
#define motorPin1 8  // IN1 no driver ULN2003
#define motorPin2 9  // IN2 no driver ULN2003
#define motorPin3 10 // IN3 no driver ULN2003
#define motorPin4 11 // IN4 no driver ULN2003
// Definir o tipo de interface AccelStepper; Motor de 4 fios em modo de meio passo:
#define MotorInterfaceType 8
// Inicialize com a sequência de pinos IN1-IN3-IN2-IN4 para usar a biblioteca AccelStepper com motor de passo 28BYJ-48:
AccelStepper stepper = AccelStepper(MotorInterfaceType, motorPin1, motorPin3, motorPin2, motorPin4);
void setup() {
  // Defina os passos máximos por segundo:
  stepper.setMaxSpeed(1000);
}
void loop() {
  // Defina a posição atual para 0:
  stepper.setCurrentPosition(0);
  // Faça o motor funcionar a 500 passos/segundo até que o motor atinja 4096 passos (1 rotação):
  while (stepper.currentPosition() != 4096) {
    stepper.setSpeed(500);
    stepper.runSpeed();
  }
  delay(1000);
  // Redefina a posição para 0:
  stepper.setCurrentPosition(0);
  // Faça o motor funcionar para trás a 1000 passos/segundo até que o motor alcance -4096 passos (1 revolução):
  while (stepper.currentPosition() != -4096) {
    stepper.setSpeed(-1000);
    stepper.runSpeed();
  }
  delay(1000);
  // Redefina a posição para 0:
  stepper.setCurrentPosition(0);
  // Faça o motor funcionar a 1000 passos/segundo até que o motor atinja 8192 passos (2 revoluções):
  while (stepper.currentPosition() != 8192) {
    stepper.setSpeed(1000);
    stepper.runSpeed();
  }
  delay(3000);
}

Explicação do código:

A primeira parte do código até a seção loop() é exatamente igual à do exemplo anterior.

No loop, utilizo um loop while em combinação com a função currentPosition(). Primeiro, defino a posição atual do motor de passo para zero com stepper.setCurrentPosition(0).

// Defina a posição atual para 0:
  stepper.setCurrentPosition(0);

A seguir, usamos o loop while. Um loop while fará um loop contínuo e infinito, até que a expressão entre parênteses, () se torne falsa. Portanto, neste caso, verifico se a posição atual do motor de passo não é igual a 4.096 passos (! = Significa: não é igual a). Embora este não seja o caso, operamos o motor de passo a uma velocidade constante, conforme definido por setSpeed().

// Faça o motor funcionar a 500 passos / segundo até que o motor atinja 4096 passos (1 rotação):
while (stepper.currentPosition() != 4096) {
  stepper.setSpeed(500);
  stepper.runSpeed();
}

No resto do loop, fazemos exatamente o mesmo, apenas com uma velocidade e posição de destino diferentes.

 

3. Exemplo de código de aceleração e desaceleração

Com o sketch a seguir, você pode adicionar aceleração e desaceleração aos movimentos do motor de passo, sem nenhuma codificação complicada. A primeira seção deste esboço é a mesma do exemplo 1, mas a configuração e o loop são diferentes.

O motor funcionará duas revoluções para frente e para trás com uma velocidade de 1000 passos por segundo e uma aceleração de 200 passos/segundo2.

/* sketche exemplo para controlar um motor de passo 28BYJ-48 com placa de driver ULN2003, AccelStepper e Arduino UNO: aceleração e desaceleração. */
// Incluir a biblioteca AccelStepper:
#include <AccelStepper.h>
// Definições dos pinos do motor:
#define motorPin1 8   // IN1 no driver ULN2003
#define motorPin2 9   // IN2 no driver ULN2003
#define motorPin3 10  // IN3 no driver ULN2003
#define motorPin4 11  // IN4 no driver ULN2003
// Definir o tipo de interface AccelStepper; Motor de 4 fios em modo de meio passo:
#define MotorInterfaceType 8
// Inicialize com a sequência de pinos IN1-IN3-IN2-IN4 para usar a biblioteca AccelStepper com motor de passo 28BYJ-48:
AccelStepper stepper = AccelStepper(MotorInterfaceType, motorPin1, motorPin3, motorPin2, motorPin4);
void setup() {
  // Defina os passos máximos por segundo:
  stepper.setMaxSpeed(1000);
  // Defina a aceleração máxima em passos por segundo^2:
  stepper.setAcceleration(200);
}
void loop() {
  // Definir posição alvo:
  stepper.moveTo(8192);
  // Corra para a posição com velocidade e aceleração definidas:
  stepper.runToPosition();
  
  delay(1000);
  
  // Mova de volta para a posição original:
  stepper.moveTo(0);
  // Corra para a posição com velocidade e aceleração definidas:
  stepper.runToPosition();
  
  delay(1000);
}

Como funciona o código:

Na configuração, além da velocidade máxima, também precisamos definir a aceleração/desaceleração. Para isso, usamos a função setAcceleration().

void setup() {
  // Defina os passos máximos por segundo:
  stepper.setMaxSpeed(1000);
  // Defina a aceleração máxima em passos por segundo^2:
  stepper.setAcceleration(200);
}

Na seção de loop do código, usei uma maneira diferente de deixar o motor girar um número predefinido de etapas. Primeiro, defino a posição de destino com a função moveTo(). Em seguida, simplesmente usamos a função runToPosition() para permitir que o motor funcione até a posição desejada com a velocidade e aceleração definidas. O motor irá desacelerar antes de atingir a posição alvo.

void loop() {
  // Definir posição alvo:
  stepper.moveTo(8192);
  // Corra para a posição com velocidade e aceleração definidas:
  stepper.runToPosition();
  
  delay(1000);
  
  // Mova de volta para a posição original:
  stepper.moveTo(0);
  // Corra para a posição com velocidade e aceleração definidas:
  stepper.runToPosition();
  
  delay(1000);
}

Finalmente, definimos a nova posição de destino de volta para 0, para que possamos retornar à origem.

Conclusão

Neste artigo, mostrei como você pode controlar um motor de passo 28BYJ-48 com um driver ULN2003 e Arduino. Vimos 4 exemplos, usando as bibliotecas Stepper e AccelStepper. Espero que você tenha achado útil e informativo. Se sim, compartilhe com um amigo que também gosta de eletrônicos!

Eu adoraria saber quais projetos você planeja construir (ou já construiu) com este motor de passo. Se você tiver alguma dúvida, sugestão ou se achar que algo está faltando neste tutorial, por favor, deixe um comentário abaixo.

 

Visits: 3 Visits: 1191481