Referencia de la clase MotorPaso

Controlador para motores paso a paso 28BYJ-48 con driver ULN2003. Más...

#include <motorStep.h>

Métodos públicos
	MotorPaso (uint8_t pinA, uint8_t pinB, uint8_t pinC, uint8_t pinD)
	Constructor del motor paso a paso.
void	fijarVelocidad (float rpm)
	Establece la velocidad del motor en RPM.
void	pasoAdelante ()
	Avanza un paso en la secuencia del motor.
void	pasoAtras ()
	Retrocede un paso en la secuencia del motor.
void	aplicarPaso (int indicePaso)
	Aplica un paso específico de la secuencia (0–7).
void	movimientoContinuo ()
	Ejecuta movimiento continuo según la velocidad configurada.
void	movimientoPosicionRelativo (float grados, bool debugMSG=false)
	Mueve el motor hacia un ángulo relativo usando el camino más corto.
float	diferenciaCircular (float gradosActuales, float gradosObjetivo)
	Calcula la diferencia circular entre dos ángulos.
float	normalizarGrados (float grados)
	Normaliza un ángulo al rango 0–360 grados.
int	convertirGradosAPasos (float grados)
	Convierte grados a pasos del motor.
float	convertirPasosAGrados (int pasos)
	Convierte pasos del motor a grados.
float	movimientoDePosicionGradosCorriendo (int movimientoPasos)
	Actualiza y devuelve los grados recorridos durante el movimiento.
void	debugMovimientoRelativo (int pasoActualDelBucle)
	Imprime información detallada del movimiento relativo.

Atributos privados
uint8_t	pinA
	Bobina A.
uint8_t	pinB
	Bobina B.
uint8_t	pinC
	Bobina C.
uint8_t	pinD
	Bobina D.
unsigned long	retardoPaso
	Microsegundos entre pasos (determina la velocidad).
unsigned long	tiempoUltimoPaso
	Marca temporal del último paso ejecutado.
short	rpm
	Velocidad configurada en RPM.
int	pasoActual
	Índice de la secuencia (0–7).
int	pasosPorVuelta = PASOS_POR_VUELTA
	Pasos necesarios para 360°
int	pasos
	Pasos totales a ejecutar en el movimiento actual.
float	gradoActual
	Ángulo actual del motor (0–360 normalizado).
float	gradosObjetivo
	Ángulo objetivo solicitado.
float	gradosCorriendo
	Ángulo recorrido durante el movimiento (progreso).
float	diferencia
	Diferencia circular entre gradoActual y gradosObjetivo (–180 a +180).
bool	direccionAdelante
	Dirección: true = adelante.
bool	direccionAtras
	Dirección: true = atrás.

Descripción detallada

Controlador para motores paso a paso 28BYJ-48 con driver ULN2003.

Esta clase permite:

• Controlar pasos individuales (adelante/atrás)
• Establecer velocidad en RPM
• Realizar movimientos relativos en grados
• Obtener información del progreso del movimiento
• Depurar el comportamiento mediante mensajes por consola

La clase está organizada por familias funcionales para facilitar la lectura, mantenimiento y generación de documentación.

Definición en la línea 22 del archivo motorStep.h.

Documentación de constructores y destructores

MotorPaso()

MotorPaso::MotorPaso	(	uint8_t	pinA,
		uint8_t	pinB,
		uint8_t	pinC,
		uint8_t	pinD )

Constructor del motor paso a paso.

Inicializa el motor paso a paso configurando los pines y el estado inicial.

Parámetros

pinA	Pin conectado a la bobina A.
pinB	Pin conectado a la bobina B.
pinC	Pin conectado a la bobina C.
pinD	Pin conectado a la bobina D.

Definición en la línea 12 del archivo motorStep.cpp.

    : pinA(pinA), pinB(pinB), pinC(pinC), pinD(pinD),
      retardoPaso(2000), tiempoUltimoPaso(0), pasoActual(0),
      gradoActual(0), gradosObjetivo(0), gradosCorriendo(0),
      direccionAdelante(false), direccionAtras(false)
{
    pinMode(pinA, OUTPUT);
    pinMode(pinB, OUTPUT);
    pinMode(pinC, OUTPUT);
    pinMode(pinD, OUTPUT);
}

