Motore passo-passo 28BYJ-48: tutto quello che devi sapere

El 28BYJ-48 è un motore passo-passo unipolare basso costo e alta precisione, ideale per progetti di elettronica, stampanti 3D, macchine CNC e robotica. Le sue dimensioni compatte, il basso consumo energetico e la facilità d'uso lo rendono una scelta popolare per gli hobbisti e i professionisti dell'elettronica.

Inoltre, insieme a questo motore, a modulo con ULN2003, per il tuo controllo. In questo modo disponiamo di tutto il necessario per poter utilizzare questo sistema in modo completo, utilizzando un microcontrollore o una scheda Arduino o simili.

Cos'è il motore passo-passo 28BYJ-48?

Un il motore passo-passo è un tipo di motore elettrico che si muove in piccoli passi angolari discreti, piuttosto che in una rotazione continua. Funziona utilizzando una serie di elettromagneti che vengono attivati ​​in una sequenza specifica. Attivando diversi elettromagneti si crea un campo magnetico che attrae il rotore del motore, facendolo ruotare un passo alla volta. Il numero di passi per giro e la precisione del movimento dipendono dal design specifico del motore e dalla sequenza di controllo utilizzata.

All'interno dei motori passo-passo ne abbiamo due tipologie:

• Unipolare- Hanno un unico set di bobine e richiedono uno speciale controller per invertire la corrente e far ruotare il motore in entrambe le direzioni.
• Bipolare- Hanno due serie di bobine indipendenti, che consentono loro di ruotare in entrambe le direzioni senza la necessità di un controller speciale.

Nel caso del 28BYJ-28 è di tipo unipolare, come ho detto prima. E, all'interno di questo gruppo, è caratterizzato da quanto segue occhiali:

• Stepper unipolare: controllo semplice con soli 4 cavi.
• Riduttore integrato: offre alta precisione (0.088° per passo) e coppia elevata (3 N·cm).
• Basso consumo energetico: 83 mA (modello 5V) o 32 mA (modello 12V).
• Alimentazione: 5 V o 12 V (a seconda del modello).
• Prezzo economico: a partire da 1.2 € per unità, o poco più se includono un modulo ULN2003.

Reland Sole 28BYJ-48...

3,57 €

Visualizza offerta

HiLetgo 5 pezzi ULN2003...

13,99 €

Visualizza offerta

ELEGOO 5 Set 28BYJ-48...

14,39 €

Visualizza offerta

Come l' possibili applicazioni, alcuni li ho già menzionati prima, ma qui vi do ancora qualche idea per i vostri progetti:

• Controllo di valvole idrauliche e pneumatiche.
• Robot articolati e bracci robotici.
• Posizionamento del sensore.
• Tavole rotanti per scanner.
• stampanti 3D.
• Macchine CNC.

Il motore passo-passo non funziona da solo, richiede un altro elemento. In questo caso, Il 28BYJ-48 è controllato da una scheda con ULN2003 integrato, che permette di amplificare la corrente delle uscite Arduino per alimentare le bobine del motore. Attivando le bobine nella sequenza corretta, il motore ruota passo dopo passo con grande precisione.

Tipi di sequenze e fasi di controllo

Ci varie sequenze di controllo per il 28BYJ-48, i più comuni sono:

• Sequenza d'onda completa: attiva tutte le bobine contemporaneamente.
• Sequenza di mezzo passo: Attiva due bobine adiacenti contemporaneamente.
• Sequenza di passi microscopica: Attiva una bobina alla volta.

Vediamo le fasi in dettaglio:

• Sequenza monofase: In una sequenza monofase accendiamo una singola bobina alla volta. Prendendo questa sequenza di accensione in una tabella, sarebbe necessario generare quanto segue nella piedinatura del motore:

