Presentar el shield RAMPS 1.4

Aprender a montarla correctamente.

Manejar motores paso a paso y finales de carrera.

 

 

	Arduino Mega
	RAMPS Board
	Drivers A4988
	Dos finales de Carrera

 

 

 

El nombre RAMPS viene dado por sus siglas Raprap Arduino Mega Pololu Shield. Son unos shields para Arduino MEGA diseñadas para controlar motores paso a paso, generalmente NEMA,utilizando drivers POLOLU A4988 o DVR8825.

Son ampliamente utilizadas para controlar impresoras 3d, ya que además de los motores paso a paso, podemos gestionar todos los periféricos que suelen componer las impresoras: ventiladores, finales de carrera, tomas de alimentación, pantalla LCD, hotends… Pero de momento no vamos a entrar en eso, y de momento vamos a centrarnos en el control de motores paso a paso.

Con ella podemos controlar hasta 6 motores paso a paso, 5 de ellos de forma independiente (en el eje Z hay 2 para un solo Pololu), junto a 6 finales de carrera.

Si no sabéis lo que son motores paso a paso, echad un ojo aquí, aquí o aquí.

Los finales de carrera son unos interruptores, que nos sirven para posicionar los motores paso a paso en el origen.

 

 

En este caso vamos a usar dos motores NEMA 17 y dos finales de carrera, pero es muy sencillo escalarlo si queréis utilizar más. Los Nema 17 tienen 200 pasos por vuelta en principio. Esto quiere decir que con cada paso obtenemos un movimiento de 1,8º por paso.

Pero podemos usar los jumpers que vienen con la RAMPS para trabajar con micropasos, en cuyo caso podemos llegar a conseguir una relación de 1/16 pasos por vuelta en el caso de los drivers A4988, es decir, podemos llegar a los 3200 pasos por vuelta.  Y en el caso de los DRV8225 podríamos llegar a 1/32, es decir 6400 pasos por vuelta.

Nosotros vamos a colocar los 3 jumpers para conseguir los 3200 pasos usando los drivers A4988:

Cuando hayamos puesto los jumpers (o no, lo que hayáis decidido), podemos colocar los Pololu encima. Encajan perfectamente encima de los jumpers, y hay que colocarlos en las zonas marcadas: X, Y ,Z , E0 y E1. Eso sí, atención, hay que colocarlos como en la imagen. Si lo hacemos al revés vamos a quemar los drivers y la RAMPS.

¡¡¡¡¡¡AVISO!!!!!! Volved a mirad los pololus antes de colocarlos. Están marcados los pines, en la ramps, fijaros que coincidan con los del Pololu.

O ponedlos como en la imagen, con el potenciómetro hacia el lado contrario que la toma para la fuente de alimentación.

Y ahora podemos colocar los motores paso a paso que se conectan directamente encima de donde hemos colocado los Pololu. No os preocupéis  del sentido de los cables, ponedlos los dos iguales para que giren igual y listo. Si luego preferís que sea al revés, no tenéis más que darles la vuelta.

Los finales de carrera se colocan en los pines que hay arriba a la derecha, marcados por «END STOPS». Hay dos para cada eje, aunque podéis usarlos como queráis. Podéis enchufarlos directamente a S, + y -. Vamos a poner dos, uno en el primero y uno en el tercero, que son los que se usan normalmente para el eje X e Y en las impresoras, que son los que estamos usando.

 

 

En este primer programa vamos a mover los motores paso a paso sin tener en cuenta los finales de carrera. Lo primero que vamos a hacer es las definiciones de los pines que utiliza la Ramps para mover los motores y controlar los finales de carrera.

Si nos fijamos, cada eje tiene un pin para habilitarlo, uno para la dirección y otro para dar un paso. Demás tiene dos pines para los finales de carrera.

#define X_STEP_PIN 54
#define X_DIR_PIN 55
#define X_ENABLE_PIN 38
#define X_MIN_PIN 3
#define X_MAX_PIN 2

#define Y_STEP_PIN 60
#define Y_DIR_PIN 61
#define Y_ENABLE_PIN 56
#define Y_MIN_PIN 14
#define Y_MAX_PIN 15

#define Z_STEP_PIN 46
#define Z_DIR_PIN 48
#define Z_ENABLE_PIN 62
#define Z_MIN_PIN 18
#define Z_MAX_PIN 19

