Tutorial de Arduino Motor Shield

El Arduino Motor Shield le permite controlar fácilmente la dirección y velocidad del motor utilizando un Arduino. Al permitirle abordar simplemente los pines Arduino, hace que sea muy simple incorporar un motor a su proyecto. También le permite poder alimentar un motor con una fuente de alimentación separada de hasta 12v. Lo mejor de todo, el escudo es muy fácil de encontrar. Por todas estas razones, el Arduino Motor Shield es un poco genial para tener en tu arsenal para la creación rápida de prototipos y la experimentación general.

Paso 1: instalar

Los pines del escudo oficial del motor Arduino solo se alinearán con Arduino Uno Rev.3.

Para que funcione con versiones anteriores del Arduino, deberá recortar algunos pines del protector del motor. Sin embargo, esto no es, en absoluto, recomendable.

Inserte los pasadores de protección del motor en el zócalo del Arduino Uno.

Paso 2: Características del escudo

El escudo del motor tiene 2 canales, lo que permite el control de dos motores de CC o 1 motor paso a paso.

También tiene 6 encabezados para la conexión de entradas, salidas y líneas de comunicación de Tinkerkit. El uso de estos pines es algo limitado y, por lo tanto, no se trata en este tutorial.

Con una fuente de alimentación externa, la pantalla del motor puede suministrar de manera segura hasta 12 V y 2 A por canal del motor (o 4 A a un solo canal).

Hay pines en el Arduino que el escudo siempre usa. Al direccionar estos pines, puede seleccionar un canal de motor para iniciar, especificar la dirección del motor (polaridad), establecer la velocidad del motor (PWM), detener y arrancar el motor, y controlar la absorción de corriente de cada canal.

El desglose del pin es el siguiente:

FunciónCanal ACanal b
DirecciónDigital 12Digital 13
Velocidad (PWM)Digital 3Digital 11
FrenoDigital 9Digital 8
Detección de corriente0 análogo1 análogo

Para obtener más información sobre las especificaciones técnicas, consulte la página oficial del escudo del motor en el sitio de Arduino.

Paso 3: programa

Conecte el Arduino al puerto USB de su computadora y abra el entorno de desarrollo Arduino.

Para que la placa haga algo, debe inicializar el canal del motor alternando tres parámetros:

  1. Primero debe establecer la dirección del motor (polaridad de la fuente de alimentación) configurándola en ALTA o BAJA.
  2. Luego, debe desactivar el pasador de freno del canal del motor ajustándolo a BAJO.
  3. Finalmente, para que el motor comience a moverse, debe establecer la velocidad enviando un comando PWM (analogWrite) al pin apropiado.

Si no hace las tres cosas, el motor no se encenderá.

En los siguientes pasos hay algunos ejemplos comunes de configuraciones comunes de motores.

Paso 4: un motor

Para controlar un motor usando el Arduino Motor Shield, primero enchufe el cable positivo (rojo) del motor en el terminal del Canal A + en el escudo del motor, y el cable de tierra (negro) del motor en el terminal del Canal A - en el escudo.

No siempre es necesaria una fuente de alimentación externa, pero mejora drásticamente el rendimiento del motor. Se recomienda que siempre use uno.

Para conectar su fuente de alimentación externa, conecte el cable positivo (rojo) de la fuente de alimentación al terminal "Vin", y el cable de tierra (negro) al terminal "GND".

Finalmente, suba el código para controlar el Motor Shield al Arduino.

Aquí está el código para controlar un motor:
 / ************************************************* ************ Motor Shield 1-Channel DC Motor Demo por Randy Sarafan Para más información ver: //www.instructables.com/id/Arduino-Motor-Shield-Tutorial/ **** ************************************************** ******* / void setup () {// Setup Channel A pinMode (12, OUTPUT); // Inicia el canal del motor A pin pinMode (9, OUTPUT); // Inicia el pin del canal de freno A} void loop () {// forward @ full speed digitalWrite (12, HIGH); // Establece la dirección hacia adelante del canal A digitalWrite (9, LOW); // Desactivar el freno para el canal A analogWrite (3, 255); // Hace girar el motor en el canal A con retraso de velocidad máxima (3000); digitalWrite (9, ALTO); // Activar el freno para el retraso del canal A (1000); // hacia atrás @ media velocidad digitalWrite (12, LOW); // Establece la dirección hacia atrás del canal A digitalWrite (9, LOW); // Desactivar el freno para el canal A analogWrite (3, 123); // Hace girar el motor en el canal A con retraso de media velocidad (3000); digitalWrite (9, ALTO); // Activar el freno para el retraso del canal A (1000); } 

Paso 5: dos motores

La interfaz con dos motores es casi lo mismo que la interfaz con un motor. Simplemente conecte el motor al canal B.

La única diferencia en cuanto al código es que necesita activar un segundo canal para controlar el segundo motor.

