fbpixel
Utilizar um controlador de motor passo a passo DRV8825

Utilizar um controlador de motor passo a passo DRV8825

Neste tutorial, veremos como acionar um motor de passo bipolar utilizando um controlador DRV8825. Este tutorial é compatível com os drivers de motor de passo normalmente utilizados em projectos de fresagem digital ou de impressoras 3D (DRV8825, SilentStepStick, etc.).

Hardware

  • Arduino UNO
  • Controlador de passo DRV8825 (ou A4988 ou SilentStepStick)
  • Cabo USB A macho para USB B macho

Princípio de funcionamento

Os controladores de motores passo a passo permitem que os motores sejam controlados de forma eficiente utilizando apenas dois sinais de controlo, STEP e DIR. O número de impulsos enviados para o controlador corresponde ao número de passos dados, a frequência de impulsos corresponde à velocidade do motor e o sinal dir corresponde ao sentido de rotação do motor. O módulo DRV8825 encarrega-se de enviar a sequência para as duas bobinas do motor de acordo com os comandos recebidos como entrada.

Especificações técnicas DRV8825

Minimum operating voltage8.2 V
Maximum operating voltage45 V
Continuous current per phase1.5 A
Maximum current per phase2.2 A
Minimum logic voltage2.5 V
Maximum logic voltage5.25 V
Microstep resolutionfull, 1/2, 1/4, 1/8, 1/16 and 1/32
Reverse voltage protection?No
Dimensions15.5 × 20.5 mm (0.6″ × 0.8″)

Diagrama

Antes de ligar o seu motor ao driver, defina corretamente o limitador de corrente. Para o fazer, é necessário:

  • fornecer ao Arduino e ao Shield a tensão do motor.
  • Em seguida, coloque um voltímetro entre o potenciómetro e a terra.
  • Rodar o potenciómetro com uma chave de fendas até obter o valor que segue a regra abaixo.
MaxCurrent=Vref x 2 

Por exemplo:

Se o valor da corrente for 1A, o valor apresentado no multímetro deve ser igual a 0,5V.

MaxCurrent=1.0A –> Vref = 0.5V

A resolução dos passos do driver pode ser modificada para uma maior precisão. Esta configuração é definida colocando os pinos M0, M1 e M2 em HIGH ou LOW de acordo com a seguinte tabela lógica.

M0M1M2Microstep resolution
LowLowLowFull step
HighLowLow1/2 step
LowHighLow1/4 step
HighHighLow1/8 step
LowLowHigh1/16 step
HighLowHigh1/32 step
LowHighHigh1/32 step
HighHighHigh1/32 step

Código

Para acionar o driver do motor passo a passo, tudo o que precisamos de fazer é enviar um estado HIGH ou LOW para o pino DIR e um impulso para o pino STEP.

const int stepPin = 2;
const int dirPin = 3;


const int stepsPerRev=200;
int pulseWidthMicros = 100;  // microseconds
int millisBtwnSteps = 1000;

void setup() {
  Serial.begin(9600);
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
 
  Serial.println(F("A4988 Initialized"));
}

void loop() {
  Serial.println(F("Running clockwise"));
  digitalWrite(dirPin, HIGH); // Enables the motor to move in a particular direction
  // Makes 200 pulses for making one full cycle rotation
  for (int i = 0; i < stepsPerRev; i++) {
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(pulseWidthMicros);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(millisBtwnSteps);
  }
  delay(1000); // One second delay

  Serial.println(F("Running counter-clockwise"));
  digitalWrite(dirPin, LOW); //Changes the rotations direction
  // Makes 400 pulses for making two full cycle rotation
  for (int i = 0; i < 2*stepsPerRev; i++) {
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(pulseWidthMicros);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(millisBtwnSteps);
  }
  delay(1000);
}

Para mais funções, pode utilizar a biblioteca AccelStepper.h

Aplicações

  • Controlo de um motor passo a passo
  • Controlo de vários motores com uma placa CNC

Fontes

Utilizar um controlador de motor passo a passo A4988

Utilizar um controlador de motor passo a passo A4988

Neste tutorial, vamos ver como acionar um motor de passo bipolar utilizando um controlador A4988. Este tutorial é compatível com os drivers de motor de passo normalmente utilizados em projectos de fresagem digital ou de impressoras 3D (DRV8825, SilentStepStick, etc.).

Hardware

  • Arduino UNO
  • Motor de passo A4988
  • Cabo USB A macho para USB B macho

