Nota

Ciao e benvenuto nella Community di appassionati di SunFounder Raspberry Pi & Arduino & ESP32 su Facebook! Esplora più a fondo il mondo di Raspberry Pi, Arduino e ESP32 con altri appassionati.

Perché unirsi a noi?

Supporto Esperto: Risolvi problemi post-vendita e sfide tecniche con l’aiuto della nostra community e del nostro team.
Impara e Condividi: Scambia consigli e tutorial per migliorare le tue competenze.
Anteprime Esclusive: Ottieni accesso anticipato alle nuove comunicazioni sui prodotti e agli spoiler.
Sconti Speciali: Approfitta di sconti esclusivi sui nostri nuovi prodotti.
Promozioni Festive e Giveaway: Partecipa a giveaway e promozioni per le festività.

👉 Pronto per esplorare e creare con noi? Clicca su [Qui] e unisciti oggi stesso!

1.3.3 Motore Passo-passo

Introduzione

I motori passo-passo, grazie al loro design unico, possono essere controllati con un alto grado di precisione senza bisogno di meccanismi di feedback. L’albero di un motore passo-passo, montato con una serie di magneti, è controllato da una serie di bobine elettromagnetiche che si attivano positivamente e negativamente in una sequenza specifica, muovendolo con precisione in piccoli «passi» avanti o indietro.

Componenti

Principio

Motore Passo-passo

Esistono due tipi di motori passo-passo, unipolari e bipolari, ed è importante sapere con quale tipo si sta lavorando. In questo esperimento useremo un motore passo-passo unipolare.

Il motore passo-passo è un dispositivo a quattro fasi che utilizza una corrente continua unipolare. Alimentando tutti gli avvolgimenti del motore in una sequenza temporale appropriata, il motore può ruotare passo dopo passo. Lo schema di un motore passo-passo reattivo a quattro fasi:

Nella figura, al centro del motore si trova un rotore - un magnete permanente a forma di ingranaggio. Attorno al rotore ci sono denti numerati da 0 a 5. Più all’esterno, sono presenti 8 poli magnetici, collegati a coppie tramite avvolgimenti, formando quattro fasi da A a D. Ogni fase ha due terminali collegati rispettivamente agli interruttori SA, SB, SC e SD. Così, le quattro fasi sono in parallelo nel circuito, e i due poli magnetici in una fase sono in serie.

Funzionamento di un motore passo-passo a 4 fasi:

Quando l’interruttore SB è acceso e gli interruttori SA, SC e SD sono spenti, i poli magnetici della fase B si allineano con i denti 0 e 3 del rotore. Nel frattempo, i denti 1 e 4 creano uno sfasamento con i poli delle fasi C e D. Accendendo SC e spegnendo SA, SB e SD, il rotore ruota grazie al campo magnetico della fase C, e i denti 1 e 4 si allineano ai poli magnetici della fase C, con le altre coppie di denti che mantengono uno sfasamento rispetto alle altre fasi. Attivando le fasi A, B, C e D in sequenza, il rotore ruoterà nell’ordine A, B, C e D.

Il motore passo-passo a quattro fasi ha tre modalità operative: quattro passi singoli, quattro passi doppi e otto passi. Gli angoli di passo sono uguali per i quattro passi singoli e doppi, ma la coppia è inferiore nel caso dei quattro passi singoli. Gli otto passi dimezzano l’angolo di passo e aumentano la coppia e la precisione di controllo.

Il motore passo-passo che usiamo ha un rotore con 32 poli magnetici, quindi una rotazione completa richiede 32 passi. L’albero di uscita è collegato a un riduttore con un rapporto di 1/64, quindi una rotazione completa richiede 32*64=2048 passi.

ULN2003

