Tutorial Arduino Motor Shield

Arduino Motor Shield consente di controllare facilmente la direzione e la velocità del motore utilizzando un Arduino. Consentendo di indirizzare semplicemente i pin di Arduino, è molto semplice incorporare un motore nel progetto. Inoltre, consente di alimentare un motore con un'alimentazione separata fino a 12v. Soprattutto, lo scudo è molto facile da trovare. Per tutti questi motivi, l'Arduino Motor Shield è un piccolo oggetto da avere nel tuo arsenale per la prototipazione rapida e la sperimentazione generale.

Passaggio 1: installare

I pin dello scudo motore Arduino ufficiale si allineeranno solo con Arduino Uno Rev. 3.

Per farlo funzionare con le versioni precedenti di Arduino, dovrai tagliare alcuni perni dallo scudo del motore. Tuttavia, questo non è affatto raccomandato.

Inserire i piedini dello schermo del motore nella presa dell'Arduino Uno.

Passaggio 2: caratteristiche dello scudo

Lo schermo del motore ha 2 canali, che consente il controllo di due motori CC o 1 motore passo-passo.

Dispone inoltre di 6 intestazioni per il collegamento di ingressi, uscite e linee di comunicazione Tinkerkit. L'uso di questi pin è alquanto limitato e quindi non trattato in questo tutorial.

Con un alimentatore esterno, lo schermo del motore può fornire in sicurezza fino a 12V e 2A per canale motore (o 4A a un singolo canale).

Ci sono pin sull'Arduino che sono sempre in uso dallo scudo. Indirizzando questi pin è possibile selezionare un canale del motore da avviare, specificare la direzione del motore (polarità), impostare la velocità del motore (PWM), arrestare e avviare il motore e monitorare l'assorbimento di corrente di ciascun canale.

La suddivisione dei pin è la seguente:

Per ulteriori informazioni sulle specifiche tecniche, consultare la pagina ufficiale dello scudo motore sul sito Arduino.

Passaggio 3: programma

Collega Arduino alla porta USB del tuo computer e apri l'ambiente di sviluppo Arduino.

Per fare in modo che la scheda faccia qualsiasi cosa, è necessario inizializzare il canale del motore attivando tre parametri:

