Controlador de brazo robótico MK2 Plus

Hagamos una pequeña función de ayuda para configurar nuestros pines.

  void pinsetup () {
 pinMode (ENABLE, OUTPUT); 
 digitalWrite (ENABLE, LOW); 
 pinMode (XLIMIT, INPUT_PULLUP); 
 pinMode ( YLIMIT, INPUT_PULLUP); 
 pinMode (ZLIMIT, INPUT_PULLUP); 
}  

Ahora que está hecho, repasemos la lógica de nuestra rutina de búsqueda.

  void autohome () {// Estamos usando esto para llamar a nuestra rutina de inicio 
 xyhome (); 
 zhome (); 
} 
 void xyhome () {
 int initial_xhome =-1; 
 int initial_yhome =-1; 
 // Establezca la velocidad máxima y la aceleración de cada paso a paso al inicio para el inicio 
 XMOTOR.setMaxSpeed ​​(500.0 ); // Establece la velocidad máxima de paso a paso (más lenta para obtener una mejor precisión) 
 XMOTOR.setAcceleration (50.0); // Establecer la aceleración de Stepper 
 YMOTOR.setMaxSpeed ​​(500.0); // Establece la velocidad máxima de paso a paso (más lenta para obtener una mejor precisión) 
 YMOTOR.setAcceleration (50.0); // Establecer la aceleración del motor paso a paso 
 // Iniciar el procedimiento de inicio del motor paso a paso al inicio 
 while (digitalRead (YLIMIT)) {// Hacer que el paso a paso se mueva en sentido antihorario hasta que se active el interruptor 
 XMOTOR. moveTo (initial_xhome); // Establece la posición para mover a 
 YMOTOR.moveTo (initial_yhome); // Establece la posición para mover a 
 initial_xhome--; // Disminuir en 1 para el siguiente movimiento si es necesario 
 initial_yhome--; 
 XMOTOR.run (); // Empiece a mover el paso a paso 
 YMOTOR.run (); 
 delay (5); 
} 
 XMOTOR.setCurrentPosition (0); // Establece la posición actual como cero por ahora 
 YMOTOR.setCurrentPosition (0); 
 initial_xhome =-1; 
 initial_yhome =1; 
 while (digitalRead (XLIMIT)) { 
 XMOTOR.moveTo (initial_xhome); // Establece la posición para mover a 
 YMOTOR.moveTo (initial_yhome); // Establece la posición para mover a 
 initial_xhome--; // Disminuir en 1 para el siguiente movimiento si es necesario 
 initial_yhome ++; 
 XMOTOR.run (); // Empiece a mover el paso a paso 
 YMOTOR.run (); 
 delay (5); 
} 
 YMOTOR.setCurrentPosition (0); // Establecer la posición actual como cero por ahora 
 YMOTOR.setMaxSpeed ​​(250.0); // Establece la velocidad máxima de paso a paso (más lenta para obtener una mejor precisión) 
 YMOTOR.setAcceleration (10.0); // Establecer la aceleración de Stepper 
 initial_yhome =1; 
 while (! DigitalRead (YLIMIT)) {// Hacer que el Stepper se mueva CW hasta que se desactive el interruptor 
 YMOTOR.moveTo (initial_yhome); 
 YMOTOR.run (); 
 initial_yhome ++; 
 delay (5); 
} 
 YMOTOR.setCurrentPosition (0); 
 YMOTOR.setMaxSpeed ​​(YMOTORMAXSPEED ); // Establecer la velocidad máxima de paso a paso (más rápido para movimientos regulares) 
 YMOTOR.setAcceleration (YMOTORACC); // Establecer la aceleración de Stepper 
 XMOTOR.setCurrentPosition (0); // Establecer la posición actual como cero por ahora 
 XMOTOR.setMaxSpeed ​​(250.0); // Establece la velocidad máxima de paso a paso (más lenta para obtener una mejor precisión) 
 XMOTOR.setAcceleration (10.0); // Establecer la aceleración de Stepper 
 initial_xhome =1; 
 while (! DigitalRead (XLIMIT)) {// Hacer que el Stepper se mueva CW hasta que se desactive el interruptor 
 XMOTOR.moveTo (initial_xhome); 
 XMOTOR.run (); 
 initial_xhome ++; 
 delay (5); 
} 
 XMOTOR.setCurrentPosition (0); 
 XMOTOR.setMaxSpeed ​​(XMOTORMAXSPEED ); // Establecer la velocidad máxima de paso a paso (más rápido para movimientos regulares) 
 XMOTOR.setAcceleration (XMOTORACC); // Establecer la aceleración de Stepper 
} 
 void zhome () {
 int initial_zhome =-1; 
 // Establecer la velocidad máxima y la aceleración de cada Stepper al inicio para el inicio 
 ZMOTOR.setMaxSpeed ​​(100.0); // Establece la velocidad máxima de paso a paso (más lenta para obtener una mejor precisión) 
 ZMOTOR.setAcceleration (100.0); // Establecer la aceleración del motor paso a paso 
 // Iniciar el procedimiento de inicio del motor paso a paso al inicio 
 while (digitalRead (ZLIMIT)) {// Hacer que el paso a paso se mueva en sentido antihorario hasta que se active el interruptor 
 ZMOTOR. moveTo (initial_zhome); // Establece la posición para mover a 
 initial_zhome--; // Disminuir en 1 para el próximo movimiento si es necesario 
 ZMOTOR.run (); // Empiece a mover el paso a paso 
 delay (5); 
} 
 ZMOTOR.setCurrentPosition (0); // Establecer la posición actual como cero por ahora 
 ZMOTOR.setMaxSpeed ​​(50.0); // Establece la velocidad máxima de paso a paso (más lenta para obtener una mejor precisión) 
 ZMOTOR.setAcceleration (50.0); // Establecer la aceleración de Stepper 
 initial_zhome =1; 
 while (! DigitalRead (ZLIMIT)) {// Hacer que el Stepper se mueva CW hasta que se desactive el interruptor 
 ZMOTOR.moveTo (initial_zhome); 
 ZMOTOR.run (); 
 initial_zhome ++; 
 delay (5); 
} 
 ZMOTOR.setCurrentPosition (0); 
 ZMOTOR.setMaxSpeed ​​(1000.0 ); // Establecer la velocidad máxima de Stepper (más rápido para movimientos regulares) 
 ZMOTOR.setAcceleration (1000.0); // Establecer la aceleración de Stepper 
}  