Princípio de funcionamento

Os controladores de motores passo a passo permitem que os motores sejam controlados de forma eficiente utilizando apenas dois sinais de controlo, STEP e DIR. O número de impulsos enviados para o controlador corresponde ao número de passos dados, a frequência de impulsos corresponde à velocidade do motor e o sinal dir corresponde à direção de rotação do motor. O módulo A4988 encarrega-se de enviar a sequência para as duas bobinas do motor de acordo com os comandos recebidos como entrada.

Especificações técnicas A4988

Minimum operating voltage 8 V
Maximum operating voltage 35 V
Continuous current per phase 1.2 A
Maximum current per phase 2 A
Minimum logic voltage 3 V
Maximum logic voltage 5.5 V
Microstep resolution full, 1/2, 1/4, 1/8 and 1/16
Reverse voltage protection? No
Dimensions 15.5 × 20.5 mm (0.6″ × 0.8″)

Diagrama

Antes de ligar o seu motor ao driver, defina corretamente o limitador de corrente. Para o fazer, é necessário:

  • fornecer ao Arduino e ao Shield a tensão do motor.
  • Em seguida, coloque um voltímetro entre o potenciómetro e a terra.
  • Rodar o potenciómetro com uma chave de fendas até obter o valor que segue a regra abaixo.

MaxCurrent=Vref x 2.5 

Por exemplo:

Se o valor da corrente for 1A, o valor apresentado no multímetro deve ser igual a 0,4V.

MaxCurrent=1.0A –> Vref = 0.4V

A resolução dos passos do driver pode ser modificada para uma maior precisão. Esta configuração é definida colocando os pinos M0, M1 e M2 em HIGH ou LOW de acordo com a seguinte tabela lógica.

MS1 MS2 MS3 Résolution Microstepping
Low Low Low Pas complet (full step)
High Low Low 1/2 pas
Low High Low 1/4 de pas
High High Low 1/8 ième de pas
High High High 1/16 ième de pas

Código

Para acionar o driver do motor passo a passo, tudo o que precisamos de fazer é enviar um estado HIGH ou LOW para o pino DIR e um impulso para o pino STEP.

const int stepPin = 2;
const int dirPin = 3;


const int stepsPerRev=200;
int pulseWidthMicros = 100;  // microseconds
int millisBtwnSteps = 1000;

void setup() {
  Serial.begin(9600);
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
 
  Serial.println(F("A4988 Initialized"));
}

void loop() {
  Serial.println(F("Running clockwise"));
  digitalWrite(dirPin, HIGH); // Enables the motor to move in a particular direction
  // Makes 200 pulses for making one full cycle rotation
  for (int i = 0; i < stepsPerRev; i++) {
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(pulseWidthMicros);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(millisBtwnSteps);
  }
  delay(1000); // One second delay

  Serial.println(F("Running counter-clockwise"));
  digitalWrite(dirPin, LOW); //Changes the rotations direction
  // Makes 400 pulses for making two full cycle rotation
  for (int i = 0; i < 2*stepsPerRev; i++) {
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(pulseWidthMicros);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(millisBtwnSteps);
  }
  delay(1000);
}

Para mais funções, pode utilizar a biblioteca AccelStepper.h

Aplicações

  • Controlo de um motor passo a passo
  • Controlo de vários motores com uma placa CNC

Fontes

https://www.arduinolibraries.info/libraries/accel-stepper

Usando um Arduino CNC Shield V3

Usando um Arduino CNC Shield V3

Neste tutorial, veremos a utilização do Escudo CNC V3 para Arduino. Para poder gerir uma máquina como uma CNC ou uma impressora 3D com vários motores passo a passo, é interessante ter uma placa que facilite a ligação dos diferentes elementos da máquina. Este é o papel do escudo CNC.

Material

  • Arduino UNO
  • Escudo CNC V3
  • Condutor Stepper A4988 ou DRV8825 ou SilentStepStick
  • Cabo USBA macho para USB B macho

Como funciona

O Escudo CNC V3 é uma placa de extensão para Arduino UNO ou Mega que pode ser facilmente interligada a controladores de motores passo-a-passo, como o A4988. Também permite conduzir e gerir os elementos necessários ao funcionamento de uma fresadora digital (CNC). Ou seja, paragens finais, ventiladores, etc,

Esquema