1. Innanzitutto è necessario impostare la direzione del motore (polarità dell'alimentatore) impostandola su ALTA o BASSA.
2. Quindi è necessario disinnestare il perno del freno per il canale del motore impostandolo su BASSO.
3. Infine, per far muovere il motore, è necessario impostare la velocità inviando un comando PWM (analogWrite) al pin appropriato.

Se non si eseguono tutte e tre queste cose, il motore non si accenderà.

Nei seguenti passaggi sono riportati alcuni esempi comuni di configurazioni comuni del motore.

Passaggio 4: un motore

Per controllare un motore utilizzando Arduino Motor Shield, collegare innanzitutto il filo positivo (rosso) del motore al terminale + del canale A sullo schermo del motore e il filo di terra (nero) del motore al terminale del canale A - sullo schermo.

Un alimentatore esterno non è sempre necessario, ma migliora drasticamente le prestazioni del motore. Si consiglia di utilizzarne sempre uno.

Per collegare l'alimentatore esterno, collegare il filo positivo (rosso) dall'alimentatore al terminale "Vin" e il filo di terra (nero) al terminale "GND".

Infine, carica il codice per controllare Motor Shield su Arduino.

 / ************************************************* ************ Demo del motore CC a 1 canale della protezione motore di Randy Sarafan Per ulteriori informazioni, consultare: //www.instructables.com/id/Arduino-Motor-Shield-Tutorial/ **** ************************************************** ******* / void setup () {// Setup Canale A pinMode (12, OUTPUT); // Avvia la modalità Pin del canale A del motore A (9, OUTPUT); // Avvia il pin del canale di frenatura} void loop () {// forward @ full speed digitalWrite (12, HIGH); // Stabilisce la direzione in avanti del canale A digitalWrite (9, LOW); // Disinnesta il freno per il canale A analogWrite (3, 255); // Gira il motore sul canale A con ritardo a piena velocità (3000); digitalWrite (9, HIGH); // Inserire il freno per il ritardo del canale A (1000); // indietro @ half speed digitalWrite (12, LOW); // Stabilisce la direzione all'indietro del canale A digitalWrite (9, LOW); // Disinnesta il freno per il canale A analogWrite (3, 123); // Gira il motore sul canale A con ritardo a metà velocità (3000); digitalWrite (9, HIGH); // Inserire il freno per il ritardo del canale A (1000); } 
Passaggio 5: due motori 
L'interfaccia con due motori è praticamente uguale all'interfaccia con un motore. Basta collegare il motore al canale B.
L'unica differenza in termini di codice è che è necessario attivare un secondo canale per controllare il secondo motore.
Ecco il codice per il controllo di due motori: 
 / ************************************************* ************ Demo del motore DC 2 canali Motor Shield di Randy Sarafan Per ulteriori informazioni, consultare: //www.instructables.com/id/Arduino-Motor-Shield-Tutorial/ **** ************************************************** ******* / void setup () {// Setup Canale A pinMode (12, OUTPUT); // Avvia la modalità Pin del canale A del motore A (9, OUTPUT); // Avvia il pin del canale A del freno // Impostazione della modalità pin del canale B (13, OUTPUT); // Avvia la modalità Pin del canale A del motore A (8, OUTPUT); // Avvia il pin del canale A del freno} void loop () {// Motor A forward @ full speed digitalWrite (12, HIGH); // Stabilisce la direzione in avanti del canale A digitalWrite (9, LOW); // Disinnesta il freno per il canale A analogWrite (3, 255); // Gira il motore sul canale A alla massima velocità // Motore B indietro a metà velocità digitalWrite (13, LOW); // Stabilisce la direzione all'indietro del canale B digitalWrite (8, LOW); // Disinnesta il freno per il canale B analogWrite (11, 123); // Gira il motore sul canale B con ritardo a metà velocità (3000); digitalWrite (9, HIGH); // Inserire il freno per il canale A digitalWrite (9, HIGH); // Inserire il freno per il ritardo del canale B (1000); // Motor A forward @ full speed digitalWrite (12, LOW); // Stabilisce la direzione all'indietro del canale A digitalWrite (9, LOW); // Disinnesta il freno per il canale A analogWrite (3, 123); // Gira il motore sul canale A a metà velocità // Motore B in avanti @ full speed digitalWrite (13, HIGH); // Stabilisce la direzione in avanti del canale B digitalWrite (8, LOW); // Disinnesta il freno per il canale B analogWrite (11, 255); // Gira il motore sul canale B con ritardo alla massima velocità (3000); digitalWrite (9, HIGH); // Inserire il freno per il canale A digitalWrite (9, HIGH); // Inserire il freno per il ritardo del canale B (1000); } 
Passaggio 6: motore passo-passo 
Esistono diversi tipi di motori passo-passo, ma in questo tutorial ci occuperemo in modo specifico dei motori passo-passo bipolari. I motori passo-passo bipolari hanno tipicamente 4 pin, che corrispondono a due bobine. Per utilizzare uno stepper, è necessario alimentare queste due bobine in fase con polarità alternata.
Per capire quali due perni compongono una singola bobina, inserire un LED in uno qualsiasi dei due perni sulla sua presa e ruotare l'albero del motore. Se il LED si accende, hai trovato una bobina. Gli altri due pin dovrebbero costituire l'altra bobina.
Per far girare un motore bipolare:
Alimentare la prima bobina.
Quindi alimentare la seconda bobina con inversione di polarità.
Quindi alimentare la prima bobina con inversione di polarità.
Infine, alimentare la seconda bobina.
Per invertire la direzione del motore di uno stepper bipolare, è sufficiente invertire la polarità della seconda bobina.
Ecco il codice per far girare lo stepper in una direzione: 
 / ************************************************* ************ Demo del motore passo-passo dello scudo del motore di Randy Sarafan Per ulteriori informazioni, consultare: //www.instructables.com/id/Arduino-Motor-Shield-Tutorial/ ******** ************************************************** *** / int delaylegnth = 30; void setup () {// stabilisce la direzione del motore attiva / disattiva pin pinMode (12, OUTPUT); // CH A - HIGH = avanti e BASSO = indietro ??? pinMode (13, OUTPUT); // CH B - HIGH = avanti e BASSO = indietro ??? // stabilisce pinMode pin motore freno (9, OUTPUT); // freno (disabilita) CH A pinMode (8, OUTPUT); // freno (disabilita) CH B} void loop () {digitalWrite (9, LOW); // ENABLE CH A digitalWrite (8, HIGH); // DISABLE CH B digitalWrite (12, HIGH); // Imposta la direzione di CH A analogWrite (3, 255); // Sposta il ritardo CH A (delaylegnth); digitalWrite (9, HIGH); // DISABLE CH A digitalWrite (8, LOW); // ENABLE CH B digitalWrite (13, LOW); // Imposta la direzione di CH B analogWrite (11, 255); // Sposta il ritardo CH B (delaylegnth); digitalWrite (9, LOW); // ENABLE CH A digitalWrite (8, HIGH); // DISABLE CH B digitalWrite (12, LOW); // Imposta la direzione di CH A analogWrite (3, 255); // Sposta il ritardo CH A (delaylegnth); digitalWrite (9, HIGH); // DISABLE CH A digitalWrite (8, LOW); // ENABLE CH B digitalWrite (13, HIGH); // Imposta la direzione di CH B analogWrite (11, 255); // Sposta il ritardo CH B (delaylegnth); } 

Ecco il codice per far girare lo stepper nella direzione opposta: 
 / ************************************************* ************ Demo del motore passo-passo dello scudo del motore di Randy Sarafan Per ulteriori informazioni, consultare: //www.instructables.com/id/Arduino-Motor-Shield-Tutorial/ ******** ************************************************** *** / int delaylegnth = 30; void setup () {// stabilisce la direzione del motore attiva / disattiva pin pinMode (12, OUTPUT); // CH A - HIGH = avanti e BASSO = indietro ??? pinMode (13, OUTPUT); // CH B - HIGH = avanti e BASSO = indietro ??? // stabilisce pinMode pin motore freno (9, OUTPUT); // freno (disabilita) CH A pinMode (8, OUTPUT); // freno (disabilita) CH B} void loop () {digitalWrite (9, LOW); // ENABLE CH A digitalWrite (8, HIGH); // DISABLE CH B digitalWrite (12, HIGH); // Imposta la direzione di CH A analogWrite (3, 255); // Sposta il ritardo CH A (delaylegnth); digitalWrite (9, HIGH); // DISABLE CH A digitalWrite (8, LOW); // ENABLE CH B digitalWrite (13, HIGH); // Imposta la direzione di CH B analogWrite (11, 255); // Sposta il ritardo CH B (delaylegnth); digitalWrite (9, LOW); // ENABLE CH A digitalWrite (8, HIGH); // DISABLE CH B digitalWrite (12, LOW); // Imposta la direzione di CH A analogWrite (3, 255); // Sposta il ritardo CH A (delaylegnth); digitalWrite (9, HIGH); // DISABLE CH A digitalWrite (8, LOW); // ENABLE CH B digitalWrite (13, LOW); // Imposta la direzione di CH B analogWrite (11, 255); // Sposta il ritardo CH B (delaylegnth); }