Hacemos una fresadora de control numérico de tres ejes.

La idea de hacer una máquina en casa con las manos no es nueva. Todos los que piensen en la implementación de dichos equipos en el hogar deben guiarse por su motivo de creación. Esto es necesario para mí, porque por naturaleza no tengo tantas manos rectas para hacer piezas buenas, incluso más o menos generales, y a menudo surge la tarea de hacer la parte compleja exacta, que la máquina puede manejar bien. Siempre hay suficientes nuevas ideas e ideas para la implementación, pero no mucho tiempo.



Brevemente sobre el autor.

4- , « », « », « ».

Spoiler

. , . , , , . . , - , .

Términos de referencia o qué esperar en la salida


La fresadora resultante debe cumplir las siguientes condiciones:

  • Tener un área de trabajo aceptable
  • Tener una velocidad axial aceptable
  • Para procesar piezas de madera de dureza media y alta. Idealmente manejar aluminio

La regla principal de las máquinas es la rigidez. Cuanto mayor sea la rigidez de la máquina, menor será la vibración, el contragolpe, el hundimiento, las curvas y otros defectos que afectarán la calidad de los blancos procesados. Dado que la máquina se fabricará completamente en casa, el único material que realmente se puede procesar en tal cantidad en el hogar y del cual será posible hacer la cama de la máquina: un árbol. Por supuesto que hay diferentes tipos. Y por la falta de gran capital, para el estudiante , todo lo que se encuentre se usará para crear. Y esto es esencialmente un tablero de muestra con un taladro de un árbol bastante blando. Aunque también hay pequeñas láminas de madera contrachapada. Lo que es rico, entonces será utilizado.

También vale la pena señalar qué control de la máquina se lanzará. Hay una computadora muy antigua, su orilla es casi para tales propósitos. AMD Duron 1.2 GHz, RAM 768 MB, 64 MB Video Mem, HDD 20 GB. Simplemente aptos para estos fines. La gestión estará bajo Linux CNC. Para Mach3 bajo Win no quería trabajar de forma inteligente. Necesita un poco más de recursos.

Desarrollo


El desarrollo de la máquina se dividirá en varias partes.

  • Desarrollo de un controlador de motor paso a paso.
  • Desarrollo de un motor paso a paso.
  • Diseño de aislamiento óptico
  • Desarrollo del plan de nutrición

Debe decirse de inmediato que el desarrollo de la parte mecánica como tal estuvo ausente, porque no hay tanta experiencia para desarrollar y anticipar algo. Por lo tanto, el desarrollo se llevó a cabo inmediatamente en la etapa de ensamblaje.

Desarrollo de un controlador de motor paso a paso.


Se desarrollará un controlador de motor paso a paso en un microcontrolador PIC. Por qué En primer lugar, era necesario entender finalmente cómo funcionan los motores paso a paso, en segundo lugar, era más interesante, en tercer lugar, el mismo chip L297 terminado costó un poco caro por alguna razón y, como resultado, se ensambló en el microcontrolador un poco más barato.



Como el microcontrolador de control se tomó PIC16F630. Tiene un mínimo de periferia y un número suficiente de patas para controlar. El puerto C es para salida directa de pulsos de control. Los pines A1, A2 tienen señales de entrada DIR, STEP. El pin A2 está habilitado en modo de interrupción externa, y DIR funciona como un pin de entrada normal. El controlador se lanza a través de cuarzo a 20 MHz.

El código fue escrito en C usando un pequeño inserto asm y compilado en el compilador CCS C.

#include <16f630.h>
#case  
#FUSES NOWDT                    
#FUSES NOMCLR                   
#FUSES HS                     
#FUSES PUT                    
#FUSES BROWNOUT 

#use delay(clock = 20 MHz)                                                                                                                         
#use fast_io(C)                                                     
#opt 9  
                                
#define DIR		PIN_A1                                                             
#define CLK		PIN_A2   
#define LED		PIN_A0                                
                                                                          
#zero_ram       
                             
//half step array     
const int steps[256] =    
{                 
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,                                                                                         
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,                                                                                          
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,                                                                                          
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,                                                                                          
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,                                                                                          
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,                                                                                          
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,                                                                                          
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101,
	0b00000100,0b00000110,0b00000010,0b00001010,0b00001000,0b00001001,0b00000001,0b00000101                                                                                             
};                                                         
             
unsigned int8 nowStep = 0;        
                                                                                                                 
#INT_TIMER1                                                     
void LoadDrop_isr()      
{                                                                           
	output_c(0);              
}                                                                                                          
                                                                                                       
#INT_EXT                    
void clk_isr()
{                                    
   //input_state(DIR) ? nowStep++ : nowStep--;                                                 
  	#asm asis              
  	BTFSC  05.1 
  	INCF   nowStep,F         
  	BTFSS  05.1                                                      
  	DECF   nowStep,F    
  	#endasm             
                    
	output_c(steps[nowStep]);
	set_timer1(0);		
}                                       
                                                                                                                                                    