O escudo é colocado no microcontrolador Arduino e os motores são ligados directamente aos pinos de saída dos condutores. Pode escolher os condutores que desejar em função da potência dos seus motores e das suas aplicações (A4988, DRV8825, SilentStepStick, TMC).

Os terminais estão disponíveis abaixo de cada condutor para seleccionar a resolução do passo. Estes terminais são ligados aos pinos MS0, MS1 e MS2 dos controladores.

Antes de ligar os motores, certifique-se de que o limitador de corrente em cada controlador corresponde ao motor que está a conduzir.

Código

Para accionar um motor passo-a-passo com Escudo V3 CNC, referimo-nos ao pinout do escudo, que nos dá acesso aos pinos de chamada para enviar comandos ao controlador do motor (DRV8825, A4988 ou SilentStepStick).

const int enPin=8;
const int stepXPin = 2; //X.STEP
const int dirXPin = 5; // X.DIR
const int stepYPin = 3; //Y.STEP
const int dirYPin = 6; // Y.DIR
const int stepZPin = 4; //Z.STEP
const int dirZPin = 7; // Z.DIR

int stepPin=stepYPin;
int dirPin=dirYPin;

const int stepsPerRev=200;
int pulseWidthMicros = 100;  // microseconds
int millisBtwnSteps = 1000;

void setup() {
  Serial.begin(9600);
  pinMode(enPin, OUTPUT);
  digitalWrite(enPin, LOW);
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
 
  Serial.println(F("CNC Shield Initialized"));
}

void loop() {
  Serial.println(F("Running clockwise"));
  digitalWrite(dirPin, HIGH); // Enables the motor to move in a particular direction
  // Makes 200 pulses for making one full cycle rotation
  for (int i = 0; i < stepsPerRev; i++) {
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(pulseWidthMicros);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(millisBtwnSteps);
  }
  delay(1000); // One second delay

  Serial.println(F("Running counter-clockwise"));
  digitalWrite(dirPin, LOW); //Changes the rotations direction
  // Makes 400 pulses for making two full cycle rotation
  for (int i = 0; i < 2*stepsPerRev; i++) {
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(pulseWidthMicros);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(millisBtwnSteps);
  }
  delay(1000);
}

Para testar o funcionamento do Shield e dos motores, não utilizamos nenhuma biblioteca em particular. Contudo, se quiser utilizar funcionalidades mais avançadas pode utilizar a biblioteca AccelStepper ou o firmware GRBL V0.9.

Resultado

Assim que o código tiver sido carregado e o sistema ligado, deverá ver o motor ligado ao condutor em Y rodar uma volta no sentido dos ponteiros do relógio e duas voltas no sentido anti-horário. Se não for este o caso, provavelmente tem um problema de ligação.

Também é possível que o rastilho no quadro esteja danificado. Pode substituí-lo por um fio de chumbo.

Aplicações

  • Faça o seu próprio CNC ou gravador a laser
  • Fazer um cortador
  • Conduzir até três motores passo-a-passo de forma independente

Fontes

Controlar vários motores com o Motor Shield V2

Controlar vários motores com o Motor Shield V2

O Motor Shield V2 é uma placa de extensão para os microcontroladores Arduino UNO e Mega, para controlar motores de corrente contínua e motores de passo. Para controlar motores, é possível utilizar circuitos integrados diretamente, mas isso requer uma cablagem extensa que pode se tornar muito difícil de administrar. Para realizar montagens mais limpas, pode criar os seus próprios circuitos impressos ou utilizar shields.

Vamos usar o Motor Shield V2 e ver as suas melhorias em relação à versão anterior.

Pré-requisito: Programar com o Arduino

Material

  • Computador
  • Arduino UNO
  • Cabo USB para ligar o Arduino ao computador
  • Motor CC
  • Motor de passo
  • Motor Shield V2

Visão geral do Motor Shield V2

O Motor Shield V2 utiliza o TB6612 MOSFET, com capacidade de 1,2A por canal, e a comunicação I2C. Ele usa menos pinos do que a versão anterior:

  • Digital pin SCL/A5: Comunicação I2C Serial Clock Line
  • Digital pin SDA/A4: Comunicação I2C Serial Clock Line

O Motor Shield V2 tem um jumper para selecionar o endereço I2C e pode ser empilhado. Isso permite conduzir até 32 shields (ou 64 motores de passo ou 128 motores CC) com uma única placa Arduino.

Esquema