#define E_STEP_PIN 26
#define E_DIR_PIN 28
#define E_ENABLE_PIN 24

#define Q_STEP_PIN 36
#define Q_DIR_PIN 34
#define Q_ENABLE_PIN 30

En el setup establecemos como salida los pines para controlar los motores, en este caso el motor X y el Y. Además ponemos a LOW los «ENABLE_PIN» para habilitarlos:

void setup()
{
 pinMode(X_STEP_PIN , OUTPUT);
 pinMode(X_DIR_PIN , OUTPUT);
 pinMode(X_ENABLE_PIN , OUTPUT);
 pinMode(Y_STEP_PIN , OUTPUT);
 pinMode(Y_DIR_PIN , OUTPUT);
 pinMode(Y_ENABLE_PIN , OUTPUT);
 
 digitalWrite(X_ENABLE_PIN , LOW);
 digitalWrite(Y_ENABLE_PIN , LOW);
}

Y en el loop vamos a mover los motores, que como veréis es de lo más sencillo. Simplemente fijamos la dirección y lo vamos moviendo paso a paso. En este ejemplo damos una vuelta para cada lado con cada motor, moviéndolos de forma simultánea.

Recordad que en este caso estamos usando micropasos, así que una vuelta completa tiene 3200 pasos.

Si no habéis colocado ningún jumper, tendrán 200 pasos por vuelta. 

void loop ()
{
 digitalWrite(X_DIR_PIN , HIGH);
 digitalWrite(Y_DIR_PIN , HIGH);

 for (int i = 0; i <= 3200; i++)
 {
 digitalWrite(X_STEP_PIN , HIGH);
 digitalWrite(Y_STEP_PIN , HIGH);
 delay(1);
 digitalWrite(X_STEP_PIN , LOW);
 digitalWrite(Y_STEP_PIN , LOW);
 }
 delay(1000);

 digitalWrite(X_DIR_PIN , LOW);
 digitalWrite(Y_DIR_PIN , LOW);

 for (int i = 0; i <= 3200; i++)
 {
 digitalWrite(X_STEP_PIN , HIGH);
 digitalWrite(Y_STEP_PIN , HIGH);
 delay (1);
 digitalWrite(X_STEP_PIN , LOW);
 digitalWrite(Y_STEP_PIN , LOW);
 }
 delay(1000);

 

 

Muchas veces cuando usamos motores paso paso es para tener precisión a la hora de posicionar un elemento. En el caso de las impresoras 3d, o que sé yo, si quisiéramos controlar la apertura y cierre de una persiana motorizada, necesitamos saber cual es el origen del movimiento.

Para esto se utilizan los finales de carrera, que no son más que unos interruptores, que al ser apretados nos indican que hemos llegado al punto «cero» u origen.

Vamos a modificar el programa anterior para hacer que antes de que empiecen a moverse los motores se posicionen tocando los finales de carrera. Para eso lo primero que hacemos es establecer los pines para los finales de carrera como entrada, y las vamos a poner como PULL_UP, de forma que que leamos un 0 al apretarlos.

Además en el setup vamos a hacer un par de bucles, uno para cada motor, en el que los movamos paso a paso hasta que leamos que se ha presionado un interruptor.

 pinMode(X_MIN_PIN , INPUT_PULLUP);
 pinMode(Y_MIN_PIN , INPUT_PULLUP);
 
 Serial.println ("EMPEZANDO HOME");

 while (digitalRead(X_MIN_PIN) == 1)
 {
 
 digitalWrite(X_DIR_PIN, LOW);
 for (int i = 0; i <= 1; i++)
 {
 digitalWrite(X_STEP_PIN , HIGH);
 delay(1);
 digitalWrite(X_STEP_PIN , LOW);
 }
 }
 
 while (digitalRead(Y_MIN_PIN) == 1)
 { 
 digitalWrite(Y_DIR_PIN, LOW);
 for (int i = 0; i <= 1; i++)
 {
 digitalWrite(Y_STEP_PIN , HIGH);
 delay(1);
 digitalWrite(Y_STEP_PIN , LOW);
 }
 }
 Serial.println ("HOME TERMINADO");
 delay(1000);

Podéis descargar el programa completo aquí:

Ramps.