Documentación de funciones miembro

aplicarPaso()

void MotorPaso::aplicarPaso

(

int

indicePaso

)

Aplica un paso específico de la secuencia (0–7).

Activa las bobinas según el índice de paso (0–7).

Parámetros

indicePaso

Índice de la secuencia.

Definición en la línea 69 del archivo motorStep.cpp.

                                 {
    switch (i) {
        case 0: digitalWrite(pinA, HIGH); digitalWrite(pinB, LOW);  digitalWrite(pinC, LOW);  digitalWrite(pinD, LOW);  break;
        case 1: digitalWrite(pinA, HIGH); digitalWrite(pinB, HIGH); digitalWrite(pinC, LOW);  digitalWrite(pinD, LOW);  break;
        case 2: digitalWrite(pinA, LOW);  digitalWrite(pinB, HIGH); digitalWrite(pinC, LOW);  digitalWrite(pinD, LOW);  break;
        case 3: digitalWrite(pinA, LOW);  digitalWrite(pinB, HIGH); digitalWrite(pinC, HIGH); digitalWrite(pinD, LOW);  break;
        case 4: digitalWrite(pinA, LOW);  digitalWrite(pinB, LOW);  digitalWrite(pinC, HIGH); digitalWrite(pinD, LOW);  break;
        case 5: digitalWrite(pinA, LOW);  digitalWrite(pinB, LOW);  digitalWrite(pinC, HIGH); digitalWrite(pinD, HIGH); break;
        case 6: digitalWrite(pinA, LOW);  digitalWrite(pinB, LOW);  digitalWrite(pinC, LOW);  digitalWrite(pinD, HIGH); break;
        case 7: digitalWrite(pinA, HIGH); digitalWrite(pinB, LOW);  digitalWrite(pinC, LOW);  digitalWrite(pinD, HIGH); break;
    }
}

Gráfico de llamadas a esta función:

convertirGradosAPasos()

int MotorPaso::convertirGradosAPasos

(

float

grados

)

Convierte grados a pasos del motor.

Parámetros

grados

Ángulo en grados.

Devuelve

Número de pasos equivalentes.

Definición en la línea 159 del archivo motorStep.cpp.

                                                 {
    return (int)(abs(grados) * this->pasosPorVuelta / 360.0f);
}

Gráfico de llamadas a esta función:

convertirPasosAGrados()

float MotorPaso::convertirPasosAGrados

(

int

pasos

)

Convierte pasos del motor a grados.

Parámetros

pasos

Número de pasos.

Devuelve

Ángulo equivalente en grados.

Definición en la línea 166 del archivo motorStep.cpp.

                                                {
    return (float)pasos * 360.0f / this->pasosPorVuelta;
}

Gráfico de llamadas a esta función:

debugMovimientoRelativo()

void MotorPaso::debugMovimientoRelativo

(

int

pasoActualDelBucle

)

Imprime información detallada del movimiento relativo.

Parámetros

pasoActualDelBucle

Paso actual dentro del bucle de movimiento.

Definición en la línea 199 del archivo motorStep.cpp.

                                                              {
 
    Serial.println("====================================");
    Serial.print("Paso actual: ");
    Serial.print(pasoActualDelBucle);
    Serial.print(" / ");
    Serial.println(this->pasos);
 
    Serial.print("Diferencia circular: ");
    Serial.print(this->diferencia);
    Serial.println(" grados");
 
    Serial.print("Pasos totales calculados: ");
    Serial.println(this->pasos);
 
    Serial.print("Dirección: ");
    if (this->direccionAdelante) Serial.println("Adelante (+)");
    else if (this->direccionAtras) Serial.println("Atrás (–)");
    else Serial.println("Sin movimiento");
 
    Serial.print("Grados recorridos hasta ahora: ");
    Serial.print(this->gradosCorriendo);
    Serial.println(" grados");
 
    Serial.print("Grado actual (antes de normalizar): ");
    Serial.println(this->gradoActual);
 
    Serial.println("====================================");
}