Compatível com as placas UNO e Mega, o shield é colocado diretamente sobre a placa Arduino. A fonte de alimentação liga-se ao bloco terminal Power. Os motores são ligados aos blocos terminais M1 a M4. Pode ser necessário ligar três tipos de motores (fora os servomotores):

  • motor CC
  • motor de passo unipolar
  • motor de passo bipolar


As ligações desses motores estão detalhadas nos diagramas a seguir..

Código para controle de motores CC

Para interagir com o Motor Shield V2, utilizamos a biblioteca Adafruit_MotorShield.h. Para conduzir o motor CC, usamos a classe Adafruit_DCMotor, cujas funções a se conhecer são:

  • motor.getMotor(integer) para selecionar o motor utilizado
  • motor.run() para ativar o motor num sentido ou outro (RELEASE,BACKWARD,FORWARD).
  • motor.setSpeed() para definir a velocidade
#include <Wire.h>
#include <Adafruit_MotorShield.h>

// Create the motor shield object with the default I2C address
Adafruit_MotorShield AFMS = Adafruit_MotorShield(); 
// Or, create it with a different I2C address (say for stacking)
// Adafruit_MotorShield AFMS = Adafruit_MotorShield(0x61); 

// Select which 'port' M1, M2, M3 or M4. In this case, M1
Adafruit_DCMotor *myMotor = AFMS.getMotor(1);
// You can also make another motor on port M2
//Adafruit_DCMotor *myOtherMotor = AFMS.getMotor(2);

void setup() {
  Serial.begin(9600);           // set up Serial library at 9600 bps
  Serial.println("Adafruit Motorshield v2 - DC Motor test!");

  AFMS.begin();  // create with the default frequency 1.6KHz
  //AFMS.begin(1000);  // OR with a different frequency, say 1KHz
  
  // Set the speed to start, from 0 (off) to 255 (max speed)
  myMotor->setSpeed(150);
  myMotor->run(FORWARD);
  // turn on motor
  myMotor->run(RELEASE);
}

void loop() {
  uint8_t i;
  
  Serial.print("tick");

  myMotor->run(FORWARD);
  for (i=0; i<255; i++) {
    myMotor->setSpeed(i);  
    delay(10);
  }
  for (i=255; i!=0; i--) {
    myMotor->setSpeed(i);  
    delay(10);
  }
  
  Serial.print("tock");

  myMotor->run(BACKWARD);
  for (i=0; i<255; i++) {
    myMotor->setSpeed(i);  
    delay(10);
  }
  for (i=255; i!=0; i--) {
    myMotor->setSpeed(i);  
    delay(10);
  }

  Serial.print("tech");
  myMotor->run(RELEASE);
  delay(1000);
}

Código para controle de motores de passo

Para controlar um motor de passo, utilizamos a classe Adafruit_StepperMotor, cujas funções a se conhecer são:

  • motor.getStepper(número de passos , terminal utilizado) para selecionar o motor utilizado
  • motor.setSpeed(velocidade) para definir a velocidade
  • motor.step(número de passos, sentido, algoritmo) para girar um número de passos num sentido ou outro

Este é o exemplo da biblioteca.

#include <Wire.h>
#include <Adafruit_MotorShield.h>

// Create the motor shield object with the default I2C address
Adafruit_MotorShield AFMS = Adafruit_MotorShield(); 
// Or, create it with a different I2C address (say for stacking)
// Adafruit_MotorShield AFMS = Adafruit_MotorShield(0x61); 

// Connect a stepper motor with 4080 steps per revolution (1.8 degree)
// to motor port #2 (M3 and M4)
Adafruit_StepperMotor *myMotor = AFMS.getStepper(48, 2);


void setup() {
  Serial.begin(9600);           // set up Serial library at 9600 bps
  Serial.println("Stepper test!");

  AFMS.begin();  // create with the default frequency 1.6KHz
  //AFMS.begin(1000);  // OR with a different frequency, say 1KHz
  
  myMotor->setSpeed(10);  // 10 rpm   
}