Per integrare il motore nel circuito, è necessario utilizzare una scheda driver. Il Driver del Motore Passo-passo ULN2003 è un circuito a 7 canali. Quando il pin di ingresso è ad alto livello, il pin di uscita è a basso livello, e viceversa. Se IN1 è impostato su livello alto, mentre IN2, IN3 e IN4 su livello basso, l’uscita OUT1 sarà a livello basso e le altre uscite saranno a livello alto.

Il driver del motore passo-passo con chip ULN2003 e 4 LED è illustrato di seguito. Nella scheda, IN1, IN2, IN3 e IN4 fungono da ingressi e i quattro LED, A, B, C e D, indicano lo stato dei pin di ingresso. Inoltre, OUT1, OUT2, OUT3 e OUT4 sono collegati a SA, SB, SC e SD sul driver del motore passo-passo. Quando IN1 è a livello alto, il LED A si accende, SA si attiva e il motore ruota di un passo. Continuando con sequenze temporali specifiche, il motore ruota passo dopo passo.

Schema del Circuito

Procedure Sperimentali

Step 1: Costruire il circuito.

Per gli Utenti di Linguaggio C

Passo 2: Accedi alla cartella del codice.

cd ~/davinci-kit-for-raspberry-pi/c/1.3.3/

Passo 3: Compila il codice.

gcc 1.3.3_StepperMotor.c -lwiringPi

Passo 4: Esegui il file eseguibile.

sudo ./a.out

Durante l’esecuzione del codice, il motore passo-passo ruoterà in senso orario o antiorario in base all’input che inserirai: 'a' per antiorario o 'c' per orario.

Nota

Se non funziona dopo l’esecuzione o appare un messaggio di errore: "wiringPi.h: No such file or directory", consulta Il codice C non funziona?.

Codice

#include <stdio.h>
#include <wiringPi.h>

const int motorPin[] = {1, 4, 5, 6};
int rolePerMinute = 15;
int stepsPerRevolution = 2048;
int stepSpeed = 0;

void rotary(char direction){
    if(direction == 'c'){
        for(int j=0;j<4;j++){
            for(int i=0;i<4;i++)
                {digitalWrite(motorPin[i],0x99>>j & (0x08>>i));}
            delayMicroseconds(stepSpeed);
        }
    }
    else if(direction =='a'){
        for(int j=0;j<4;j++){
            for(int i=0;i<4;i++)
                {digitalWrite(motorPin[i],0x99<<j & (0x80>>i));}
            delayMicroseconds(stepSpeed);
        }
    }
}

void loop()
{
    char direction = '0';
    while (1)
    {
        printf("select motor direction a=anticlockwise, c=clockwise: ");
        delay(100);
        direction=getchar();
        if (direction == 'c')
        {
            printf("motor running clockwise\n");
            delay(100);
            break;
        }
        else if (direction == 'a')
        {
            printf("motor running anti-clockwise\n");
            delay(100);
            break;
        }
        else
        {
            printf("input error, please try again!\n");
            delay(100);
        }
    }
    while(1)
    {
        rotary(direction);
    }
}

void main(void)
{
    if (wiringPiSetup() == -1)
    {
        printf("setup wiringPi failed !");
        return;
    }
    for (int i = 0; i < 4; i++)
    {
        pinMode(motorPin[i], OUTPUT);
    }
    stepSpeed = (60000000 / rolePerMinute) / stepsPerRevolution;
    loop();
}

Spiegazione del Codice

int rolePerMinute = 15;
int stepsPerRevolution = 2048;
int stepSpeed = 0;

rolePerMinute: Rivoluzioni per minuto, l’RPM del motore passo-passo utilizzato in questo kit dovrebbe essere compreso tra 0 e 17.

stepsPerRevolution: Numero di passi per ogni giro completo; il motore passo-passo utilizzato in questo kit richiede 2048 passi per rivoluzione.

stepSpeed: Tempo necessario per ogni passo. Nel main(), il valore viene assegnato tramite la formula:「(60000000 / rolePerMinute) / stepsPerRevolution」 (60.000.000 us = 1 minuto)

