Geekly articles weekly

Fabricamos uma fresadora de controle numérico de três eixos

A idéia de fazer uma máquina em casa com as mãos não é nova. Todos que pensam na implementação de tais equipamentos em casa devem ser guiados por seus motivos de criação. Isso é necessário para mim, porque, por natureza, não tenho tantas mãos retas para criar peças boas, mesmo mais ou menos gerais, e geralmente surge a tarefa de criar a peça complexa exata, com a qual a máquina pode lidar bem. Sempre existem novas idéias e idéias para implementação, mas não há muito tempo.



Brevemente sobre o autor

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

Spoiler

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

Termos de Referência ou o que esperar na saída


A fresadora resultante deve atender às seguintes condições:

  • Tenha uma área de trabalho aceitável
  • Tenha uma velocidade axial aceitável
  • Processar peças de madeira de dureza média e alta. Idealmente manusear alumínio

A principal regra das máquinas é a rigidez. Quanto maior a rigidez da máquina, menor vibração, folga, descida, dobras e outros defeitos que afetarão a qualidade dos espaços em branco processados. Como a máquina será fabricada completamente em casa, o único material que realmente pode ser processado em tal quantidade em casa e do qual será possível fazer a cama da máquina - uma árvore. Claro que existem tipos diferentes. E pela falta de grande capital, para o aluno , tudo o que for encontrado será usado para criar. E este é essencialmente um quadro de amostra com uma broca de uma árvore bastante macia. Embora existam também pequenas folhas de madeira compensada. O que é rico, então será usado.

Também é importante notar que controle da máquina será lançado. Há um computador muito antigo, sua margem é quase para tais propósitos. AMD Duron 1,2 GHz, RAM 768 MB, 64 MB Video Mem, HDD 20 GB. Apenas adequado para esses fins. O gerenciamento estará sob o Linux CNC. Para Mach3 sob Win não queria trabalhar de forma inteligente. Ele precisa de um pouco mais de recursos.

Desenvolvimento


O desenvolvimento da máquina será dividido em várias partes.

  • Desenvolvimento de um controlador de motor de passo
  • Desenvolvimento de um driver de motor de passo
  • Projeto de isolamento óptico
  • Desenvolvimento do Plano de Nutrição

Deve-se dizer imediatamente que o desenvolvimento da parte mecânica, como tal, estava ausente, porque não há muita experiência para desenvolver e antecipar algo. Portanto, o desenvolvimento foi realizado imediatamente na fase de montagem.

Desenvolvimento de um controlador de motor de passo


Um controlador de motor de passo será desenvolvido em um microcontrolador PIC. Porque Em primeiro lugar, foi necessário finalmente entender como os motores de passo funcionam; em segundo lugar, era mais interessante; em terceiro lugar, o mesmo chip L297 acabado custava um pouco caro por algum motivo e, como resultado, acabou sendo montado no microcontrolador um pouco mais barato.



Como o microcontrolador de controle foi tomado PIC16F630. Possui um mínimo de periferia e um número suficiente de pernas para controlar. A porta C é para saída direta de pulsos de controle. Os pinos A1, A2 possuem sinais de entrada DIR, STEP. O pino A2 está ativado no modo de interrupção externa e o DIR funciona como um pino de entrada comum. O controlador é lançado através de quartzo a 20 MHz.

O código foi escrito em C usando uma pequena inserção asm e compilado no 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 descrever o código, será mais fácil começar com a lógica do controlador. Quando o controlador inicia, ocorre a configuração inicial do ferro e a inclusão de interrupções. O número da etapa é armazenado na variável de 8 bits não assinada nowStep e, no início, o número é zero. Em seguida, o ciclo perpétuo do programa é iniciado em MAIN_LOOP, no qual há simplesmente um piscar do LED conectado ao pino A0. Para que? Em primeiro lugar, é claro que a pedra não congelou e, em segundo lugar, efeitos especiais! O pino A2 está configurado para uma interrupção externa em uma borda ascendente. Quando um evento é gravado no pé, a interrupção INT_EXT será processada na qual a próxima etapa é alternada. Para exibir a próxima etapa, um incremento ou decremento do ponteiro da etapa nowStep ocorre, dependendo da entrada DIR.Em seguida, a partir da matriz de etapas da posição nowStep, uma nova combinação de comutação dos enrolamentos do motor é exibida na porta. Além disso, no início da inicialização do microcontrolador, o timer 1. é configurado e iniciado.Este timer redefine os sinais de saída para evitar o superaquecimento dos motores. O timer redefine os sinais de saída aproximadamente 100 ms após definir o sinal. Ou seja, essa é uma medida puramente preventiva.