void loop() {
  int nbSteps=4080;
  
  Serial.println("Single coil steps forward");
  myMotor->step(nbSteps, FORWARD, SINGLE); 
  delay(1000);
  Serial.println("Single coil steps backward");
  myMotor->step(nbSteps, BACKWARD, SINGLE); 
  delay(1000);
  Serial.println("Double coil steps forward");
  myMotor->step(nbSteps, FORWARD, DOUBLE); 
  Serial.println("Double coil steps backward");
  myMotor->step(nbSteps, BACKWARD, DOUBLE);
  delay(1000);
  Serial.println("Interleave coil steps forward");
  myMotor->step(nbSteps, FORWARD, INTERLEAVE); 
  Serial.println("Interleave coil steps backward");
  myMotor->step(nbSteps, BACKWARD, INTERLEAVE); 
  delay(1000);
  Serial.println("Microstep steps forward");
  myMotor->step(50, FORWARD, MICROSTEP); 
  Serial.println("Microstep steps backward");
  myMotor->step(50, BACKWARD, MICROSTEP);
  delay(1000);
}

Converter o código do V1 para o V2

Para converter o seu código Arduino do Motor Shield V1 para o V2, modifique os seguintes itens:

  • Substitua a biblioteca:
    #include <Adafruit_MotorShield.h> 
  • Crie um objeto MotorShield:
    Adafruit_MotorShield AFMS = Adafruit_MotorShield();  
  • Crie um objeto Motor usando um ponteiro:
    Adafruit_DCMotor *motorG = AFMS.getMotor(1); 
    Adafruit_StepperMotor
    *myMotor = AFMS.getStepper(48, 2);
  • Acrescente a linha de inicialização do shield:
      AFMS.begin();   
  • Substitua os “. ” por ” -> ” ao chamar funções:
    motorG->setSpeed(motorSpeed);  
    motorG->run(RELEASE);

Teste e combine estes exemplos para obter as funcionalidades que deseja. Se tiver algum problema ao usar o seu Motor Shield, fique à vontade para nos deixar um comentário ou enviar uma mensagem.

Aplicação

  • Conduzir um robô com 2, 4 ou mais rodas

Fontes

Retrouvez nos tutoriels et d’autres exemples dans notre générateur automatique de code
La Programmerie

Controlar vários motores com o Raspberry Pi e o MotorHAT

Controlar vários motores com o Raspberry Pi e o MotorHAT

Para controlar um motor de passo ou de corrente contínua com um Raspberry Pi, é necessário acrescentar um circuito integrado, como uma ponte H. Para simplificar a montagem, existem shields como para o Arduino, que no caso do Raspberry. se chamam HAT (chapéu). Veremos como comunicar com o MotorHAT.

Pré-requisitos: Programar com o Raspberry Pi

Material

  • Monitor
  • Cabo HDMI
  • Teclado
  • Raspberry Pi 3 (com sistema operacional em micro SD)
  • Mouse
  • Carregador micro USB B
  • Adafruit MotorHat
  • Motor CC

Apresentação do MotorHat

O MotorHat utiliza transistores MOSFET TB6612 para controlar a corrente nos motores. Ele faz interface com o Raspberry Pi por meio de comunicação I2C, permitindo economizar entradas e saídas. O MotorHAT é compatível com todas as placas Raspberry Pi.

  • Digital pin SCL/BCM3: Comunicação I2C Serial Clock Line
  • Digital Pin SDA/BCM: Comunicação I2C Seria Clock Line

O MotorHat tem um jumper para selecionar o endereço I2C e pode ser empilhado. Isso permite controlar até 32 shields (ou 64 motores de passo ou 128 motores CC) com uma única placa.

Esquema de ligação

Compatível com as placas Raspberry Pi, o HAT é colocado diretamente sobre os pinos do Raspberry. A fonte de alimentação liga-se ao bloco terminal POWER. Os motores ligam-se aos blocos terminais M1 a M4. Pode ser necessário ligar três tipos de motores:

  • motor CC
  • motor de passo unipolar
  • motor de passo bipolar

As ligações desses motores são detalhadas nos diagramas a seguir.

Configuração do Raspberry Pi

Para poder comunicar com o MotorHAT, é preciso autorizar o Raspberry Pi a usar a comunicação I2C. Na área de trabalho, no menu “Preferências”, abra o menu “Configuração do Raspberry Pi”. Sob a aba “Interfaces”, selecione “Permitir I2C”, depois “Validar”.

Ou então, num terminal, digite “sudo raspi-config”. Em “5 Opções de Interface”, selecione “P5 I2C” e depois valide.

Código básico para controlar um motor CC

Para comunicar com o MotorHat, usaremos a biblioteca Adafruit_MotorHAT

#!/usr/bin/python
#i2c 0x60 0x70

from Adafruit_MotorHAT import Adafruit_MotorHAT,Adafruit_DCMotor