void main()                                                                                                                                  
{                            
	output_a(0);                         
	input_a();  
	        
	set_tris_c(0);                    
	output_c(0);  
	                           
	setup_comparator(NC_NC_NC_NC);                        
	setup_timer_1(T1_INTERNAL | T1_DIV_BY_8);                       
	set_timer1(0);                                                          
	                          
	ext_int_edge(L_TO_H);    
	                                                          
	enable_interrupts(INT_TIMER1);             
	enable_interrupts(INT_EXT);                   
	enable_interrupts(GLOBAL);  
	                                                                    
	unsigned int16 blinkCounter = 0; 
	             
	MAIN_LOOP:                    
	                                  
		 if(!blinkCounter++)              
		 	output_toggle(LED);        
		 	                
	goto MAIN_LOOP;                                                                                                                                                      
}                                               

Para describir el código, será más fácil comenzar con la lógica del controlador. Cuando se inicia el controlador, se produce la configuración inicial de la plancha y la inclusión de interrupciones. El número de paso se almacena en la variable de 8 bits sin signo nowStep y al principio el número es cero. A continuación, el ciclo de programa perpetuo se inicia en MAIN_LOOP en el que simplemente hay un parpadeo del LED conectado al pin A0. Para que? En primer lugar, está claro que la piedra no se congeló, y en segundo lugar, ¡efectos especiales! El pin A2 está configurado para una interrupción externa en un borde ascendente. Cuando se registra un evento en el pie, se procesará la interrupción INT_EXT en la que se cambia el siguiente paso. Para mostrar el siguiente paso, se produce un incremento o disminución del puntero de paso nowStep, dependiendo de la entrada DIR.Luego, desde la matriz de pasos pasos desde la posición nowStep, se muestra una nueva combinación de conmutación de los devanados del motor en el puerto. Además, al comienzo de la inicialización del microcontrolador, se configura e inicia el temporizador 1. Este temporizador restablece las señales de salida para evitar el sobrecalentamiento de los motores. El temporizador restablece las señales de salida aproximadamente 100 ms después de configurar la señal. Es decir, esta es una medida puramente precautoria.

En la simulación, fue posible lograr un período de señal CLK de 15 μs, que corresponde a una frecuencia de 66. (6) KHz. Sin embargo, creo que por primera vez no está mal, es posible una mayor optimización.

Desarrollo de un motor paso a paso.


No hay necesidad de ir lejos. Esquema típico. El controlador se basa en el controlador terminado L298N.



¿Por qué resistencias R1 - R4? Honestamente, no lo se. Inicialmente, la documentación va al circuito junto con L297, toda comunicación sin resistencias. Sin embargo, en Internet encontré circuitos con resistencias en las líneas. Miré el diagrama de bloques en la hoja de datos en el L298N. Todas las líneas de ENTRADA van al elemento Y de entrada inversa. Nada debería suceder sin resistencias. Pero decidí no arriesgarme y por si acaso para insertar, esta vez. No será mucho peor, la inclinación del frente en la entrada caerá.

El resto del esquema repite el que figura en la hoja de datos.

Diseño de aislamiento óptico


La placa optoacopladora sirve para proteger la máquina de control, en este caso la computadora, de la parte de alimentación de la máquina. Por lo tanto, si algo comienza a humear desde el costado de la máquina, lo hará solo hasta la placa del optoacoplador y minimizará el daño.

El esquema es bastante grande, así que haga clic para ver el tamaño completo. Inicialmente, se tomaron optoacopladores 4N25. Porque pensé que cualquier optoacoplador de hoy se estiraría 60 kHz. Pero, de hecho, no, no lo estiraron, no tuvieron tiempo. Por lo tanto, como resultado, tuve que reemplazarlo con 6N135, en el que el rendimiento es mucho mayor (hasta 2MHz en términos de hoja de datos). Por pines, no son directamente compatibles, sin embargo, fue posible insertarlos sin alterar toda la placa. No hice un nuevo esquema, creo que quien quiera, podrá recargar la placa por su cuenta.





Como debería ser, la potencia del circuito se divide en dos partes, desde el lado de la máquina y el lado de la computadora. Desde el lado de la computadora, la energía se suministra a través del cable USB, este es su único propósito. Desde el lado de la máquina ya hay un paquete de cables de 5 V.

Desarrollo del plan de nutrición


Además, dado que todo se hizo no en monolito, sino en pequeños bloques, fue necesario separar más cables de lo habitual para la alimentación y las señales. Por lo tanto, para simplificar el cableado, decidí hacer una pequeña tira separada con conectores para distribuir la energía en las líneas de 12 V y 5 V. La tira de energía



contiene seis conectores para líneas de 5 V y 12 V, así como dos conectores separados para conectar refrigeradores.

Asamblea y resultado


Como no comencé a tomar fotos desde el principio, y no había ningún plan para escribir un artículo, faltan muchos pasos de montaje, pero mostraré los que sí. Todas las fotos en esta sección son clicables.

Hacer un conductor de motor paso a paso


Movió la imagen con LUT: Grabado y estañado: Perforado: Sellado: Luego, fue necesario repetir el éxito para 2 ejes más:





















