LECTURA 1

CONTROL BÁSICO DE UN MOTOR PASO A PASO

28BYJ-48 CON ARDUINO Y DRIVER ULN2003

Un motor paso a paso es un dispositivo electromecánico que convierte una serie de pulsos
eléctricos en desplazamientos angulares, lo que significa que es capaz de girar una cantid ad
determinada de grados, dependiendo de sus entradas de control. Los motores paso a paso son
ideales para la construcción de mecanismos en donde se requieren movimientos muy
precisos. Poseen un estator construido por varios bobinados en un material ferromagnético y
un rotor que puede girar libremente.

Existen diferentes tipos de motores paso a paso, uno de ellos son los denominado s
unipolares, estos motores suelen tener 5 o 6 cables de salida, dependiendo de su conexionado
interno. Normalmente emplean 4 cables para recibir los pulsos que indican la secuencia y
duración de los pasos y los restantes sirven como alimentación del motor. Este tipo de
motores se caracteriza por ser simple de controlar. A continuación, se muestran las tres
secuencias más empleadas.

SECUENCIA 1-FASE
En secuencia de 1-fase se activa una sola bobina cada vez.

Paso A B A’ B’
1 ON OFF OFF OFF
2 OFF ON OFF OFF
3 OFF OFF ON OFF
4 OFF OFF OFF ON

1
 SECUENCIA 2-FASES
En la secuencia en 2-fases se activan dos bobinas correlativas en cada fase. Al hacer
trabajar dos bobinas simultáneamente en cada paso el campo magnético generado es superior
por lo que el motor tiene más par y, en general, presenta un mejor comportamiento. Como
punto negativo, el consumo energético es mayor.

Paso A B A’ B’
1 ON ON OFF OFF
2 OFF ON ON OFF
3 OFF OFF ON ON
4 ON OFF OFF ON

SECUENCIA DE MEDIO PASO

En esta, se activan una y dos bobinas alternativamente. Con esta secuencia conseguimo s
una precisión de la mitad del paso. El par desarrollado varía ya que en algunos pasos
activamos dos bobinas y en otras solo una, pero a la vez el giro se encuentra más “guiado”,
por lo que en general ambos efectos se compensan y el funcionamiento es bueno, salvo en
aplicaciones donde estemos muy al límite del par máximo.

2
 Paso A B A’ B’
1 ON OFF OFF OFF
2 ON ON OFF OFF
3 OFF ON OFF OFF
4 OFF ON ON OFF
5 OFF OFF ON OFF
6 OFF OFF ON ON
7 OFF OFF OFF ON
8 ON OFF OFF ON

El motor paso a paso 28BYJ-48 es un motor unipolar ampliamente utilizado en

aplicaciones industriales, como el control de válvulas hidráulicas y neumáticas. En el campo
de los hobbies, podemos usar el 28BYJ-48 para hacer pequeños robots articulados. Es un
pequeño motor de bajo precio, sus características eléctricas son modestas, pero incorpora un
reductor integrado que lo convierte en un componente útil e interesante. Posee un paso de
5.625 grados (64 pasos por vuelta). El reductor interno tiene una relación de 1/64,
combinados, la precisión total es de 4076 pasos por vuelta.

La alimentación del motor es 5V o 12V según el modelo, siendo más habitual el modelo
de 5V. Físicamente ambos modelos son idénticos, por lo que para saber la tensión nomina l

3
deberemos mirar la etiqueta del motor. El 28BYJ-48 tiene un par máximo tras el reductor de
3N•cm (0.3Kgf•cm). La frecuencia máxima de operación es de 100Hz, lo que supone unos
40 segundos por vuelta, o equivalentemente una velocidad de giro máxima en torno a 1.5
rpm. La resistencia y el consumo eléctrico varían con el modelo de 28BYJ-48. En los
modelos de 5V es de 60 Ohm, lo que supone un consumo de 83mA. Los modelos de 12V
tienen resistencias de 130-380 Ohm, y consumos de 71 a 32mA.

Para su control se puede emplear una placa con integrado ULN2003. Este integrado es
una agrupación de 7 pares Darlington, de los cuales se usan 4, uno por cada fase del motor.
Este controlador permite suministrar la corriente requerida por el motor para su
funcionamiento, misma que resulta superior a la que proporcionan las salidas de la tarjeta del
microcontrolador.

CÓDIGO DE EJEMPLO CON UNA SECUENCIA DE

MEDIO PASO.

//definicion de pines
const int motorPin1 = 2; // 28BYJ48 In1
const int motorPin2 = 3; // 28BYJ48 In2
const int motorPin3 = 4; // 28BYJ48 In3
const int motorPin4 = 5; // 28BYJ48 In4

//definicion variables
int motorSpeed = 1200; //variable para fijar la velocidad
int stepCounter = 0; // contador para los pasos
int stepsPerRev = 4076; // pasos para una vuelta completa
const int numSteps = 8;
const int stepsLookup[8] = { B1000, B1100, B0100, B0110, B0010, B0011, B0001, B1001 };

//-------------------------------------------------------------------------------------

4
void setup()
{
//declarar pines como salida
pinMode(motorPin1, OUTPUT);
pinMode(motorPin2, OUTPUT);
pinMode(motorPin3, OUTPUT);
pinMode(motorPin4, OUTPUT);
Serial.begin(9600);
}
//-------------------------------------------------------------------------------------
void loop()
{
for (int i = 0; i < stepsPerRev; i++)
{
clockwise();
delayMicroseconds(motorSpeed);
}
for (int i = 0; i < stepsPerRev; i++)
{
anticlockwise();
delayMicroseconds(motorSpeed);
}
}

//------------------------------------------------------------------------------------
void clockwise()
{
stepCounter++;
if (stepCounter >= numSteps) stepCounter = 0;
setOutput(stepCounter);
}
//-----------------------------------------------------------------------------------
void anticlockwise()
{
stepCounter--;
if (stepCounter < 0) stepCounter = numSteps - 1;
setOutput(stepCounter);
}
//-----------------------------------------------------------------------------------
void setOutput(int step)
{
digitalWrite(motorPin1, bitRead(stepsLookup[step], 0));
digitalWrite(motorPin2, bitRead(stepsLookup[step], 1));
digitalWrite(motorPin3, bitRead(stepsLookup[step], 2));
digitalWrite(motorPin4, bitRead(stepsLookup[step], 3));
}
//------------------------------------------------------------------------------------