• Sequenza bifase: accendiamo due bobine correlative in ciascuna fase, quindi il campo magnetico generato è maggiore (41% in più) quindi il motore ha più coppia, cioè otteniamo più forza. Come punto negativo, raddoppiamo il consumo di energia. Per quanto riguarda la tabella, sarebbe:

• Sequenza di mezzo passo: Questa è un'altra delle tappe che vedremo, potrai sperimentare ciò che ti interessa di più. Qui accendiamo alternativamente una e due bobine, ottenendo una precisione di mezzo passo. Viene utilizzato in applicazioni in cui è necessaria la massima precisione, anche se potrebbero verificarsi problemi quando l'applicazione è al limite di coppia. Esprimendo la sequenza in forma tabellare si ottiene:

28BYJ-28 con Arduino

La prima cosa è collegare correttamente il modulo e motore 28byj-48 alla nostra scheda Arduino, per fare ciò è sufficiente effettuare i seguenti collegamenti:

• Pin – da ULN2003 al GND di Arduino.
• Pin + dell'ULN2003 a Vcc (5v o in altri casi, se si tratta di un motore a 12v, bisognerebbe utilizzare un alimentatore con quella tensione) di Arduino.
• IN1, IN2, IN3 e IN4 dell'ULN2003 agli ingressi digitali D8, D9, D10 e D11 dell'Arduino.
• Il motore 28byj-48, collegalo semplicemente alla porta del modulo ULN2003.

Ora che sei connesso, la prossima cosa da fare è utilizzare un esempio nell'IDE di Arduino, che puoi utilizzare così com'è per sperimentarlo o modificarlo a tuo piacimento. In questo esempio, tutte le tabelle delle fasi sono commentate, come // davanti alla riga, sai... Se vuoi usarne una, cancella semplicemente // davanti alle istruzioni.

//Definir los pines
const int motorPin1 = 8;    // 28BYJ48 In1
const int motorPin2 = 9;    // 28BYJ48 In2
const int motorPin3 = 10;   // 28BYJ48 In3
const int motorPin4 = 11;   // 28BYJ48 In4
                   
//Definición de variables
int motorSpeed = 1200;   //Velocidad del motor
int stepCounter = 0;     //Contador de pasos
int stepsPerRev = 4076;  //Pasos para un giro completo

//Tablas de secuencia (descomentar la que necesites)
//Secuencia 1-fase
//const int numSteps = 4;
//const int stepsLookup[4] = { B1000, B0100, B0010, B0001 };

//Secuencia 2-fases
//const int numSteps = 4;
//const int stepsLookup[4] = { B1100, B0110, B0011, B1001 };

//Secuencia media fase
//const int numSteps = 8;
//const int stepsLookup[8] = { B1000, B1100, B0100, B0110, B0010, B0011, B0001, B1001 };

void setup()
{
  //Declarar los pines usados como salida
  pinMode(motorPin1, OUTPUT);
  pinMode(motorPin2, OUTPUT);
  pinMode(motorPin3, OUTPUT);
  pinMode(motorPin4, OUTPUT);
}

void loop()
{
  for (int i = 0; i < stepsPerRev * 2; i++)
  {
    clockwise();
    delayMicroseconds(motorSpeed);
  }
  for (int i = 0; i < stepsPerRev * 2; i++)
  {
    anticlockwise();
    delayMicroseconds(motorSpeed);
  }
  delay(1000);
}

void clockwise()
{
  stepCounter++;
  if (stepCounter >= numSteps) stepCounter = 0;
  setOutput(stepCounter);
}

void anticlockwise()
{
  stepCounter--;
  if (stepCounter < 0) stepCounter = numSteps - 1;
  setOutput(stepCounter);
}

void setOutput(int step)
{
  digitalWrite(motorPin1, bitRead(stepsLookup[step], 0));
  digitalWrite(motorPin2, bitRead(stepsLookup[step], 1));
  digitalWrite(motorPin3, bitRead(stepsLookup[step], 2));
  digitalWrite(motorPin4, bitRead(stepsLookup[step], 3));
}