Motor paso a paso Nema 17

Con este motor paso a paso se puede controlar de forma muy precisa el giro de su eje para hacer movimientos de precisión y así controlar el movimiento de tu máquina o robot.

Características técnicas del Nema 17

El motor paso a paso Nema 17 es de tipo bipolar, con un ángulo de paso de 1,8º, es decir, puede dividir cada una de las revoluciones o vueltas en 200 pasos. Cada bobinado de los que tiene en su interior soporta 1.2A de intensidad a 4v de tensión, con lo que es capaz de desarrollar una fuerza considerable de 3.2 kg/cm.

Además, este motor Nema 17 es robusto, por eso se emplea en aplicaciones como las impresoras 3D caseras y otros robot que necesitan tener una consistencia considerable. También es usado en cortadoras láser, máquinas de CNC, etc.

Las características técnicas son:

• • Peso 350 gramos
  • Tamaño 42.3x48mm sin eje
  • Diámetro del eje 5mm D
  • Longitud del eje 25 mm
  • 200 pasos por vuelta (1,8º/paso)
  • Corriente 1.2A por bobinado
  • Tensión de alimentación 4v
  • Resistencia 3.3 Ohm por bobina
  • Torque motor de 3.2 kg/cm
  • Inductancia 2.8 mH por bobina

PinOut

El pinout de estos motores paso a paso es bastante sencillo, ya que no tienen demasiados cables para la conexión, además traen un conector para que los puedas hacer de forma más sencilla. En el caso del NEMA 17 encontrarás un pinout como el que puedes ver en la imagen superior.

Pero si necesitas conocer más detalles técnicos y eléctricos de los límites y rangos en los que puede trabajar el NEMA 17, puedes buscar un datasheet de este motor paso a paso y así obtener toda la información complementaria que buscas.

 

Ejemplo de cómo comenzar con el Nema 17 y Arduino

Un ejemplo sencillo para comenzar a usar este motor paso a paso NEMA 17 con Arduino es este simple esquema que puedes montar. Yo he empleado un driver para motores DRV8825, pero puedes usar alguno diferente e incluso también un motor paso a paso diferente si quieres variar el proyecto y adaptarlo a tus necesidades.

En el caso del driver empleado funciona como máximo a 45v y 2A de intensidad, por lo que es ideal para motores paso a paso o steppers de talla pequeña y mediana como es el caso del NEMA 17 bipolar. Pero si necesitas algo más «pesado», un  motor más grande como el NEMA 23, entonces puedes usar el driver TB6600.

Recuerda que puedes usar también la biblioteca AccelStepper para un mejor manejo. Una biblioteca escrita por Mike McCauley que resulta muy práctica para tus proyectos, con soporte para aceleración y desaceleración, toda una ventaja para multitud de funciones.

Las conexiones resumidas son las siguientes:

• El motor NEMA 17 tiene su conexiones GND y VMOT al suministro eléctrico. La fuente debe tener entre 8v y 45v de suministro, y el condensador agregado podrá ser de 100µF.
• Las dos bobinas del stepper está conectado a A1, A2, y B1, B2 respectivamente.
• El pin GND del diver está conectado a GND de Arduino.
• El pin VDD del driver está conectado a 5v de Arduino.
• STP y DIR para el paso y dirección están conectados a los pines digitales 3 y 2 respectivamente. Si quieres elegir otros pines de Arduino puedes, solo tienes que modificar el código en consonancia.
• RST y SLP para reset y sleep del driver los debes conectar a 5v de la placa Arduino.
• EN o pin de activación puede estar desconectado, ya que de ese modo el driver estará activo. Si se pone a HIGH en vez de LOW el driver está desactivo.
• Otros pines estarán desconectados…

En cuanto al código del sketch, puede ser tan simple como este para hacer funcionar el NEMA 17 y dar los primeros pasos.

#define dirPin 2
#define stepPin 3
#define stepsPerRevolution 200
void setup() {
  // Declare pins as output:
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
}
void loop() {
  // Set the spinning direction clockwise:
  digitalWrite(dirPin, HIGH);
  // Spin the stepper motor 1 revolution slowly:
  for (int i = 0; i < stepsPerRevolution; i++) {
    // These four lines result in 1 step:
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(2000);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(2000);
  }
  delay(1000);
  // Set the spinning direction counterclockwise:
  digitalWrite(dirPin, LOW);
  // Spin the stepper motor 1 revolution quickly:
  for (int i = 0; i < stepsPerRevolution; i++) {
    // These four lines result in 1 step:
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(1000);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(1000);
  }
  delay(1000);
  // Set the spinning direction clockwise:
  digitalWrite(dirPin, HIGH);
  // Spin the stepper motor 5 revolutions fast:
  for (int i = 0; i < 5 * stepsPerRevolution; i++) {
    // These four lines result in 1 step:
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(500);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(500);
  }
  delay(1000);
  // Set the spinning direction counterclockwise:
  digitalWrite(dirPin, LOW);
  //Spin the stepper motor 5 revolutions fast:
  for (int i = 0; i < 5 * stepsPerRevolution; i++) {
    // These four lines result in 1 step:
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(500);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(500);
  }
  delay(1000);
}