Gráfico de llamadas a esta función:

diferenciaCircular()

float MotorPaso::diferenciaCircular	(	float	gradosActuales,
		float	gradosObjetivo )

Calcula la diferencia circular entre dos ángulos.

Parámetros

gradosActuales	Ángulo actual.
gradosObjetivo	Ángulo objetivo.

Devuelve

Diferencia circular entre -180 y +180 grados.

Definición en la línea 173 del archivo motorStep.cpp.

                                                                {
    float diff = objetivo - actual;
 
    if (diff > 180.0f)  diff -= 360.0f;
    if (diff < -180.0f) diff += 360.0f;
 
    return diff;
}

Gráfico de llamadas a esta función:

fijarVelocidad()

void MotorPaso::fijarVelocidad

(

float

rpm

)

Establece la velocidad del motor en RPM.

Establece la velocidad del motor en RPM calculando el retardo entre pasos.

Parámetros

rpm	Revoluciones por minuto.

Definición en la línea 33 del archivo motorStep.cpp.

                                        {
    this->retardoPaso = (60.0 * 1000000.0) / (rpm * this->pasosPorVuelta);
    this->rpm = rpm;
}

Gráfico de llamadas a esta función:

movimientoContinuo()

void MotorPaso::movimientoContinuo

(

)

Ejecuta movimiento continuo según la velocidad configurada.

Definición en la línea 91 del archivo motorStep.cpp.

                                   {
    unsigned long ahora = micros();
 
    if (ahora - this->tiempoUltimoPaso >= this->retardoPaso) {
        this->tiempoUltimoPaso = ahora;
        this->pasoAdelante();
    }
}

Gráfico de llamadas de esta función:

movimientoDePosicionGradosCorriendo()

float MotorPaso::movimientoDePosicionGradosCorriendo

(

int

movimientoPasos

)

Actualiza y devuelve los grados recorridos durante el movimiento.

Parámetros

movimientoPasos

Pasos ejecutados hasta el momento.

Devuelve

Grados recorridos.

Definición en la línea 145 del archivo motorStep.cpp.

                                                                        {
    this->gradosCorriendo = convertirPasosAGrados(movimientoPasos);
    return this->gradosCorriendo;
}

Gráfico de llamadas de esta función:

Gráfico de llamadas a esta función:

movimientoPosicionRelativo()

void MotorPaso::movimientoPosicionRelativo	(	float	grados,
		bool	debugMSG = false )

Mueve el motor hacia un ángulo relativo usando el camino más corto.

Parámetros

grados	Ángulo objetivo en grados.
debugMSG	Si es true, imprime información detallada del movimiento.

Definición en la línea 109 del archivo motorStep.cpp.

                                                                      {
 
    this->diferencia = this->diferenciaCircular(this->gradoActual, grados);
    this->pasos = convertirGradosAPasos(abs(this->diferencia));
 
    this->direccionAdelante = (this->diferencia > 0);
    this->direccionAtras    = (this->diferencia < 0);
 
    if (this->direccionAtras) {
        for (int i = 0; i < this->pasos; i++) {
            this->pasoAtras();
            movimientoDePosicionGradosCorriendo(i);
            if (debugMSG) debugMovimientoRelativo(i);
        }
    }
 
    if (this->direccionAdelante) {
        for (int i = 0; i < this->pasos; i++) {
            this->pasoAdelante();
            movimientoDePosicionGradosCorriendo(i);
            if (debugMSG) debugMovimientoRelativo(i);
        }
    }
 
    this->gradoActual = normalizarGrados(grados);
}

Gráfico de llamadas de esta función:

Gráfico de llamadas a esta función:

normalizarGrados()

float MotorPaso::normalizarGrados