Fabricación de paneles de aislamiento óptico




Se movió LUTom y se corrigió con un marcador:



Grabado:





Manchado: Ensamblado



todos los componentes electrónicos:







Montaje de la máquina


La máquina se ensambló a partir de tableros contrachapados de 10 mm de espesor y 18 mm. Al ensamblar, se usaron guías de muebles, fue mejor por primera vez que no encontré nada, y psicológicamente no estaba listo para procesar al menos las mismas esquinas metálicas.

Al principio hubo tal construcción:





la primera versión del eje Z:



pero como lo entiendo ahora, no fue nada bueno, todo dio vueltas, escalonado. En general, no se habló de ninguna rigidez.
Se produjo otro intento:





durante el cual los ejes X e Y se movieron a una plataforma separada y se convirtieron en una mesa móvil:



ya era mejor, pero aún estaba muy lejos de algo que no se tambaleaba. Como resultado, llegué a esta opción:



Sin embargo, el eje Z todavía se retorcía y doblaba demasiado. Esta vez me senté y pensé bien y ya estaba involucrado en algún diseño. El resultado fue este diseño:



las esquinas de aluminio igual con un estante de 25 mm y un grosor de 2 mm se utilizaron como guías. No pude encontrar acero. Serían muchas veces mejores. Las pautas para la fabricación industrial, por supuesto, todavía no se pueden comparar.

Carro móvil:





nuevo eje Z montado:





resultado. Puede notar que el eje ensamblado, y el diseño en su conjunto, aún difiere incluso del diseñado. Sin embargo, alinear y centrar el eje cuando solo necesita un calibrador a vernier y un taladro manual es una tarea bastante difícil. Así que tuve que cambiar de opinión y experimentar sobre la marcha:





Muestras para moler algo:



Incluso con tantos si, incluso con un diseño tan imperfecto, logré crear algo que funcionara y el resultado me impresionó.

Computadora de control


El software de control para máquinas CNC debe funcionar en sistemas en tiempo real para generar señales sincronizadas con precisión. Por lo tanto, Windows no es adecuado para esto. Por supuesto, para la operación correcta, se escriben controladores que resuelven este problema, pero generalmente requiere más recursos, y la estabilidad de dicho sistema es menor que la de los sistemas en tiempo real.
El procesamiento se llevó a cabo bajo el control de LinuxCNC. La instalación y configuración no deberían causar mucha dificultad. El sitio web del programa ya tiene compilaciones listas para usar y fuentes gourmet. Existen varios métodos de instalación: en un sistema ya instalado o desde cero junto con un sistema operativo configurado. Elegí la segunda opción, ya que no tenía mucha experiencia con Linux y no había suficiente tiempo para lidiar con el proceso de parcheo. La segunda opción es una distribución regular de Debian con un núcleo RTC y LinuxCNC ya instalados.

Después de la instalación, es necesario ajustar el eje de las máquinas: mapeo de señales, velocidad, aceleración, etc. El resultado es un archivo de salida para iniciar, que, cuando se inicia, mostrará el programa de control de la máquina con los parámetros especificados.

Conclusión


Como resultado del trabajo realizado, quedan muchas impresiones, así como preguntas y tareas para mejorar la máquina resultante.

  1. Para aumentar el voltaje de los motores de 12 V a su funcionamiento de 24 V
  2. Fortalezca el diseño e idealmente prepare un nuevo diseño de máquina con un diseño preliminar completo
  3. Agregar interruptores de límite y botón de parada de emergencia
  4. Para optimizar el funcionamiento de los controladores de motor.
  5. Vuelva a montar la electrónica de la máquina en una placa, a excepción de la placa de optoaislamiento.
  6. Reemplace el eje de la máquina con el que coincida con el propósito. Es un motor altamente acelerado y más potente que el grabador chino actual.
  7. Reemplace el motor en el eje Z, ya que el motor actual es menos potente y el más cargado

La máquina resultante tiene un área de trabajo de más de 270 mm a lo largo de los ejes X e Y, y aproximadamente 150 mm a lo largo de Z. Las velocidades de movimiento a lo largo de los ejes X e Y son más de 500 mm / s, y a lo largo de Z 300 mm / s. Esto es a 12 V de voltaje de funcionamiento. Esa es la mitad de su rendimiento. Hay espacio para crecer.

Lo que se puede decir con certeza: valió la pena. Al menos una tarea que la máquina hará bien ahora: tablas de cortar. Puedes olvidarte del grabado y LUT. Las tablas de cortar tienen, por supuesto, sus inconvenientes, pero es mejor tener alternativas que la única opción. En el video, se vio cómo una fresa de 3 mm molía la letra M, tal vez con una velocidad de avance baja y capas de 0,1 mm, pero este también es el resultado.

Difundir algunas fuentes o placas PCB no ven mucho punto hasta ahora. La máquina no funcionó adecuada para cargas serias o bastante estable y única. Sin embargo, este no es el último intento de hacer nada y espero que la próxima iteración de desarrollo se esté preparando, una mejor.

Source: https://habr.com/ru/post/es394537/


All Articles