Na simulação, foi possível obter um período de sinal CLK de 15 μs, o que corresponde a uma frequência de 66. (6) KHz. Pela primeira vez, não é ruim, acho que é possível uma otimização adicional.

Desenvolvimento de um driver de motor de passo


Não há necessidade de ir longe. Esquema típico. O driver é construído com base no driver finalizado L298N.



Por que resistores R1 - R4? Honestamente, eu não sei. Inicialmente, a documentação vai para o circuito em conjunto com o L297, toda comunicação sem resistores. No entanto, na Internet, encontrei circuitos com resistores nas linhas. Olhei para o diagrama de blocos na folha de dados do L298N. Todas as linhas INPUT vão para o elemento AND de entrada inversa. Nada deve acontecer sem resistores. Mas eu decidi não arriscar e apenas para inserir, desta vez. Não será muito pior, a inclinação da frente na entrada cairá.

O restante do esquema repete o indicado na folha de dados.

Projeto de isolamento óptico


A placa do acoplador óptico serve para proteger a máquina de controle, neste caso o computador, da parte de energia da máquina. Portanto, se algo começar a fumar do lado da máquina, ele fumará apenas até a placa do optoacoplador e minimizará os danos.

O esquema é bastante grande, então clique para ver o tamanho completo. Inicialmente, foram utilizados os acopladores ópticos 4N25. Pois eu pensei que qualquer acoplador óptico de hoje esticaria 60 kHz. Mas, de fato, não, eles não esticaram, não tiveram tempo. Portanto, como resultado, tive que substituí-lo pelo 6N135, cujo desempenho é muito maior (até 2 MHz em termos de folha de dados). Por pinos, eles não são diretamente compatíveis, no entanto, foi possível inseri-los sem alterar a placa inteira. Eu não fiz um novo esquema, acho que quem quiser, poderá recarregar o conselho por conta própria.





Como deve ser, a potência do circuito é dividida em duas partes, do lado da máquina e do lado do computador. Do lado do computador, a energia é fornecida através do cabo USB, esse é seu único objetivo. Do lado da máquina já existe um feixe de fios de 5 V.

Desenvolvimento do Plano de Nutrição


Além disso, como tudo era feito não em monólito, mas em pequenos blocos, era necessário separar mais fios do que o habitual para energia e sinais. Portanto, para simplificar a fiação, decidi fazer uma pequena faixa separada com conectores para distribuição de energia nas linhas de 12 V e 5 V. A régua de energia



contém seis conectores para as linhas de 5 V e 12 V, além de dois conectores separados para conectar os refrigeradores.

Montagem e resultado


Como não comecei a tirar fotos desde o início e não havia plano de escrever um artigo, faltam muitas etapas de montagem, mas mostrarei as que são. Todas as fotos nesta seção são clicáveis.

Fazendo um driver de motor de passo


Moveu a imagem com LUT: Gravado e enlatado: Perfurado: Selado: Em seguida, foi necessário repetir o sucesso para mais 2 eixos:





















Fabricação de painéis de isolamento óptico




Movido LUTom e corrigido com um marcador:



Gravado:





Manchado: Montado



todos os componentes eletrônicos:







Montagem da máquina


A máquina foi montada a partir de compensado de 10 mm de espessura e placas de 18 mm. Na montagem, foram utilizados guias de móveis; era melhor, pela primeira vez, não encontrar nada e, psicologicamente, não estava pronto para processar pelo menos os mesmos cantos de metal.

A princípio, houve uma construção assim:





a primeira versão do eixo Z:



mas como eu o entendo agora, não era bom, tudo deu a volta, cambaleando. Em geral, não se falou em rigidez.
Outra tentativa se seguiu:





durante a qual os eixos X e Y foram movidos para uma plataforma separada e transformados em uma mesa móvel:



