.. note::
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 [|link_sf_facebook|] e unisciti oggi stesso!
.. _1.3.3_motor:
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
-------------
.. image:: img/list_1.3.3.png
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:
.. image:: img/image129.png
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.
.. image:: img/image130.png
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.
.. image:: img/image132.png
Schema del Circuito
-----------------------
.. image:: img/image339.png
Procedure Sperimentali
---------------------------
**Step 1:** Costruire il circuito.
.. image:: img/image134.png
:width: 800
Per gli Utenti di Linguaggio C
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
**Passo 2**: Accedi alla cartella del codice.
.. raw:: html
.. code-block::
cd ~/davinci-kit-for-raspberry-pi/c/1.3.3/
**Passo 3**: Compila il codice.
.. raw:: html
.. code-block::
gcc 1.3.3_StepperMotor.c -lwiringPi
**Passo 4**: Esegui il file eseguibile.
.. raw:: html
.. code-block::
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.
.. note::
Se non funziona dopo l'esecuzione o appare un messaggio di errore: \"wiringPi.h: No such file or directory\", consulta :ref:`faq_c_nowork`.
**Codice**
.. code-block:: c
#include
#include
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<>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**
.. code-block:: c
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)
.. code-block:: c
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.
.. code-block:: c
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<>i));}
delayMicroseconds(stepSpeed);
}
}
}
Per far ruotare il motore passo-passo **in senso orario**, lo stato di livello di motorPin è mostrato nella tabella seguente:
.. image:: img/image340.png
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.
.. image:: img/image341.png
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.
.. raw:: html
.. code-block::
cd ~/davinci-kit-for-raspberry-pi/python/
**Passo 3**: Esegui il file eseguibile.
.. raw:: html
.. code-block::
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**
.. note::
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``.
.. raw:: html
.. code-block:: 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<>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**
.. code-block:: python
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).
.. code-block:: python
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.
.. code-block:: python
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<>i))
sleep(stepSpeed)
Per far ruotare il motore passo-passo in senso orario, lo stato di livello
dei motorPin è mostrato nella tabella seguente:
.. image:: img/image342.png
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:
.. image:: img/image343.png
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.
Immagine del Fenomeno
-------------------------
.. image:: img/image135.jpeg