import time
import atexit

mh=Adafruit_MotorHAT(addr=0x60)
MAX_SPEED=150

def turnOffMotors():
    mh.getMotor(1).run(Adafruit_MotorHAT.RELEASE)
    mh.getMotor(2).run(Adafruit_MotorHAT.RELEASE)
    mh.getMotor(3).run(Adafruit_MotorHAT.RELEASE)
    mh.getMotor(4).run(Adafruit_MotorHAT.RELEASE)

atexit.register(turnOffMotors)

motor=mh.getMotor(1)

while True:
	print("Forward \n")
	motor.run(Adafruit_MotorHAT.FORWARD)
	print("Speed up \n")
	for i in range(MAX_SPEED):
		motor.setSpeed(i)
		time.sleep(0.01)
	
	print("Speed down \n")
	for i in reversed(range(MAX_SPEED)):
		motor.setSpeed(i)
		time.sleep(0.01)
	
	print("Backward\n")
	motor.run(Adafruit_MotorHAT.BACKWARD)
	print "Speed up \n"
	for i in range(MAX_SPEED):
		motor.setSpeed(i)
		time.sleep(0.01)
	
	print("Speed down \n")
	for i in reversed(range(MAX_SPEED)):
		motor.setSpeed(i)
		time.sleep(0.01)
	
	print("STOP \n")
	motor.run(Adafruit_MotorHAT.RELEASE)
	time.sleep(2)

Nesse exemplo, uma função de desligar é definida com o objeto atexit. Isso assegura que os motores desliguem quando saímos do scrip Python..

Código básico para controlar um motor de passo

Para utilizar um motor de passo, é necessário obter o objeto Stepper definido na Adafruit_MotorHAT.

#!/usr/bin/python
#import Adafruit_MotorHAT, Adafruit_DCMotor, Adafruit_Stepper
from Adafruit_MotorHAT import Adafruit_MotorHAT, Adafruit_DCMotor, Adafruit_StepperMotor

import time
import atexit

# create a default object, no changes to I2C address or frequency
mh = Adafruit_MotorHAT()

# recommended for auto-disabling motors on shutdown!
def turnOffMotors():
    mh.getMotor(1).run(Adafruit_MotorHAT.RELEASE)
    mh.getMotor(2).run(Adafruit_MotorHAT.RELEASE)
    mh.getMotor(3).run(Adafruit_MotorHAT.RELEASE)
    mh.getMotor(4).run(Adafruit_MotorHAT.RELEASE)

atexit.register(turnOffMotors)

myStepper = mh.getStepper(200, 1)  # 200 steps/rev, motor port #1
myStepper.setSpeed(30)             # 30 RPM

while (True):
    print("Single coil steps")
    myStepper.step(100, Adafruit_MotorHAT.FORWARD,  Adafruit_MotorHAT.SINGLE)
    myStepper.step(100, Adafruit_MotorHAT.BACKWARD, Adafruit_MotorHAT.SINGLE)

    print("Double coil steps")
    myStepper.step(100, Adafruit_MotorHAT.FORWARD,  Adafruit_MotorHAT.DOUBLE)
    myStepper.step(100, Adafruit_MotorHAT.BACKWARD, Adafruit_MotorHAT.DOUBLE)

    print("Interleaved coil steps")
    myStepper.step(100, Adafruit_MotorHAT.FORWARD,  Adafruit_MotorHAT.INTERLEAVE)
    myStepper.step(100, Adafruit_MotorHAT.BACKWARD, Adafruit_MotorHAT.INTERLEAVE)

    print("Microsteps")
    myStepper.step(100, Adafruit_MotorHAT.FORWARD,  Adafruit_MotorHAT.MICROSTEP)
    myStepper.step(100, Adafruit_MotorHAT.BACKWARD, Adafruit_MotorHAT.MICROSTEP

Obs: Fique atento às indentações ao escrever ou copiar um código, para evitar erros de compilação.

Inspire-se nos exemplos acima para usar o Raspberry Pi para controlar o seu sistema que contenha um motor de passo ou motor CC. Sinta-se livre para nos deixar um comentário ou uma mensagem caso tenha dificuldades para controlar os seus motores com o Raspberry Pi.

Aplicações

Conduzir um robô com vários motores de corrente contínua ou de passo

Fontes

Retrouvez nos tutoriels et d’autres exemples dans notre générateur automatique de code
La Programmerie