já era melhor, mas ainda muito longe de algo que não cambaleia. Como resultado, cheguei a esta opção:



No entanto, o eixo Z ainda estava tremendo e dobrando demais. Dessa vez, sentei-me e pensei bem e já estava envolvido em algum projeto. O resultado foi este projeto:



cantos iguais de alumínio com uma prateleira de 25 mm e uma espessura de 2 mm foram usados ​​como guias. Não encontrei aço. Eles seriam muitas vezes melhores. As diretrizes para a fabricação industrial, é claro, ainda não podem ser comparadas.

Carro em movimento:





Novo eixo Z montado:





resultado. Você pode notar que o eixo montado e o design como um todo ainda diferem do eixo projetado. No entanto, alinhar e centralizar o eixo quando você só precisa de um paquímetro e broca manual é uma tarefa bastante difícil. Então eu tive que mudar de idéia e experimentar em qualquer lugar:





Amostras para moer algo:



Mesmo com tantos se, mesmo com um design tão imperfeito, eu consegui criar algo funcionando e o resultado que me impressionou.

Computador de controle


O software de controle para máquinas CNC deve trabalhar em sistemas em tempo real para gerar sinais precisamente sincronizados. Portanto, o Windows não é adequado para isso. Obviamente, para a operação correta, são escritos drivers que resolvem esse problema, mas geralmente requerem mais recursos, e a estabilidade de um sistema desse tipo é menor do que os sistemas em tempo real.
O processamento foi realizado sob o controle do LinuxCNC. A instalação e configuração não devem causar muita dificuldade. O site do programa já possui versões prontas e fontes gourmet. Existem vários métodos de instalação: em um sistema já instalado ou do zero, juntamente com um sistema operacional configurado. Eu escolhi a segunda opção, pois não tinha muita experiência com Linux e não havia tempo suficiente para lidar com o processo de correção. A segunda opção é uma distribuição Debian regular com um kernel RTC e LinuxCNC já instalado.

Após a instalação, é necessário ajustar o eixo das máquinas: mapeamento de sinal, velocidade, aceleração e assim por diante. O resultado é um arquivo de saída para iniciar, que, quando iniciado, mostrará o próprio programa de controle da máquina com os parâmetros especificados.

Conclusão


Como resultado do trabalho realizado, restam muitas impressões, além de perguntas e tarefas para melhorar a máquina resultante.

  1. Aumentar a tensão dos motores de 12 V para os 24 V de trabalho
  2. Reforce o design e prepare idealmente um novo design de máquina com design completo preliminar
  3. Adicione interruptores de limite e botão de parada de emergência
  4. Para otimizar a operação dos controladores de motor
  5. Remonte os componentes eletrônicos da máquina em uma placa, exceto a placa de opto-isolamento
  6. Substitua o eixo da máquina pela finalidade correspondente. Esse é um motor altamente acelerado e mais poderoso do que o atual gravador chinês.
  7. Substitua o mecanismo no eixo Z, pois o mecanismo atual é menos potente e o mais carregado

A máquina resultante possui uma área de trabalho de mais de 270 mm ao longo dos eixos X e Y e cerca de 150 mm ao longo do Z. As velocidades de movimento ao longo dos eixos X e Y são mais de 500 mm / s e ao longo do Z 300 mm / s. Esta é a tensão operacional de 12 V. Isso é metade do desempenho deles. Há espaço para crescer.

O que se pode dizer com certeza - valeu a pena. Pelo menos uma tarefa que a máquina fará bem agora: tábuas de cortar. Você pode esquecer a gravação e a LUT. Obviamente, as tábuas de cortar têm suas desvantagens, mas é melhor ter alternativas do que a única opção. No vídeo, foi visto como uma fresa de 3 mm usinou a letra M, talvez com baixa taxa de avanço e camadas de 0,1 mm, mas esse também é o resultado.

Espalhe algumas placas de fonte ou PCB até agora. A máquina não funcionou adequadamente para cargas sérias ou bastante estável e única. No entanto, esta não é a última tentativa de fazer nada e a próxima iteração de desenvolvimento está sendo preparada, espero, melhor.

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

More articles:


All Articles