Bien, eso es mucho código. ¿Qué está pasando realmente aquí? El brazo primero realiza una rutina de referencia en los motores X e Y. Debido a la forma en que funcionan los vínculos, esto se hace en unos pocos pasos. (Puede ver el video al final para ver esto en acción)

• Primero, los motores X e Y se mueven en direcciones opuestas para que el interruptor de límite Y se presione primero.
• Tan pronto como se presiona el interruptor de límite Y, ambos motores giran en la misma dirección de modo que se presiona el interruptor de límite X.
• Después de presionar el interruptor X, los motores se mueven un poco para que los interruptores se presionen (presionados como en, no el triste un poco presionado).
• Finalmente, el motor Z se gira de manera que se presiona el interruptor de límite Z.

Deberá tener mucho cuidado al realizar el procedimiento de inicio por primera vez. Si sus motores paso a paso se mueven hacia el otro lado, simplemente APAGUE LA CORRIENTE y LUEGO gire el conector del motor.

Ahora que está hecho, llame a autohome () desde su función setup () para que solo se ejecute una vez. Deje su bucle () en blanco. Y mantenga una mano sobre la fuente de alimentación para apagarla si algo sale mal.

  void setup () {
 // ponga su código de configuración aquí, para que se ejecute una vez:
 Serial.begin (9600); 
 pinsetup (); 
 autohome (); 
 Serial.println ("HOMING OK"); 
}  

Si tiene suerte, sus motores girarán en la dirección correcta, los interruptores de límite harán clic correctamente y la rutina de inicio funcionará sin ningún problema. Pero si eres como yo, tendrás que hacer pequeños cambios antes de que todo esté listo y funcionando. Por lo tanto, desconecte siempre la alimentación si el inicio no funciona correctamente para no estropear su brazo impreso en 3D.

Finalmente, puede escribir su propia lógica en el bucle () para que su brazo se mueva a las posiciones que desee. Debido a la forma en que está vinculado el brazo, los motores X e Y controlan el efector final de una manera casi cartesiana.

  void loop () {
 XMOTOR.runToNewPosition (100); 
 delay (1000); 
 YMOTOR.runToNewPosition (50); 
 delay (1000); 
 YMOTOR.runToNewPosition (-50); 
 delay (1000); 
 YMOTOR.runToNewPosition (0); 
 delay (1000); 
 XMOTOR.runToNewPosition ( 0); 
 retraso (1000); 
}  

Conclusión

He visto muchos tutoriales sobre cómo usar el popular firmware GRBL para controlar este brazo. Sin embargo, esto significa que necesita una computadora para enviar comandos en serie al brazo para que se mueva. Si solo necesita que el brazo MK2 haga unos pocos movimientos, puede codificarlos fácilmente en el Arduino y dejar que haga lo suyo.

¡Eso no significa que no puedas controlar esto con comandos en serie! Simplemente puede incorporar un código delimitador de serie en este y enviar los pasos del motor XY y Z como una cadena (delimitada con caracteres especiales, por ejemplo, 5, 6, 7 * que movería el motor X en 5 pasos, el Y en 6 y la Z por 7. El * se usa para indicar el final de la cadena).

También puede desarrollar esto aún más para enviar las coordenadas espaciales 3D del efector final y hacer que el arduino descubra los pasos requeridos usando cinemática inversa, o incluso trigonometría básica.

¡Divertirse! ¡Y mi más sincero agradecimiento a todos los brillantes diseñadores de Thingiverse!

 Sin vista previa (solo descarga).