(

float

grados

)

Normaliza un ángulo al rango 0–360 grados.

Parámetros

grados

Ángulo a normalizar.

Devuelve

Ángulo normalizado.

Definición en la línea 185 del archivo motorStep.cpp.

                                              {
    float g = fmod(grados, 360.0f);
    return (g < 0) ? g + 360.0f : g;
}

Gráfico de llamadas a esta función:

pasoAdelante()

void MotorPaso::pasoAdelante

(

)

Avanza un paso en la secuencia del motor.

Definición en la línea 47 del archivo motorStep.cpp.

                             {
    this->pasoActual++;
    if (this->pasoActual > 7) this->pasoActual = 0;
 
    this->aplicarPaso(this->pasoActual);
    delayMicroseconds(this->retardoPaso);
}

Gráfico de llamadas de esta función:

Gráfico de llamadas a esta función:

pasoAtras()

void MotorPaso::pasoAtras

(

)

Retrocede un paso en la secuencia del motor.

Definición en la línea 58 del archivo motorStep.cpp.

                          {
    this->pasoActual--;
    if (this->pasoActual < 0) this->pasoActual = 7;
 
    this->aplicarPaso(this->pasoActual);
    delayMicroseconds(this->retardoPaso);
}

Gráfico de llamadas de esta función:

Gráfico de llamadas a esta función:

Documentación de datos miembro

diferencia

float MotorPaso::diferencia

private

Diferencia circular entre gradoActual y gradosObjetivo (–180 a +180).

Definición en la línea 176 del archivo motorStep.h.

direccionAdelante

bool MotorPaso::direccionAdelante

private

Dirección: true = adelante.

Definición en la línea 177 del archivo motorStep.h.

direccionAtras

bool MotorPaso::direccionAtras

private

Dirección: true = atrás.

Definición en la línea 178 del archivo motorStep.h.

gradoActual

float MotorPaso::gradoActual

private

Ángulo actual del motor (0–360 normalizado).

Definición en la línea 173 del archivo motorStep.h.

gradosCorriendo

float MotorPaso::gradosCorriendo

private

Ángulo recorrido durante el movimiento (progreso).

Definición en la línea 175 del archivo motorStep.h.

gradosObjetivo

float MotorPaso::gradosObjetivo

private

Ángulo objetivo solicitado.

Definición en la línea 174 del archivo motorStep.h.

pasoActual

int MotorPaso::pasoActual

private

Índice de la secuencia (0–7).

Definición en la línea 165 del archivo motorStep.h.

pasos

int MotorPaso::pasos

private

Pasos totales a ejecutar en el movimiento actual.

Definición en la línea 172 del archivo motorStep.h.

pasosPorVuelta

int MotorPaso::pasosPorVuelta = PASOS_POR_VUELTA

private

Pasos necesarios para 360°

Definición en la línea 166 del archivo motorStep.h.

pinA

uint8_t MotorPaso::pinA

private

Bobina A.

Definición en la línea 148 del archivo motorStep.h.

pinB

uint8_t MotorPaso::pinB

private

Bobina B.

Definición en la línea 149 del archivo motorStep.h.

pinC

uint8_t MotorPaso::pinC

private

Bobina C.

Definición en la línea 150 del archivo motorStep.h.

pinD

uint8_t MotorPaso::pinD

private

Bobina D.

Definición en la línea 151 del archivo motorStep.h.

retardoPaso

unsigned long MotorPaso::retardoPaso

private

Microsegundos entre pasos (determina la velocidad).

Definición en la línea 157 del archivo motorStep.h.

rpm

short MotorPaso::rpm

private

Velocidad configurada en RPM.

Definición en la línea 159 del archivo motorStep.h.

tiempoUltimoPaso

unsigned long MotorPaso::tiempoUltimoPaso

private

Marca temporal del último paso ejecutado.

Definición en la línea 158 del archivo motorStep.h.

---

La documentación de esta clase está generada de los siguientes archivos:

• motorStep.h
• motorStep.cpp