Aquí hay un código para controlar dos motores:
 / ************************************************* ************ Motor Shield 2-Channel DC Motor Demo por Randy Sarafan Para obtener más información, visite: //www.instructables.com/id/Arduino-Motor-Shield-Tutorial/ **** ************************************************** ******* / void setup () {// Setup Channel A pinMode (12, OUTPUT); // Inicia el canal del motor A pin pinMode (9, OUTPUT); // Inicia el pin del canal de freno A // Configura el pin del modo del canal B (13, OUTPUT); // Inicia el canal del motor A pin pinMode (8, OUTPUT); // Inicia el pin del canal de freno A} void loop () {// Motor A adelante @ velocidad digital digitalWrite (12, HIGH); // Establece la dirección hacia adelante del canal A digitalWrite (9, LOW); // Desactivar el freno para el canal A analogWrite (3, 255); // Hace girar el motor en el canal A a toda velocidad // Motor B hacia atrás a media velocidad digitalWrite (13, LOW); // Establece la dirección hacia atrás del canal B digitalWrite (8, LOW); // Desactivar el freno para el canal B analogWrite (11, 123); // Hace girar el motor en el canal B con retraso de media velocidad (3000); digitalWrite (9, ALTO); // Activa el freno para el canal A digitalWrite (9, HIGH); // Activar el freno para el retraso del canal B (1000); // Motor A adelante @ velocidad total digitalWrite (12, BAJO); // Establece la dirección hacia atrás del canal A digitalWrite (9, LOW); // Desactivar el freno para el canal A analogWrite (3, 123); // Hace girar el motor en el canal A a la mitad de la velocidad // Motor B hacia adelante @ velocidad digital digitalWrite (13, HIGH); // Establece la dirección hacia adelante del canal B digitalWrite (8, LOW); // Desactivar el freno para el canal B analogWrite (11, 255); // Hace girar el motor en el canal B a velocidad máxima (3000); digitalWrite (9, ALTO); // Activa el freno para el canal A digitalWrite (9, HIGH); // Activar el freno para el retraso del canal B (1000); } 

Paso 6: motor paso a paso

Hay varios tipos diferentes de motores paso a paso, pero en este tutorial abordaremos específicamente los motores paso a paso bipolares. Los motores paso a paso bipolares suelen tener 4 pines, que corresponden a dos bobinas. Para usar un paso a paso, debe alimentar estas dos bobinas en fase con polaridad alterna.

Para determinar qué dos pines forman una sola bobina, inserte un LED en cualquiera de los dos pines de su zócalo y gire el eje del motor. Si el LED se ilumina, encontraste una bobina. Los otros dos pines deben formar la otra bobina.

Para hacer girar un motor bipolar:

  1. Encienda la primera bobina.
  2. Luego alimente la segunda bobina con polaridad inversa.
  3. Luego alimente la primera bobina con polaridad inversa.
  4. Finalmente, alimente la segunda bobina.

Para invertir la dirección del motor de un paso a paso bipolar, simplemente invierta la polaridad de la segunda bobina.

Aquí hay un código para hacer que el paso a paso gire en una dirección:
 / ************************************************* ************ Motor Shield Stepper Demo por Randy Sarafan Para más información ver: //www.instructables.com/id/Arduino-Motor-Shield-Tutorial/ ******** ************************************************** *** / int delaylegnth = 30; void setup () {// establece los pines de palanca de dirección del motor pinMode (12, OUTPUT); // CH A - ALTO = hacia delante y BAJO = hacia atrás ??? pinMode (13, SALIDA); // CH B - HIGH = hacia adelante y LOW = hacia atrás ??? // establece los pines del freno del motor pinMode (9, OUTPUT); // freno (deshabilitar) CH A pinMode (8, OUTPUT); // freno (deshabilitar) CH B} void loop () {digitalWrite (9, LOW); // ENABLE CH A digitalWrite (8, HIGH); // DESACTIVAR CH B digitalWrite (12, ALTO); // Establece la dirección de CH A analogWrite (3, 255); // Mueve CH A delay (delaylegnth); digitalWrite (9, ALTO); // DESACTIVAR CH A digitalWrite (8, LOW); // HABILITAR CH B digitalWrite (13, BAJO); // Establece la dirección de CH B analogWrite (11, 255); // Mueve CH B delay (delaylegnth); digitalWrite (9, BAJO); // ENABLE CH A digitalWrite (8, HIGH); // DESACTIVAR CH B digitalWrite (12, BAJO); // Establece la dirección de CH A analogWrite (3, 255); // Mueve CH A delay (delaylegnth); digitalWrite (9, ALTO); // DESACTIVAR CH A digitalWrite (8, LOW); // ENABLE CH B digitalWrite (13, ALTO); // Establece la dirección de CH B analogWrite (11, 255); // Mueve CH B delay (delaylegnth); } 

Aquí hay un código para hacer que el paso a paso gire en la dirección opuesta:
 / ************************************************* ************ Motor Shield Stepper Demo por Randy Sarafan Para más información ver: //www.instructables.com/id/Arduino-Motor-Shield-Tutorial/ ******** ************************************************** *** / int delaylegnth = 30; void setup () {// establece los pines de palanca de dirección del motor pinMode (12, OUTPUT); // CH A - ALTO = hacia delante y BAJO = hacia atrás ??? pinMode (13, SALIDA); // CH B - HIGH = hacia adelante y LOW = hacia atrás ??? // establece los pines del freno del motor pinMode (9, OUTPUT); // freno (deshabilitar) CH A pinMode (8, OUTPUT); // freno (deshabilitar) CH B} void loop () {digitalWrite (9, LOW); // ENABLE CH A digitalWrite (8, HIGH); // DESACTIVAR CH B digitalWrite (12, ALTO); // Establece la dirección de CH A analogWrite (3, 255); // Mueve CH A delay (delaylegnth); digitalWrite (9, ALTO); // DESACTIVAR CH A digitalWrite (8, LOW); // ENABLE CH B digitalWrite (13, ALTO); // Establece la dirección de CH B analogWrite (11, 255); // Mueve CH B delay (delaylegnth); digitalWrite (9, BAJO); // ENABLE CH A digitalWrite (8, HIGH); // DESACTIVAR CH B digitalWrite (12, BAJO); // Establece la dirección de CH A analogWrite (3, 255); // Mueve CH A delay (delaylegnth); digitalWrite (9, ALTO); // DESACTIVAR CH A digitalWrite (8, LOW); // HABILITAR CH B digitalWrite (13, BAJO); // Establece la dirección de CH B analogWrite (11, 255); // Mueve CH B delay (delaylegnth); } 

Artículos Relacionados