void loop()
{
    char direction = '0';
    while (1)
    {
        printf("select motor direction a=anticlockwise, c=clockwise: ");
        direction=getchar();
        if (direction == 'c')
        {
            printf("motor running clockwise\n");
            break;
        }
        else if (direction == 'a')
        {
            printf("motor running anti-clockwise\n");
            break;
        }
        else
        {
            printf("input error, please try again!\n");
        }
    }
    while(1)
    {
        rotary(direction);
    }
}

La funzione loop() è suddivisa in due parti (situate tra due cicli while(1)):

La prima parte ottiene il valore del tasto. Quando viene premuto “a” o “c”, il ciclo si interrompe e l’input viene fermato.

La seconda parte chiama rotary(direction) per far funzionare il motore passo-passo.

void rotary(char direction){
    if(direction == 'c'){
        for(int j=0;j<4;j++){
            for(int i=0;i<4;i++)
                {digitalWrite(motorPin[i],0x99>>j & (0x08>>i));}
            delayMicroseconds(stepSpeed);
        }
    }
    else if(direction =='a'){
        for(int j=0;j<4;j++){
            for(int i=0;i<4;i++)
                {digitalWrite(motorPin[i],0x99<<j & (0x80>>i));}
            delayMicroseconds(stepSpeed);
        }
    }
}

Per far ruotare il motore passo-passo in senso orario, lo stato di livello di motorPin è mostrato nella tabella seguente:

Il valore di scrittura per MotorPin viene implementato utilizzando un ciclo for a due livelli.

Nel Passo1, j=0, i=0~4.

motorPin[0] sarà impostato su livello alto（10011001&00001000=1）

motorPin[1] sarà impostato su livello basso（10011001&00000100=0）

motorPin[2] sarà impostato su livello basso（10011001&00000010=0）

motorPin[3] sarà impostato su livello alto（10011001&00000001=1）

Nel Passo2, j=1, i=0~4.

motorPin[0] sarà impostato su livello alto（01001100&00001000=1）

motorPin[1] sarà impostato su livello basso（01001100&00000100=1）

e così via.

Per far ruotare il motore passo-passo in senso antiorario, lo stato di livello di motorPin è mostrato nella seguente tabella.

Nel Passo1, j=0, i=0~4.

motorPin[0] sarà impostato su livello alto（10011001&10000000=1）

motorPin[1] sarà impostato su livello basso（10011001&01000000=0）

Nel Passo2, j=1, i=0~4.

motorPin[0] sarà impostato su livello alto（00110010&10000000=0）

motorPin[1] sarà impostato su livello basso（00110010&01000000=0）

e così via.

Per Utenti Python

Passo 2: Vai nella cartella del codice.

cd ~/davinci-kit-for-raspberry-pi/python/

Passo 3: Esegui il file eseguibile.

sudo python3 1.3.3_StepperMotor.py

Quando il codice viene eseguito, il motore passo-passo ruoterà in senso orario o antiorario a seconda del tuo input “a” o “c”.

Codice

Nota

Puoi Modificare/Ripristinare/Copiare/Eseguire/Arrestare il codice sottostante. Prima, però, è necessario accedere al percorso del codice sorgente come davinci-kit-for-raspberry-pi/python.

import RPi.GPIO as GPIO
from time import sleep

motorPin = (18,23,24,25)
rolePerMinute =15
stepsPerRevolution = 2048
stepSpeed = (60/rolePerMinute)/stepsPerRevolution

def setup():
    GPIO.setwarnings(False)
    GPIO.setmode(GPIO.BCM)
    for i in motorPin:
        GPIO.setup(i, GPIO.OUT)

def rotary(direction):
    if(direction == 'c'):
        for j in range(4):
            for i in range(4):
                GPIO.output(motorPin[i],0x99>>j & (0x08>>i))
            sleep(stepSpeed)

    elif(direction == 'a'):
        for j in range(4):
            for i in range(4):
                GPIO.output(motorPin[i],0x99<<j & (0x80>>i))
            sleep(stepSpeed)

def loop():
    while True:
        direction = input('select motor direction a=anticlockwise, c=clockwise: ')
        if(direction == 'c'):
            print('motor running clockwise\n')
            break
        elif(direction == 'a'):
            print('motor running anti-clockwise\n')
            break
        else:
            print('input error, please try again!')
    while True:
        rotary(direction)

def destroy():
    GPIO.cleanup()

if __name__ == '__main__':
    setup()
    try:
        loop()
    except KeyboardInterrupt:
        destroy()

Spiegazione del Codice

rolePerMinute = 15
stepsPerRevolution = 2048
stepSpeed = (60/rolePerMinute)/stepsPerRevolution

rolePerMinute: Rivoluzioni per minuto, l’RPM del motore passo-passo utilizzato in questo kit dovrebbe essere tra 0 e 17.

stepsPerRevolution: Numero di passi per ogni rotazione, il motore passo-passo utilizzato in questo kit richiede 2048 passi per una rotazione completa.

stepSpeed: Il tempo impiegato per ogni passo, calcolato come 「 (60 / rolePerMinute) / stepsPerRevolution」(60s=1 minuto).

def loop():
    while True:
        direction = input('select motor direction a=anticlockwise, c=clockwise: ')
        if(direction == 'c'):
            print('motor running clockwise\n')
            break
        elif(direction == 'a'):
            print('motor running anti-clockwise\n')
            break
        else:
            print('input error, please try again!')
    while True:
        rotary(direction)

La funzione loop() è suddivisa in due parti (situate in due cicli while(True)) :

La prima parte serve a ottenere il valore della chiave. Quando viene premuto “a” o “c”, il ciclo si interrompe e l’input si arresta.

La seconda parte richiama rotary(direction) per avviare il motore passo-passo.

def rotary(direction):
    if(direction == 'c'):
        for j in range(4):
            for i in range(4):
                GPIO.output(motorPin[i],0x99>>j & (0x08>>i))
            sleep(stepSpeed)

    elif(direction == 'a'):
        for j in range(4):
            for i in range(4):
                GPIO.output(motorPin[i],0x99<<j & (0x80>>i))
            sleep(stepSpeed)

Per far ruotare il motore passo-passo in senso orario, lo stato di livello dei motorPin è mostrato nella tabella seguente:

Il valore di scrittura per MotorPin viene implementato utilizzando un ciclo for a due livelli.

Nel Passo1, j=0, i=0~4.

motorPin[0] sarà impostato su livello alto（10011001&00001000=1）

motorPin[1] sarà impostato su livello basso（10011001&00000100=0）

motorPin[2] sarà impostato su livello basso（10011001&00000010=0）

motorPin[3] sarà impostato su livello alto（10011001&00000001=1）

Nel Passo2, j=1, i=0~4.

motorPin[0] sarà impostato su livello alto（01001100&00001000=1）

motorPin[1] sarà impostato su livello basso（01001100&00000100=1）

e così via.

Per far ruotare il motore passo-passo in senso antiorario, lo stato di livello dei motorPin è mostrato nella tabella seguente:

Nel Passo1, j=0, i=0~4.

motorPin[0] sarà impostato su livello alto（10011001&10000000=1）

motorPin[1] sarà impostato su livello basso（10011001&01000000=0）

Nel Passo2, j=1, i=0~4.

motorPin[0] sarà impostato su livello alto（00110010&10000000=0）

motorPin[1] sarà impostato su livello basso（00110010&01000000=0）

e così via.

1.3.3 Motore Passo-passo

Introduzione

Componenti

Principio

Schema del Circuito

Procedure Sperimentali

Per gli Utenti di Linguaggio C

Per Utenti Python

Immagine del Fenomeno