Felipe monografia tcc 2013 14 101

Felipe Campos dos Santos

CONTROLE DE TRÊS EIXOS DE MÁQUINA FERRAMENTA CNC COM ARDUINO

Porto Alegre 2013

Felipe Campos dos Santos

CONTROLE DE TRÊS EIXOS DE MÁQUINA FERRAMENTA CNC COM ARDUINO

Trabalho de Conclusão apresentado para obtenção do título de Tecnólogo em Automação Industrial na Faculdade de Tecnologia SENAI Porto Alegre do Curso Superior de Tecnologia em Automação Industrial.

Orientador: Professor Sergio Helegda

Porto Alegre 2013

Felipe Campos dos Santos

CONTROLE DE TRÊS EIXOS DE MÁQUINA FERRAMENTA CNC COM ARDUINO

Trabalho de Conclusão apresentado para obtenção do título de Tecnólogo em Automação Industrial na Faculdade de Tecnologia SENAI Porto Alegre do Curso Superior de Tecnologia em Automação Industrial

Data de aprovação

_________________________________ Prof. Me. Sergio Helegda

_________________________________ Prof.

_________________________________ Prof. Me. Alexandre Gaspary Haupt

Dedicat贸ria Dedico esse trabalho ao meu pai Antonio Vianei Lemos dos Santos.

Agradecimentos

Percilia Campos dos Santos

Por todo apoio e ajuda ao longo de todos esses anos

Vianei Campos dos Santos

Pela incentivação e motivação ao longo da minha caminhada.

Sergio Helegda

Por dedicação pessoal no apoio do desenvolvimento desse trabalho

RESUMO

O desenvolvimento de máquinas ferramentas de baixo custo na indústria de usinagem de matérias é um desafio crescente ao passo que os custos com software crescem são progressivamente crescentes. Assim, um dos principais objetivos da indústria é utilizar tecnologias robustas e confiáveis com custo razoavelmente baixo no desenvolvimento de máquinas. Dessa forma, a proposta desse trabalho foi desenvolver um programa de controle de posicionamento de uma máquina ferramenta para usinagem de materiais leves, utilizando a tecnologia acessível de processamento com o microcontrolador Arduino Uno. Entre as tecnologias computacionais usadas foram à plataforma Arduino IDE, para programação em linguagem C, o MATLAB, para validação de dados, e o Autodesk Inventor, para o projeto mecânico. Construtivamente, escolheu-se utilizar um protótipo de máquina ferramenta genérica para realizar uma integração de sistemas de projeto de engenharia auxiliado pelo computador. Paralelamente, o conjunto de metodologias aplicadas no desenvolvimento desse programa é composto por conceitos de computação gráfica, elaboradas pelo autor André Lamothe (1995), e do algoritmo de Jack Elton Bresenham (1962), para desenhos de linhas em dispositivos matriciais. O resultado desse trabalho foi a produção de um firmware de execução de tarefas de interpolações lineares a partir da interpretação de comandos em código G enviados pela comunicação serial via computador a placa Arduino Uno. Palavras-chave: Arduino. Controle. Programação. Interpolação.

ABSTRACT

The development of machine tools in the industry of low cost machining of materials is a growing challenge while software costs are steadily increasing. Thus , a major goal of industry is to use robust and reliable technology with reasonably low cost in developing machines. Thus , the purpose of this study was to develop a program to control the positioning of a machine tool for machining soft materials, using accessible processing technology with Arduino Uno microcontroller. Between computational technologies used were the Arduino platform IDE for programming in C, MATLAB, data validation, and Autodesk Inventor for mechanical design.

Constructively, was chosen to use a generic tool prototype machine to perform a systems integration engineering design aided by computer. In parallel, the set of methodologies used in the development of this program consists of concepts of computer graphics , developed by the author Andre Lamothe (1995 ), and Jack Elton Bresenham algorithm (1962 ), for line drawings in raster devices. The result of this work was the production of a firmware for execution of linear interpolations tasks from the interpretation of G-code commands sent by serial communication via computer to Arduino Uno board .

Keywords: Arduino. Control. Programing. Interpolation

LISTA DE FIGURAS

Figura 1 – Exemplo de Processo de Corte ................................................................ 16 Figura 2 – Pesquisa de Preferência de Controle de Máquinas Ferramentas ............ 18 Figura 3 – Pesquisa de Tipos de Máquinas Ferramentas Utilizadas......................... 19 Figura 4 – Exemplo de Controle em Um Eixo ........................................................... 21 Figura 5 – Gráfico da Equação Geral de uma Reta .................................................. 22 Figura 6 – Motor de Passo de Relutância Variável ................................................... 24 Figura 7 – Motor de Passo RV .................................................................................. 25 Figura 8 – Motor de Paso de Imãs Permanentes ...................................................... 25 Figura 9 – Motor de Passo Híbrido ............................................................................ 26 Figura 10 – Malha de Controle Típica de Motor de Passo ........................................ 27 Figura 11 – Protótipo de Router CNC de 3 Eixos ...................................................... 27 Figura 12 – Arduino Uno ........................................................................................... 29 Figura 13 – Arduino + MATLAB ................................................................................ 30 Figura 14 – Lista de Materiais ................................................................................... 31 Figura 15 – Chaves Óticas ........................................................................................ 31 Figura 16 – Chaves Alavancas.................................................................................. 33 Figura 17 – Unidade de Controle .............................................................................. 34 Figura 18 – Diagrama Elétrico da Unidade de Controle ............................................ 35 Figura 19 – Diagrama de Fluxo de Processos .......................................................... 36 Figura 20 – Diagrama de Contexto ........................................................................... 37 Figura 21 – Diagrama de Transformações ................................................................ 38 Figura 22 – Perfil Trapezoidal da Aceleração do Motor de Passo............................. 43 Figura 23 – Aproximação de Linha por Interpolação Linear ...................................... 47 Figura 24 – Semelhança de triângulos retângulos usada na programação .............. 49 Figura 25 – Interpolação Circular Gerada Pela Função ............................................ 52 Figura 26 – Programação C.N.C. .............................................................................. 53 Figura 27 - Medida Padrão para Calibração.............................................................. 54 Figura 28 – Validação da Calibração ........................................................................ 55 Figura 29 – Spindle DC ............................................................................................. 56 Figura 30 – Fresa com Ponta V................................................................................. 56 Figura 31 – Quadrado Engravado na Madeira .......................................................... 57 Figura 32 – Execução de Diversos Comandos em Código G ................................... 58 Figura 33 – Tela do Serial Monitor do Arduino IDE ................................................... 59 Figura 34 – Erro de Processamento na Função de interpolação .............................. 60 Figura 35 – Gráfico dos Dados Extraídos ................................................................. 62 Figura 36 – Protótipo Mecânico da Router ................................................................ 63

LISTA DE TABELAS

Tabela 1 – Códigos G Executáveis pelo Sistema de Automação.............................. 39 Tabela 2 – ASCII ....................................................................................................... 41

LISTA DE QUADROS

Quadro 1 – Código em C de Retorno da Ferramenta a Posição Zero ...................... 32 Quadro 2 – Linha de Programação de Interrupção no Arduino ................................. 33 Quadro 3 – Exemplo de Função de Comunicação Serial .......................................... 40 Quadro 4 – Função de Acionamento de Um Passo .................................................. 42 Quadro 5 – Exemplo de Configuração da Velocidade do Motor ............................... 43 Quadro 6 – Função de interpolação de linha utilizando algoritmo de Bresenham ... 44 Quadro 7 – Divisão da Reta em Segmentos na Função Linha.................................. 46 Quadro 8 – Função de Interpolação de Arcos ........................................................... 48 Quadro 9 – Cálculo dos Ângulos e Comprimento do Arco ........................................ 50 Quadro 10 – Execução da Interpolação na Função .................................................. 51 Quadro 11 – Configuração da Escala da Máquina .................................................... 54 Quadro 12 – Linha de Programação em Código G do Quadrado ............................. 57 Quadro 13 – Dados extraídos da Função de interpolação ........................................ 61 Quadro 14 – Programa de Processamento de Dados no MATLAB .......................... 61

LISTA DE SIGLAS

CNC - Controle Númerico Computadorizado CAM – Computer Aided Manufacturer CAD – Computer Aided Design MATLAB – Matrix Laboratory IDE – Integrated Development Environment

SUMÁRIO 1 INTRODUÇÃO ....................................................................................................... 14 1.1 Objetivo Principal ............................................................................................... 14 1.2 Objetivos Secundários........................................................................................ 14 2 REFERENCIAL TEÓRICO ..................................................................................... 15 2.1 História do CNC .................................................................................................. 15 2.2 Definições de sistemas CAD, CAM e CNC ......................................................... 15 2.3 Dificuldade de Integração de Sistemas ............................................................... 16 2.4 Objetivos do trabalho a ser desenvolvido ........................................................... 17 2.5 Hipóteses de Desenvolvimento ........................................................................... 17 2.6 Controle .............................................................................................................. 20 2.7 Interpolação Linear ............................................................................................. 21 2.8 Algoritmo de Bresenham..................................................................................... 22 2.9 Motor de Passo ................................................................................................... 23 2.10 Motor de Passo de Relutância Variável ............................................................ 24 2.11 Imãs Permanentes ............................................................................................ 25 2.12 Motor de Passo Híbrido .................................................................................... 26 3 MATERIAIS E METÓDOS .................................................................................... 27 3.1 Arduino................................................................................................................ 28 3.2 Arduino e MATLAB ............................................................................................. 29 3.3 Elementos Construtivos ...................................................................................... 30 4 PROCEDIMENTO METODOLÓGICO .................................................................. 36 4.1 Modelagem do Programa.................................................................................... 38 4.2 Leitura de Dados ................................................................................................. 39 4.3 Acionamento dos Motores de Passo .................................................................. 42 4.4 Movimento Interpolado em Retas ....................................................................... 44 4.5 Movimento Interpolado em Arco Circular ............................................................ 47 5 APLICAÇÃO E RESULTADOS ............................................................................. 52 5.1 Aplicação de Procedimentos de Testes .............................................................. 53 5.2 Calibração do Movimento Linear ao Longo do eixo ............................................ 53 5.3 Teste Inicial ......................................................................................................... 55 5.4 Validação das Funções de Interpolação ............................................................. 58 5.5 Integração de Sistemas para correção de Erros ................................................. 59

5.6 Aspectos Gerais sobre a Validação dos Resultados .......................................... 62 6 COMENTÁRIOS FINAIS ....................................................................................... 63 6.1 Conclusão ........................................................................................................... 64 6.2 Sugestões e Trabalhos Futuros .......................................................................... 65 REFERÊNCIAS ......................................................................................................... 66 APÊNDICE A – FIRMWARE DE CONTROLE PRINCIPAL....................................... 68 ANEXO A – DATASHEETS DE COMPONENTES.................................................... 91

14 1 INTRODUÇÃO

Na Indústria moderna, o desenvolvimento de produtos envolve uma concepção de metodologia de trabalho influenciada pelas ferramentas utilizadas.

Isso ocorre porque a utilização de computadores, por exemplo, como meio de expressão, geração e manipulação da informação é imprescindível para deter o domínio das ferramentas/sistemas, gerando, por fim, produtos que cumprem as expectativas. Dessa forma, na área desenho e manufatura assistido por computador, evidencia-se a necessidade de um modelo de trabalho que obedeça a um fluxo de trabalho corporativo, integrado, concorrente e globalizado na integração de sistemas computacionais de auxilio à engenharia.

1.1 Objetivo Principal

O objetivo principal deste trabalho é desenvolver e validar um sistema de controle para uma máquina ferramenta de usinagem genérica como solução de baixo custo para aplicações em materiais leves. Esse sistema será constituído de um software principal responsável pela interpretação dos comandos de um controle numérico, e por um hardware base, constituído por placa de desenvolvimento Arduino Uno que controlará o posicionamento de três motores de passo.

1.2 Objetivos Secundários

Paralelo à implantação do sistema de controle, será desenvolvida uma plataforma base, que será utilizada como modelo de uma máquina com três eixos orientados por coordenadas cartesianas. Esse protótipo precisará de um controle preciso e confiável, devido à acurácia necessária para usinar uma peça mecânica de qualidade.

Como modelo didático, e para fins de validação de projeto, serão implementadas as principais rotinas utilizadas no processamento do “código G” de máquinas comerciais.

O protótipo resultante será testado na construção de peças reais.

15 2 REFERENCIAL TEÓRICO

Para entender melhor o quadro atual dos sistemas computacionais que servem de auxílio à engenharia é sempre importante descrever a evolução histórica dos mesmos. Enfim, essa evolução está ligada à evolução do uso de computadores para controle numérico e de design.

2.1 História do CNC

Em meados de 1950 havia uma crescente necessidade de aplicar o computador para controle de máquinas indústrias, porém na época os computadores era um hardware muito restrito a grandes corporações de nível econômico altíssimo.

Dessa forma, iniciou-se a pesquisa pelo comando numérico de máquinas industriais nos Estados unidos especificamente no Instituto de tecnologia de Massachussets com patrocínio da empresa “Parson Corporation” e da Força Área dos Estados Unidos segundo autor SMID (1999).

Em meados de 1956 a força Norte-Americana começou utilizar oficinas de máquinas de código numérico com as ideias da “Parson Corporation”, as quais utilizavam fitas magnéticas para o os comandos de entrada de dados. Essas máquinas não apresentavam uma significativa confiabilidade nas aplicações na época, porque os custos eram altos e a experiência com a tecnologia era pequena.

Sendo assim, somente em na década de 60 a indústria metalúrgica começou desenvolver máquinas projetadas para receberem o código numérico dando início a uma viabilidade econômica melhor, pois aumentou a variedade de aplicações para o comando numérico.

2.2 Definições de sistemas CAD, CAM e CNC

A automação fabril de um produto inicia-se então nas máquinas indústrias que utilizam um comando numérico computadorizado, as quais são comandadas automaticamente por um programa de controle numérico, mais conhecido como programa CNC. Tal código envolve procedimentos de movimentação, frequência de rotação e acionamentos de mecanismos da máquina durante a fabricação do produto.

16 O projeto de um produto auxiliado pelo computador (CAD) permite representar, analisar e modificar um projeto de engenharia para reunir o máximo de informações possíveis sobre detalhamento do produto. Concomitante a isso a manufatura assistida por computador (CAM) utiliza-se dos modelos desenvolvidos nos sistemas CAD para realizar a automação programável das máquinas industriais dotadas de comando numérico. Sendo assim, surge um sistema de controle numérico que determina as operações de ferramentas de máquinas por meio de instruções de códigos específicos.

Os centros de usinagem CNC, por exemplo, utilizam operações de corte, furação e fresamento para fabricação de uma peça mecânica. Logo, precisa-se de instruções para operar numa determinada rotação da ferramenta para realizar essas tarefas. Após isso ela ira realizar movimento em coordenadas cartesianas para realizar o processo de usinagem. Contudo, toda essa metodologia de trabalho é descrita no código C.N enviado a máquina, é calculada pelo sistema CAM, que é responsável por definir as trajetórias da ferramenta de trabalho.

A programação C.N utilizando softwares CAM necessita do desenho geométrico da peça a ser fabricada e desenvolvida pelo sistema CAD. Paralelamente as formas geométricas descritas num desenho bidimensional ou tridimensional servirão de modelo para traçar no software a trajetória da ferramenta num processo de corte conforme figura 1 a seguir, por exemplo.

Figura 1 – Exemplo de Processo de Corte

Fonte: SABER, 2005

2.3 Dificuldade de Integração de Sistemas

O controle automático de máquinas industriais está entre uma das necessidades mais básicas das indústrias. Paralelamente, a demanda por aplicações com melhor custo-benefício é crescente porque há uma dificuldade

17 crescente por parte da indústria em obterá maximização dos lucros na área de automação industrial. Quando essa dificuldade é alinhada à necessidade do desenvolvimento de um produto com razoável qualidade, acaba surgindo a necessidade de investir consideravelmente em hardware específico, principalmente no que diz respeito à programação de um controle preciso de máquinas industriais.

Dessa forma, projetos de máquinas industriais que utilizam microcontroladores de 8 a 16 bits são opções para a redução de custos, porém devido à limitação de processamento desses chips são poucos os desenvolvedores que investem nesse tipo de aplicação. Ao encontro deste problema, a plataforma de prototipagem com Arduino, em linguagem C, proporciona desenvolver um ambiente de controle automático de máquinas, tornando mais eficaz a gestão dos custos quanto à instrumentação do projeto.

2.4 Premissas do trabalho a ser desenvolvido Nessa realidade atual estará sendo desenvolvido um controle automático de uma máquina ferramenta de usinagem de materiais leves. Isso utilizando controle numérico executado por placa de desenvolvimento Arduino Uno que controlará o posicionamento em três motores de passo. Paralelamente, será utilizado como aplicação um protótipo de dessa máquina com três eixos orientados por coordenadas cartesianas geradas pelo processamento de um código G. Sendo assim, esse protótipo precisa de um controle preciso e confiável devido à acurácia necessária para usinar uma peça mecânica de qualidade.

2.5 Hipóteses de Desenvolvimento O controle de três eixos de máquinas industriais CNC normalmente é feito em malha aberta, com motores de passo e chaves de fins de curso, para reduzir os custos com a instrumentação do projeto. Ocorrem, porém, perdas de qualidade e de precisão durante a fabricação de peças mecânicas devido à confiabilidade baixa existente no controle em malha aberta. Logo, plataformas de prototipagem flexíveis como as dos microprocessadores Arduino, permitem desenvolver uma engenharia eletrônica de baixo custo, com consideráveis quantidades de recursos de programação

computacional,

acarretando

o

desenvolvimento

de

máquinas

18 automáticas progressivamente mais confiáveis. Entretanto, a prototipagem com Arduino é uma tecnologia que foi criada para o desenvolvimento de atividades didáticas dentro das universidades. Isso ocorre entre áreas exatas, tendo pouco credenciamento no meio profissional, o que desperta nesse trabalho a utilização do software MATLAB para desenvolver um sistema genérico de controle de três eixos, com a finalidade de atingir um nível razoável de programação industrial para a plataforma de prototipagem com Arduino.

Tais plataformas foram escolhidas, porque, levando em conta uma pesquisa da fonte FABRICANTE (2013), a principal meta das empresas fabricantes de máquinas ferramentas e dispositivos especiais e melhorar a qualidade de seus processos. Uma forma de obter isso é através da utilização máquinas CNC para melhorar a confiabilidade do processo de fabricação de uma peça. Conforme figura 2 a seguir pode observar-se que a maior parte (78%) dos serviços são realizados com ferramentas tipo CNC. Contudo, a escolha e ambientes de prototipagem e simulação são um excelente suporte na obtenção dessas metas.

Figura 2 – Pesquisa de Preferência de Controle de Máquinas Ferramentas

Fonte: FABRICANTE, 2013

A escolha do tipo da máquina ferramenta para o projeto também foi levando em conta essa pesquisa da Revista Máquinas e Metais, porque a pesquisa informou o tipo de dispositivo especial mais procurado pelas empresas para melhorar a qualidade de seu processo conforme apresentado na figura 3 a seguir.

19 Figura 3 – Pesquisa de Tipos de Máquinas Ferramentas Utilizadas

Fonte: FABRICANTE, 2013

É importante ressaltar que o acionamento de motores de passo é discreto e a linguagem C incrementa passos com variáveis inteiras, ou seja, apenas realiza-se movimento em linhas verticais ou horizontais, porque no microcontrolador as instruções são executas em cascata, ou seja, duas funções não são executadas exatamente ao mesmo tempo. Sendo assim, a realização de um movimento linear ao ponto cartesiano de duas dimensões necessita que os motores precisos que executem movimentos simultâneos para atingir certa precisão. Uma forma de realizar esse acionamento é através da interpolação linear onde os passos em cada motor serão executados em sequência

em pequenos incrementos, onde a alta

velocidade de processamento do microprocessador resulta num movimento aproximado de um linha inclinada, pois as linhas horizontais e verticais dos movimentos de cada motor são tão ínfimos que tornam-se suaves ao olho humano.

Um dos objetivos principais desse trabalho é desenvolver um programa que realiza um movimento linear até um ponto de coordenadas x e y com motor de passo, realizando incrementos em variáveis inteiras. Dessa maneira, dois eixos da máquina ferramenta se movimentem simultaneamente formando uma linha reta.

20 2.6 Controle

As malhas de controle de sistemas de posicionamento no acionamento de motores CC são amplamente utilizadas em projetos de centros de usinagem na indústria metal mecânica e também em vários processos de manufaturas de peças mecânicas. Sendo assim, a necessidade da modelagem de malhas cada vez mais precisa é continuamente crescente, acarretando uma elevação nos custos de projetos para atingir o nível necessário de processamento desses sistemas robustos.

As técnicas de controle utilizadas nesse trabalho têm como função desenvolver um modelo compacto de controle dos eixos tridimensionais (x, y e z) de uma ferramenta de uma máquina de usinagem, a fim de reduzir a robustez do hardware. Essa projeção é necessária para implantar a malha de controle em uma simulação mais próxima possível da realidade. Um meio para executar essa simulação é o uso de softwares específicos, resultando na realização de uma prototipagem eletrônica com plataformas específicas de desenvolvimento.

Dessa maneira será descrito brevemente o conhecimento teórico envolvido em todos os componentes necessários para modelar essa malha de controle, começando com o funcionamento dos motores de passo e seguindo com seu acionamento por uma malha de controle. Serão utilizados, nesse caso, Drivers para modular o sinal de saída do microcontrolador e dos sensores de corrente e de posição, com a finalidade de realizar as medições corretas no sistema.

21

Figura 4 – Exemplo de Controle em Um Eixo

Fonte: SANTANA.; SILVA.; OLIVEIRA, 2008.

Na figura 4 é um exemplo de aplicação de controle de posicionamento em malha fechada. Nele existe um servo motor que pelo controle de seu deslocamento angular do eixos é possível executar um movimento preciso de um mesa com um massa qualquer, por causa da leitura de posicionamento de um encoder óptico incremental numa das extremidades do fuso. Todos os sinais desse hardware são processados por uma unidade de acionamento e controle que será o componente principal de desenvolvimento desse trabalho de conclusão.

2.7 Interpolação Linear A operação de dois motores de passo movimentar uma ferramenta no plano x e y em linha reta necessita um algoritmo de processamento, no qual a partir de um ponto cartesiano e a inclinação da reta a ser traçada realize interações com os passos dos motores. Segundo LAMOTHE (1995), uma forma matemática de realizar essas interações é com interpolações aritméticas com variáveis inteiras seguindo a fórmula de declividade de uma reta dado pela razão de distâncias entre os pontos de cada eixo no plano bidimensional:

1

22

Onde „‟M‟‟ é a inclinação da reta é também pode ser definida como a derivada da função de reta que defini os pontos cartesianos num plano 2D,

o ponto final e

é o ponto inicial:

2

2.8 Algoritmo de Bresenham

Como apresentado na figura 5, num plano bidimensional ao desenhar um gráfico veremos que precisa-se desenvolver um algoritmo que incremente cada passo para realização correta do traçado que acompanhe a inclinação da reta.

Figura 5 – Gráfico da Equação Geral de uma Reta

O método de dimensionar essa inclinação inicia-se utilizando a equação da reta como função:

3 Nessa função a inclinação “m” seria a taxa de variação das coordenadas y e x dados pela seguinte razão:

4

23 Ressalta-se que o acionamento de motor de passos pelo uso de plataformas eletrônicas, tem-se movimentos apenas em linhas horizontais e verticais. Dessa forma o algoritmo de Bresenham (1965) define que a reta deve ser divida em segmentos com projeções em linhas verticais e horizontais. Portanto, esses segmentos serão as projeções das variações das coordenadas x e y dadas pela seguinte equação, a qual calcula o comprimento dessas projeções da figura 5:

5

Transformando essa igualdade numa função semelhante a equação 5 teremos:

6

Assim, é possível realizar incrementos ínfimos no traçado de uma um reta pelo uso da equação 6. Isso permite na programação em linguagem de máquina trabalhar com duas variáveis em milímetros num quadrante bidimensional para realizar movimentos lineares em motores de passo aproximando as projeções em linhas verticais e horizontais conforme exemplo da figura 5.

2.9 Motor de Passo Entre os diversos tipos de motor de corrente continua usado para controle de posicionamento, destaca-se o motor de passo, porque ele é um atuador eletromecânico incremental não linear que permite um controle preciso de posição e velocidade aliado a um baixo custo segundo CAO (1999). Essa propriedade de fazer movimentos incrementais precisos em malha aberta diferencia esse motor dos demais motores elétricos.

Esse motor é do tipo com estator é constituído de um enrolamento de campo ou de imãs permanentes segundo FITZGERALD, JUNIOR E UMANS (2006), os quais devem fornecer ao rotor um campo magnético quando aplicado uma corrente no enrolamento ocorrendo movimentação do rotor o qual possui um circuito de armadura segundo também OLIVEIRA, AGUIAR E VARGAS (2005).Dessa maneira,

24 os diversos tipos de motores CC têm sua utilidade na aplicação de posicionamento, porque suas características construtivas são básicas, ou seja, constituídas pelo estator e rotor, facilitando a modelagem de sua malha de controle

2.10 Motor de Passo de Relutância Variável

Esse tipo de motor de passo é mais comum onde cada par de dentes do estator, conforme figura 6 abaixo, está ligado na mesma fase, sendo que o rotor possui quatro dentes. Quando uma corrente é aplicada em uma das fases (Ph1), um campo magnético surge e um dente do rotor alinha-se a esse campo. Dessa forma, no alinhamento do rotor com o campo, a relutância magnética é minimizada, logo, no desalinhamento do campo magnético, um torque é gerado no sentido de retornar à posição de equilíbrio.

Figura 6 – Motor de Passo de Relutância Variável

Fonte: KENJO.; SUGAWARA, 2003

25 Figura 7 – Motor de Passo RV

Fonte: KENJO.; SUGAWARA, 2003

2.11 Imãs Permanentes

Esse motor possui um imã permanente no rotor e o estator possui dentes envoltos por bobinas conforme figura 8. Na energização de uma das fases cria-se um campo magnético com polo oposto ao do imã, ocorrendo atração.

Figura 8 – Motor de Paso de Imãs Permanentes

Fonte: KENJO.; SUGAWARA, 2003

26

2.12 Motor de Passo Híbrido Esse motor também possui um imã permanente em seu rotor, mas ele pode funcionar tanto como um motor de relutância variável como um de imã permanente.

Isso ocorre porque seu estator é semelhante ao motor de relutância variável, mas os enrolamentos e as bobinas são conectados de forma diferente, ou seja, somente uma das duas bobinas de cada fase está em cada polo. Paralelamente, duas fases diferentes, estando no mesmo polo, geram polaridades magnéticas diferentes quando excitadas, conforme figura 9.

Figura 9 – Motor de Passo Híbrido

Fonte: KENJO.; SUGAWARA, 2003

Em projetos de máquina ferramenta, o modelo mais utilizado é o motor de passo híbrido. Essa preferência ocorre porque uma modelagem mais precisa dos motores de passo exige um modelo de elementos finitos tridimensional no seu interior segundo OSWALD (2009). Isso usado pelos fabricantes para simplificar o modelo num circuito equivalente linear segundo CAO (1999).

27

3 MATERIAIS E METÓDOS A partir do modelo de controle apresentado na figura 10 a seguir de posicionamento de um eixo através de um motor de passo híbrido é necessário desenvolver três modelos semelhantes em paralelo para controlar uma máquina Router CNC. Um modelo concreto para isso é apresentado na figura 11 a seguir.

Essa escolha ocorreu porque conforme pesquisa da figura 3 os dispositivos de fresamento é a segunda opção mais utilizada pela indústria. Portanto é uma máquina adequada para desenvolver um controle automático com a plataforma Arduino, porque uma Router de fresamento pequena é também uma máquina de baixo custo para fins didáticos.

Figura 10 – Malha de Controle Típica de Motor de Passo

Fonte: CARDOZO, 2012

Figura 11 – Protótipo de Router CNC de 3 Eixos

28

De modo geral, Routers CNC são fabricadas em vários tamanhos e formas, dependendo do que ela irá produzir ela terá uma relação direta com seus motores e elementos mecânicos que compõem sua estrutura física segundo OVERBY (2011).

Paralelamente, o termo “Router” é geralmente usado para vários tipos de aplicações, mas normalmente significa uma máquina com processo rotário, para cortar e engravar formas e figuras em matérias como metais, plásticos e madeira. Dessa forma, utiliza-se o controle numérico computacional para se obter uma melhor precisão e eficiência na produção industrial de peças e formas mecânicas. As máquinas Routers CNC geralmente são compostas de uma mesa cartesiana onde situa a área de trabalho, guias lineares para determinar quantos eixos a malha de controle irá possuir e motores CC para posicionamento e conformação do material.

Sendo assim, utilizando-se da plataforma de prototipagem com Arduino será dimensionada a eletrônica de acionamento dos motores a partir da modelagem mecânica do sistema em MATLAB e em seguida a partir de um modelo mecânico de máquina CNC, dimensionada no software CAD Autodesk Inventor, será aplicado o modelo de controle desenvolvido.

3.1 Arduino Arduino é uma plataforma computacional em “opensource”, baseada numa placa eletrônica de desenvolvimento com entradas e saídas (I/O) que implanta processamento similares à linguagem C (programing) segundo BANZI (2008). Esse hardware

livre

foi

projetado

com

um

microcontrolador

Atmel

AVR

para

desenvolvimento de projetos interativos e independentes com um computador hospedeiro.

29 Figura 12 – Arduino Uno

Esse hardware é em geral para desenvolvimento didático. Isso facilita a implantação de controle interativo devido à compatibilidade com outras plataformas computacionais de estudo, como a do MATLAB da empresa MathWorks. Por isso este foi escolhido para desenvolver a robótica de uma máquina CNC de três eixos, interagindo com o modelo de controle do MATLAB, executando esse processo num hardware físico como o da figura 11.

3.2 Arduino e MATLAB

MATLAB (Versão de Estudante) fornece um pacote de suporte que facilita o uso do ambiente de simulação matemática de posicionamento no espaço, possibilitando comunicar-se com uma placa de programação Arduino pelo cabo USB de um computador. Essa comunicação, como apresentada na figura 13, é simultânea com o hardware de acionamento eletrônico.

Essa ferramenta de simulação, aliada com o teste prático resultará na elaboração de um projeto de controle mais confiável e preciso. Isso ocorre porque a abordagem mais profunda dos parâmetros físicos do modelo dos motores, mais as variáveis de controle que o processador terá que controlar, permite-se uma flexibilidade e agilidade maior na tomada de decisão, principalmente no que diz respeito ao escopo do projeto do modelo geral de controle três eixos de uma máquina CNC.

30 Figura 13 – Arduino + MATLAB

3.3 Elementos Construtivos

O projeto mecânico elaborado ilustrado na figura 11 permitiu construir um protótipo de Router de 3 eixos inicialmente sem controle eletrônico de acionamento.

A partir disso, os componentes selecionados e dimensionados para o projeto foram determinados para usinar materiais leves e trabalhar numa área de trabalho de útil 180x180mm. Abaixo na figura 14 está um resumo dos materiais aplicados nesse projeto para realizar os testes da eletrônica de acionamento.

31 Figura 14 – Lista de Materiais

A unidade de controle para acionar o protótipo mecânico foi construída seguindo esquema da figura 18. Dessa Forma a unidade composta da placa Arduino UNO que se comunica com um computador para acionar 3 drivers de potências TB6560 conforme ilustra na figura 17. Concomitante, A unidade utilizou como sensores de fim de curso chaves óticas para identificar a posição do zero da máquina, construídos conforme esquema da figura 15, e também chaves alavanca NA/NF comuns, ilustrados na figura 16, para identifica a posição dos limites máximos.

Figura 15 – Chaves Óticas

32 Essa chave ótica opera enviando um sinal de 5 volts a uma entrada digital da placa Arduino UNO, quando algum objeto passa entre o LED e o foto transistor conforme ilustra a figura 15 acima. A leitura desse sinal foi escolhido para ser analógica de 0 a 8 bits convertido para um valor decimal entre 0 a 1024 armazenado numa variável inteira (quadro 1). Assim, esse intervalo permitiu uma precisão maior no posicionamento do zero de referência da ferramenta da Router.

Quadro 1 – Código em C de Retorno da Ferramenta a Posição Zero void hithome(){ int x0 = analogRead(XZERO); int y0 = analogRead(YZERO); int z0 = analogRead(ZZERO); fim = digitalRead(stope); while((x0>40)||(y0>40)||(z0>50)){ if(stope==LOW) {para();} if (x0>40) { digitalWrite(ENABLEX_PIN, LOW); } if (y0>40) { digitalWrite(ENABLEY_PIN, LOW); } if (z0>50) { digitalWrite(ENABLEZ_PIN, LOW); } x0 = analogRead(XZERO); y0 = analogRead(YZERO); z0 = analogRead(ZZERO); } }

33 As chaves alavancas (figura 16) posicionadas nos limites máximos de cada eixo permitiram uma maior segurança na usinagem de uma peça, caso alguma deslocamento de algum eixo ultrapasse da área de trabalho e danificasse a estrutura da Router. A lógica de controle escolhida para essas chaves foi linguagem interrupção de processamento, porque o número de portas na placa Arduino já estava limitada pelo uso do Driver de potência, logo a interrupção necessita apenas de uma porta comum para as três chaves (quadro 2).

Quadro 2 – Linha de Programação de Interrupção no Arduino void setup() { //attachInterrupt(0, emergencia, FALLING); } void emergencia() { digitalWrite(ENABLEX_PIN, LOW); // DESabilita eixo X digitalWrite(ENABLEY_PIN, LOW); // DESabilita eixo Y digitalWrite(ENABLEZ_PIN, LOW); // DESAabilita eixo Z digitalWrite(SPINDLE, LOW); Serial.println("Opa Fim de Curso"); detachInterrupt(2); }

Figura 16 – Chaves Alavancas

34 A unidade de controle foi construída seguindo o esquema da Figura 18 e o datasheet do fabricante do driver (Anexo A). Tudo isso energizado com um fonte chaveada de 300 Watts (figura 18) com saída 24 volts. É importante ressaltar que foi necessário aterrar o GND da placa Arduino e do Driver TB6560 na fonte para evitar ruído no acionamento dos motores, porque apenas o toque da mão em algum contato da eletrônica de acionamento movia os motores de passo durante seu acionamento inicial.

Figura 17 – Unidade de Controle

A placa principal, que é responsável pelo sistema de automação, é controlada pelo Arduino Uno. Essa placa controla o acionamento mecânico por interpolações lineares da Router através de três drivers de potência TB6560 para motor de passo (Anexo A consta Datasheet), conforme é ilustrado no diagrama elétrico do projeto da figura 18 abaixo.

35

Figura 18 – Diagrama ElÊtrico da Unidade de Controle

36 4 PROCEDIMENTO METODOLÓGICO

Inicialmente foi necessário descrever o comportamento eletromecânico do sistema de automação da Router CNC projetada nesse trabalho. Dessa forma, desenvolveu-se o diagrama de fluxo de processos (figura 19) do projeto da Router CNC, conforme norma NBR8190 (1983) para simbologia de instrumentos. Esse diagrama mostra a visão geral dos instrumentos e motores necessários controlados pelo software desenvolvido. Paralelamente, o diagrama da figura 19 tem como objetivo servir como base teórica para a programação em linguagem C, porque o controle dessa instrumentação tem como função fornecer a posição de referência da máquina.

Figura 19 – Diagrama de Fluxo de Processos

37 Aliado a essa instrumentação desenvolveu-se o comportamento contextual do programa, o qual é descrito pela metodologia de diagramas de sistemas dos autores WARD e MELLOR (1985). Assim, a lógica de posicionamento de coordenadas cartesianas desenvolvida é descrita no diagrama da figura 20 a seguir, a qual ilustra o fluxo de informações do programa. Esse diagrama de contexto é um detalhamento dos passos executados pelo programa semelhantes ao modelo de controle da figura 10.

Figura 20 – Diagrama de Contexto

O sistema de automação da Router CNC descritos nesse contexto foi estruturado pela a lógica de transformações da informação descritas pelo diagrama na figura 21. Esse diagrama de transformações detalha melhor as tomadas de decisões que o programa precisa executar no controle de posicionamento. O diagrama de transformações representa, também, o comportamento dos sinais de comando elétricos pela instrumentação da figura 19. Tudo isso obedecendo à lógica de controle da do diagrama de contexto. Contudo, ressalta-se que todos esses diagramas são um detalhamento do modelo de malha de controle da figura 10.

38

Figura 21 – Diagrama de Transformações

A topologia final do sistema automático utilizou-se do hardware ilustrado na figura 11 para executar todas as funções detalhadas nos diagramas de contexto e transformações das figuras 20 e 21. Entretanto, a prototipação do sistema de automação e controle de posicionamento utilizou-se de comandos enviados por uma comunicação serial de um computador ao inves de receber infromações por uma IHM usada por um operador. Destaca-se que está sendo utilizado a plataforma MATLAB para interpretar os dados processados pela unidade central para validar as funções do software em linguagem C.

4.1 Modelagem do Programa O software de controle no Arduino precisa interpretar linhas de comando em código G segundo padrão ISO 1056. Assim, foi escolhida uma lista de comandos ilustrados na tabela 1, como referência no desenvolvimento do programa. A partir disso o programa recebe dados pela comunicação serial e executa instruções de interpolação de linhas para usinar a peça desejada no material escolhido.

39 Tabela 1 – Códigos G Executáveis pelo Sistema de Automação Comando

Descrição

G00

Posicionamento Rápido

G01

Movimento com Interpolação Linear

G02

Movimento em Arco horário

G03

Movimento em Arco Anti-horáio

G28

Movimento ao zero da Máquina

G54

Modo Manual

G90

Modo Absoluto

G91

Modo Relativo

G92

Muda posição lógica atual

M3

Habilita Ferramenta

M5

Desabilita Ferramenta

M17

Habilita Motores de Passo

M18

Desabilita Motores de passo

M100

Mostra Ajuda

M114

Mostra Posição Lógica

4.2 Leitura de Dados

O programa precisa reconhecer letras e números para diferenciar as instruções em código G usando linhas de programação em linguagem C. Dessa forma, no “loop” principal do programa é feito a leitura serial de uma mensagem, conforme ilustra o exemplo do código do quadro 1 abaixo. Nesse “loop” a letra “a” e enviada ao pressionar o teclado durante a comunicação com a placa Arduino Uno e o programa interpreta a mensagem conforma a tabela 2. Nessa tabela cada caractere é atribuído um valor decimal que o diferencia, ou seja, a letra “a” possui o valor decimal 92 na tabela 2. Sendo assim, esse valor é armazenado na memória do microcontrolador para ser possível realizar operações de acionamento com linguagem C, como, por exemplo, o comando “SWITCH” do quadro 3, no qual ao receber na leitura serial o valor 92 no caso da letra „‟a‟‟ é realizado uma operação de ligar um LED.

40 Quadro 3 – Exemplo de Função de Comunicação Serial void setup() { // inicializa comunicação serial: Serial.begin(9600); // escolha dos pinos: for (intthisPin = 2; thisPin< 7; thisPin++) { pinMode(thisPin, OUTPUT); } } void loop() { // lê a porta serial if (Serial.available() > 0) { intinByte = Serial.read(); // através da tabela ASCII ele a ira ler uma palavra enviada // pelo serial monitor e acionara uma condição do comando switch (inByte) { case 'a':

// tecla da letra a no teclado

digitalWrite(2, HIGH); // liga led break;

Portanto, o código desenvolvido no projeto da máquina ferramenta (Apêndice A), também, foi utilizado variáveis inteiras para discretizar os dados e armazená-los na memória do microcontrolador como exemplo do quadro 3. Isso porque a função de processar o código G enviado pelo computador precisa armazenar a informação completa antes de iniciar o processamento dos dados.

41 Tabela 2 – ASCII Binário Decimal Hexa Glifo 0110 0000 96 60 ` 0110 0001 97 61 a 0110 0010 98 62 b 0110 0011 99 63 c 0110 0100 100 64 d 0110 0101 101 65 e 0110 0110 102 66 f 0110 0111 103 67 g 0110 1000 104 68 h 0110 1001 105 69 i 0110 1010 106 6A j 0110 1011 107 6B k 0110 1100 108 6C l 0110 1101 109 6D m 0110 1110 110 6E n 0110 1111 111 6F o 0111 0000 112 70 p 0111 0001 113 71 q 0111 0010 114 72 r 0111 0011 115 73 s 0111 0100 116 74 t 0111 0101 117 75 u 0111 0110 118 76 v 0111 0111 119 77 w 0111 1000 120 78 x 0111 1001 121 79 y 0111 1010 122 7A z 0111 1011 123 7B { 0111 1100 124 7C | 0111 1101 125 7D } 0111 1110 126 7E ~

42 4.3 Acionamento dos Motores de Passo Conforme descrito anteriormente os motores de passo são motores CC de acionamento discreto, logo para gerar a sequência de passos é preciso utilizar um função básica de linguagem C que gera um passo quando executada como exemplo do código do quadro 4.

Quadro 4 – Função de Acionamento de Um Passo Void rotacionax() {

// 66 passos equivale a 1mm na minha máquina

digitalWrite(STEPX_PIN, LOW); delayMicroseconds(300); digitalWrite(STEPX_PIN, HIGH); delayMicroseconds(300); }

No código do quadro 4 é gerado uma onda quadrática discreta de valores de tensão alta e baixa com uma atraso em microssegundos entre cada valor. O valor desse atraso tem como objetivo evitar um acionamento muito rápido das bobinas do motor de passo para não haver „‟stall‟‟ no eixo do motor, ou seja, deslocamentos imprecisos. A fim de determinar a dimensão do atraso do passo pode-se seguir o “datasheet” do fabricante (Anexo A) e escolher o valor mínimo de atraso entre os passos. Ressalta-se, o driver TB6560 de motor de passo também permite selecionar a configuração de micro passo para aplicação em pequenas chaves (Anexo A consta datasheet), a qual nesse projeto foi utilizada um micro passo de 16 vezes menor que o passo mínimo de 1,8° do motor NEMA 23.

O atraso de cada passo do motor é atribuído uma variável flutuante de programação, porque valores diferentes de atraso entre cada passo funcionam indiretamente como velocidades diferentes de deslocamento do eixo do motor (Quadro 5). Dessa maneira, é possível calcular a velocidade de avanço de um eixo e a velocidade de regime durante algum processo de usinagem e inserir os valores calculados nas linhas de programação em código G.

43 Quadro 5 – Exemplo de Configuração da Velocidade do Motor //* CONFIGURE A TAXA de AVANÇO DOS MOTORES //* input nfr A NOVA VELOCIDADE DE PASSOS/SEGUNDO void feedrate(float nfr) { step_delay = 10000/nfr; fr = nfr; }

Havendo a possibilidade de manipular a velocidade do motor em função do tempo é possível, também, determinar a aceleração do motor de passo em cada etapa de usinagem em perfil trapezoidal conforme figura 22. Essas rampas de aceleração e desaceleração são importantes para manter a eficiência sem haver perdas de passo

Figura 22 – Perfil Trapezoidal da Aceleração do Motor de Passo

44 4.4 Movimento Interpolado em Retas Os pontos cartesianos definidos em milímetros, quando enviados ao programa da placa Arduino Uno pela comunicação serial com o computador, precisaram ser processados em deslocamento vetorial convertido em passos de motor. Sendo assim, os cálculos necessários para realizar essa operação serão executados pelo algoritmo de Bresenham (1965).

O método escolhido para programar esse algoritmo em linguagem C foi desenvolver uma função que recebe a próxima posição dos eixos definido em coordenadas cartesianas “newx”, “newy” e “newz” com sinal aritmético. Essas coordenadas permitem calcular distáncia “dx” ou “dy”, por exemplo, entre o ponto de posicionamento inicial (posx, por exemplo) e o ponto final (Quadro 6) da ferramenta da máquina. Paralelamente, o sinal aritmético de cada ponto será armazenado numa variável booleana (dirx, por exemplo) para determinar o sentido correto de rotação do motor de cada eixo.

Quadro 6 – Função de interpolação de linha utilizando algoritmo de Bresenham // SOMENTE VALORES POSITIVOS static void lineABS(double newx, double newy, double newz) { double dx = newx - posx; double dy = newy - posy; double dz = newz - posz; int dirx=dx>0?LOW:HIGH; // define sentido de rotação int diry=dy>0?LOW:HIGH; int dirz=dz>0?1:-1; //eixo invertido long

adx=abs(dx*SCALEMM);

//

converte

de

milimetros

para

passos long ady=abs(dy*SCALEMM); long adz=abs(dz*SCALEZ);

A distância calculada na função do quadro 6 é convertida em passos nas variáveis “adx” e “ady” como apresentado no segmento de código. Após isso a distância é divida em vários segmentos de linhas horizontais e verticais pela linha de

45 programação do quadro 7, os quais representam os passos executados sequencialmente por cada eixo.

A maneira que a interpolação ocorre basicamente no quadro 8 é visando a execução do segmento com maior dimensão, armazenado na variável “over”. Nesse processo de armazenar a variável e realizar uma tomada de decisão, através do comando “IF” após executar um incremento “over+=adx”, é realizado a divisão do comprimento total em pequenos segmentos, pois novamente é executado um decremento na linha de programação (“over-=adx”).

No caso do exemplo de execução do comando de posicionamento rápido no ponto cartesiano [15,20] da figura 23 (gráfico gerado pelo procedimento do subcapítulo 5.5) é possível visualizar todos os segmentos calculados pela função de interpolação linear. Esses segmentos, após serem executados pela função do quadro 7, permitem o movimento em uma linha reta com sua inclinação devida, pois o alta velocidade de processamento do programa simula o movimento simultâneo de dois motores de passo.

Esse método permite que a inclinação da reta da linha de deslocamento seja determinada pela primeira execução do segmento de maior dimensão, porque o eixo com maior dimensão, no caso o eixo y da figura 23, precisa ser o mais rápido e o eixo x com a menor dimensão precisa ser o mais lento. Isso foi definido assim, porque, no exemplo da figura 23, a inclinação da reta dada pela equação 3 é 1/0.75, ou seja, a cada uma unidade de passo do eixo y o eixo x precisa andar 0,75 passo.

Isso ocorre porque o deslocamento ao longo do eixo y tem que ser mais rápido que o eixo x.

46 Quadro 7 – Divisão da Reta em Segmentos na Função Linha long over=0; long kk; // bresenham if(adx>ady) { for(kk=0;kk<adx;++kk) { digitalWrite(DIRX_PIN, dirx); rotacionax(); over+=adx; if(over>=adx) { over-=adx; digitalWrite(DIRY_PIN, diry); rotacionay(); pause(step_delay); hithome();

}

} else { for(kk=0;kk<ady;++kk) { digitalWrite(DIRY_PIN, diry); rotacionay(); over+=adx; if(over>=ady) { over-=ady; digitalWrite(DIRX_PIN, dirx); rotacionax(); pause(step_delay); hithome(); posx+=x; posy+=y; px=0; py=0;}

}

}

47

Figura 23 – Aproximação de Linha por Interpolação Linear

4.5 Movimento Interpolado em Arco Circular O programa de interpretação de código G nesse projeto foi desenvolvido uma função para a ferramenta movimentar-se em arcos de sentido horário ou anti-horário.

O método escolhido foi traçar um arco segmentado em várias retas até ponto de destino num plano bidimensional. Além disso, foi preciso calcular os parâmetros desse arco a partir das informações obtidas pelo comando G02 da tabela 1 seguindo a equação geral do círculo dado por:

7

48 A equação 7 fornece o centro do círculo dados por da ferramenta antes de traçar o arco dados por

e

e a posição atual

e . Sendo assim, a função de

interpolação circular calcula o raio do arco em radianos (Quadro 8) e armazena na variável “radius”. Após esse cálculo usou-se semelhança de triângulos retângulos (figura 24) para determinar o ângulo que define o comprimento desse arco. Isso foi feito determinando que cada segmento do círculo é a hipotenusa de um triângulo retângulo.

Quadro 8 – Função de Interpolação de Arcos // cx/cy - centro do circulo // x/y - posição final //

dir

-

ARC_CW

or

ARC_CCW

determina

direção

circulo static void arca (float x,floaty,floatcx,float cy) { int dir = ARC_CCW; // sentido anti-horário // calcula o raio double dx = posx - cx; double dy = posy - cy; double radius=sqrt(dx*dx+dy*dy);

do

49 Figura 24 – Semelhança de triângulos retângulos usada na programação

Calculando o arco tangente dos triângulos retângulos, é possível encontrar os ângulos “angle1’’ e “angle2”. A diferença desses dois ângulos fornece o ângulo “theta’’ que define o comprimento do arco do círculo”. No quadro 9 o ângulo “theta” está em radianos, logo calcula-se o comprimento em milímetros e armazena o valor na variável “len”.

Sendo assim, os parâmetros do arco são definidos pelo cálculo do raio, do ângulo do arco e seu comprimento na dimensão desejada. Seguindo a função do quadro 10, é necessário dividir o comprimento do arco em vários segmentos de linha para a máquina ferramenta realizar um movimento aproximado de um arco.

50 Quadro 9 – Cálculo dos Ângulos e Comprimento do Arco // encontra arco do raio angle1=atan2(dy,dx); // arco tangente if(angle1<0) angle1=(PI*2.0)+angle1; angle2=atan2(y-cy,x-cx); if(angle2<0) angle2=(PI*2.0)+angle2; theta=angle2-angle1; if(dir>0 && theta<0) angle2+=2*PI; else if(dir<0 && theta>0) angle1+=2*PI; theta=angle2-angle1; // comprimento do arco //float circ=PI*2.0*radius; //float len=theta*circ/(PI*2.0); // simplifica para //if(theta==0) theta=2*PI; double len = abs(theta) * radius; long int k, segments = floor( len / CM_PER_SEGMENT ); // Resolução do Arco

Entretanto, surgi à necessidade de definir uma resolução de quantas linhas possuirão cada arco traçado pela função de interpolação. A fim de ser possível realizar o desenho de arcos de no mínimo de 2 milímetros de raio, definiu-se a resolução como 0,2 centímetros por segmento. Esse valor foi seguidamente inserido no cálculo abaixo:

8

A equação 8 é possível visualizá-la na linha de código do quadro 9 da seguinte forma: “segments = floor( len / CM_PER_SEGMENT )”.Esse valor de segmentos também é a quantidade de interações no laço de programação para traçar as diversas linhas que definem o arco. Na operação de traçar as linhas é também necessário definir o ângulo aproximado de cada segmento (Quadro 10) projetado no arco da seguinte maneira:

51

9

O motivo do cálculo da equação 9 é proporcionar o dimensionamento da inclinação de cada segmento no plano x e y através da aproximação do teorema de Pitágoras em cada triângulo retângulo formado pelo segmento, o qual é semelhante ao da figura 24. A forma de realizar esse laço de programação é armazenar cada ângulo de segmento na variável “somangulo” (quadro 10). Isso aliado ao objetivo de calcular o comprimento de cada segmento dado por: “nx” e “ny”. De tal forma, utilizase o teorema de Pitágoras do triângulo retângulo formado pelo comprimento do segmento (“cos(angle3) * radius”, por exemplo), do círculo até o segmento e o cateto oposto no caso de “ny” ou adjacente no “nx”. Paralelamente, nessa aproximação foram removidos os quadrados das somas, porque foi utilizado micro passos ínfimos nos motores. Isso ocorre porque os ângulos são muito pequenos em cada segmento ocasionado números muito próximos de zero, cujo seu valor ao quadrado não acarreta alterações dimensionais significativas nesse projeto.

Quadro 10 – Execução da Interpolação na Função double difangulo=theta/segments; double nx, ny, angle3, scale; double somangulo=0; for(k=0;k<segments;++k) { // interpolação do arco por retas somangulo+=difangulo; angle3 = ( somangulo) + angle1; nx = cx + cos(angle3) * radius; ny = cy + sin(angle3) * radius; // envia para o plano lineABS(nx,ny,0); // função interpolação de linha } lineABS(x,y,0);}

52 Outra característica dessa função é interromper o movimento circular e iniciar traçando uma linha reta até o ponto final, caso o comprimento do arco não possua nenhum ponto coincidente com ponto final de destino. Esse comportamento é possível visualizar no exemplo da figura 25 a seguir de pontos processados pelo MATLAB com a função exemplificada nos quadro 8, 9 e 10.

5 APLICAÇÃO E RESULTADOS

As funções de interpolação desenvolvidas puderam ser testadas inicialmente no MATLAB para verificar a lógica da programação em linguagem C. Porém, foi necessário realizar pequenos procedimentos, os quais serão descritos a seguir, no protótipo da Router CNC para realmente validar seu funcionamento.

Figura 25 – Interpolação Circular Gerada Pela Função

53 No exemplo da figura 25 (método de gerar o gráfico no sub-capítulo 5.5) foi utilizado o comando “G02 X70 Y70 J30 I30”, onde o centro do arco não definia um circulo com comprimento até o ponto final, logo foi traçado uma linha para completar o movimento interpolado.

5.1 Aplicação de Procedimentos de Testes

O processo de fabricação de peça normalmente obedece a um padrão especificado nas informações contidas do desenho assistido por computador dessa peça produto. Algumas delas serão descritas abaixo, a fim de aplicar o mesmo procedimento de teste do Protótipo da Router CNC de 3 eixos desenvolvido: 1. Exemplo de programação C.N via software CAM usando como base a geometria da Peça (figura 26).

Figura 26 – Programação C.N.C.

Fonte: SABER, 2005

5.2 Calibração do Movimento Linear ao Longo do eixo

O código desenvolvido para controlar os três eixos da máquina necessitou dimensionar alguns parâmetros físicos inerentes à estrutura física da máquina. O principal parâmetro foi a escala de deslocamento dos fusos. Isso é necessário para definir quantos passos são necessários para mover a máquina ferramenta em um milímetro.

O método utilizado foi medir uma distância inicial com paquímetro de uma das extremidades da máquina (figura 27), após isso se envia um comando de um número alto de passos para máquina para ocorrer um deslocamento em um eixo.

Seguidamente, mede-se novamente, conforme a figura 27, a distância em relação a

54 base lateral da máquina. Dessa forma, obtém dois valores inicial e final, logo obtémse a escala da máquina usando a seguinte equação:

10

Esse resultado da equação será inserido na linha de código de “setup” da máquina ao iniciar a unidade de controle (quadro 11).

Quadro 11 – Configuração da Escala da Máquina #define SCALEMM(1092) // XX passos equivale a 1mm na minha máquina 1/16 #define SCALEZ(166666.67) // ZZ passos equivale a 1mm na minha máquina

Figura 27 - Medida Padrão para Calibração

Concluído o dimensionamento da escala da máquina, foram executados pequenos movimentos com uma caneta acoplada na ponta da ferramenta da máquina para identificar algum possível erro na medida ao executar trajetos lineares conforme ilustra na figura 28.

55 Figura 28 – Validação da Calibração

O método de traçar um triângulo é uma maneira de identificar se a ferramenta voltará exatamente a posição inicial após executar as três linhas (figura 28). Caso a ferramenta não volte exatamente na posição inicial, será necessário executar novamente o procedimento descrito na figura 27 com o maior número de passos possível dentro da área de trabalho de útil da máquina para minimizar o erro de posicionamento.

5.3 Teste Inicial O objetivo principal dos primeiros testes eram validar as funções de interpolações lineares e circulares desenvolvidas nesse trabalho. Sendo assim, foi utilizado um motor de corrente contínua de 300 Watts de potência. Esse motor é comumente chamado de Spindle (figura 29) e ele tem como função realizar processos simples de engravação em madeira MDF.

56 Figura 29 – Spindle DC

A ferramenta utilizada foi um fresa de madeira com ponta V (figura 30) no Spindle para fresar pequenas trilhas numa chapa de MDF com objetivo de realizar medições nas linhas traçadas.

Figura 30 – Fresa com Ponta V

Inicialmente os primeiro testes foram realizados para validar o comando linha.

Portanto, foi enviada a placa Arduino pelo computador a linha de código G do quadro 10 para desenhar um quadrado simples. O resultado foi a gravação na madeira de uma pequeno quadrado (figura 31) com dimensões muito próximas das especificadas no quadro 10. O erro aproximado desse quadrado foi de aproximadamente 0,05mm devido à falta de compensação da dimensão da ponta da fresa V da figura 32 na linha de código G do quadro 12.

57 Quadro 12 – Linha de Programação em Código G do Quadrado M17; // HABILITA MOTORES M3; // HABILITA SPINDLE G00 X30 Y30 Z10; G00 Z20; G00 X58 ; G00 Y58; G00 X30; G00 Y30; G00 Z10 M18; M5;

Figura 31 – Quadrado Engravado na Madeira

58 Ressalta-se que o mesmo processo executado na figura 31 é semelhante ao padrão de fabricação utilizado nos softwares CAM ilustrado na figura 26.

5.4 Validação das Funções de Interpolação

Conforme o primeiro teste, foi realizado diversos testes aleatórios com diversas comandos em linha de código G para estudar o comportamento da máquina em regime de trabalho constante (figura 32). Da mesma maneira, a metodologia aplicada nas figuras 23 e 25 de interpolação linear permitiram traçar com a ferramenta arcos e linhas simultaneamente com um erro de precisão de 0,05mm, porque na programação em código G não foi desenvolvido a compensação da dimensão da ponta da fresa.

Figura 32 – Execução de Diversos Comandos em Código G

Nesse processo da validação das funções foi fundamental utilizar o “Serial Monitor” do software Arduino IDE (Figura 33) em conjunto com processamento de dados no MATLAB. Isso porque os pontos cartesianos gerados pelas funções podem ser impressos na tela do “Serial Monitor”, utilizando o comando

59 “Serial.println(var);” segundo BANZI(2008) no programa. Assim, o valor de uma variável poder ser visualizado na tela conforme figura 33, sendo que esses valores armazenados num arquivo CSV podem ser importados para o MATLAB e gerar gráficos como das figuras 23 e 25.

Figura 33 – Tela do Serial Monitor do Arduino IDE

5.5 Integração de Sistemas para correção de Erros

Um dos problemas que foi possível corrigir com o uso do MATLAB foi o erro de sinal dos segmentos processados pela função de interpolação de arcos (quadro 9). Isso ocorreu mesmo com o código desenvolvido apenas para trabalhar no quadrante de números cartesianos positivos, pois o sinal do segmento da linha determina a direção de rotação do motor conforme mostra a variável “dirx” no quadro

60 8. Logo segmentos com sinal errados provocam movimentos não desejados no motor. Um desses movimentos indesejados é possível identificar na figura 34, onde foi traçado um laço ao invés de um arco. Nessa situação foi repetido o processo, porém extraindo todos os segmentos das variáveis “nx” e “ny” (quadro 10) da função de interpolação de arco.

Figura 34 – Erro de Processamento na Função de interpolação

Os valores extraídos da função de interpolação foram armazenados num arquivo de texto de formato CSV (quadro 13), a fim de executar um simples programa de processamento de dados no MATLAB (quadro 14).

61 Quadro 13 – Dados extraídos da Função de interpolação Comando >G02 X1 Y1 I0.5 J0.5; Segmentos 11 Dados para matlab Ny,Nx 0.00,0.00 0.16,-0.12 0.51,-0.31 1.06,-0.52 1.81,-0.68 2.73,-0.75 3.80,-0.67 4.96,-0.42 6.17,0.03 7.36,0.68 8.48,1.52

Quadro 14 – Programa de Processamento de Dados no MATLAB % interpretação dos dados do arduino clearall; pontos=csvread('C:\Users\lip\Documents\MATLAB\nx_ny.csv'); ny=pontos(:,1); nx=pontos(:,2);

plot(nx,ny), grid minor

O resultado desse procedimento foi um gráfico ilustrado na figura 35, onde foi possível identificar segmentos posicionados fora do quadrante dos pontos cartesianos positivos. Portanto, identificou-se que a execução de arcos por comandos em código G muito próximas do zero da máquina não deveriam ter sido escolhidas, porque as linhas a serem traçadas podem não estar no 1° quadrante no plano bidimensional da área de trabalho da máquina. Caso contrário, o resultado disso podem ser traçados na peça laços ou elipses divergentes das dimensões especificadas na programação em código G pelo usuário, conforme ilustra na figura 36.

62 Figura 35 – Gráfico dos Dados Extraídos

5.6 Aspectos Gerais sobre a Validação dos Resultados O uso do MATLAB e da comunicação serial da placa Arduino com um computador foi feito para a reformulação do código a partir dos erros que eram encontrados, utilizando os métodos exemplificados nas figuras 34 e 35. Isso ocorreu de tal forma identificando as divergências de cada processamento com a programação de código G executada pelo usuário. Além do mais que, o projeto mecânico de uma peça em CAD apenas fornece as dimensões a serem seguidas no processo de fabricação. Paralelamente, a fabricação de um produto utilizando processos de usinagem CNC por uma Router de baixo custo, por exemplo, é basicamente realizar movimentos em linhas e arcos com ferramenta com as mesmas dimensões especificadas no projeto em CAD. Então, o MATLAB proporcionou as ferramentas necessárias de interpretação dos dados gerados pelo programa em C para garantir a confiabilidade das funções de interpolação construídas nesse projeto de máquina ferramenta CNC. Tudo isso porque o MATLAB foi o substituto de um software CAM convencional na integração de sistemas CAD, CAM e CNC.

63 6

COMENTÁRIOS FINAIS

A plataforma Arduino mostrou-se flexível no desenvolvimento de um programa de interpretação de código G para máquina ferramenta. Isso ocorre porque as funções de interpolações, as quais se necessitou elaborar, puderam ser testadas com software MATLAB e validadas no protótipo de uma Router CNC de 3 eixos simultaneamente, através do computador.

Entre os objetivos estabelecidos nesse trabalho, o controle de posicionamento automático foi bem sucedido. Entretanto, a validação da acurácia dos processos executados pelo programa principal necessita de um melhoramento estatístico mais extenso para seguir normas e padrões de qualidade específicos da indústria.

Ratifica-se que, como o objetivo restringia-se a desenvolver uma máquina ferramenta para fins didáticos, este foi perfeitamente validado pelo resultado do programa principal, exposto no apêndice A. O autor OVERBY (2011) contribui significativamente com seu livro no dimensionamento dos elementos mecânicos necessários para a construção de um protótipo de máquina ferramenta. Esse projeto foi elaborado com mais facilidade por causa do software Autodesk Inventor (figura 16), porque através desse software foi possível prevenir possíveis problemas de estrutura, que interferem nos processos de usinagem como, por exemplo, flambagem e desnivelamento.

Figura 36 – Protótipo Mecânico da Router

64 Os autores BANZI (2008) e LAMOTHE (1995) foram importantíssimos na elaboração do código em linguagem C na plataforma Arduino. Isso ocorreu porque o autor BANZI (2008) forneceu em seu livro métodos de programação em C básicos para o Arduino, já LAMOTHE (1995) é uma referência muito avançada para a elaboração de algoritmos de processamento de gráfico em linguagem C, mesmo sendo um livro antigo. Portanto, as funções de interpolação desenvolvida satisfazem o nível adequado de precisão na indústria.

6.1 Conclusão O objetivo principal deste trabalho de desenvolvimento e validação para um sistema de controle de uma máquina de usinagem genérica como solução de baixo custo foi perfeitamente alcançado.

O MATLAB nesse projeto teve como função substituir um programa CAM convencional para analisar as trajetórias realizadas pela ferramenta em cada linha de programação em código G. Portanto, a compatibilidade da plataforma Arduino com software MATLAB contribuiu significativamente para a construção das funções de interpolação em linguagem C. Acrescenta-se a isso que, erros de processamento como exemplo citado no sub-capítulo 5.3, puderam ser identificados com mais facilidade utilizando a interpretação dos dados através dos gráficos gerados pelo MATLAB. A implementação de uma Router compacta para fresamento foi alcançada com sucesso, tornando-se crucial no cumprimento das metas do projeto. Isso ocorreu principalmente devido esse tipo de máquina seguir as preferências da indústria, referenciadas no sub-capítulo 2.5.

Tanto a nível acadêmico como para um modelo industrial, o produto resultante deste trabalho atendeu perfeitamente as expectativas, pois se pode validar uma versão de hardware e firmware para controle de máquinas CNC de uso genérico de até três eixos.

65 6.2 Sugestões e Trabalhos Futuros Uma base de dados contendo as medidas de um conjunto de amostras peças poderia ser gerada para validação da precisão do controle desse firmware, pois seria desejado a esse projeto atender um nível de precisão de usinagem padrão nas industriais. Contudo, estima-se que a construção dessa base de dados necessitará uma pesquisa de procedimentos e processos de fabricação na indústria mais extensa que o trabalho aqui exposto. Soma-se a isso o fato de que para atender o foco de desenvolver o programa de controle consumiu uma gama significativa de conteúdos teóricos sobre programação de máquina com linguagem C. Com um firmware de controle de máquinas ferramentas CNC concluída, surge-se como proposta de trabalho futuro elaborar um projeto mais avançado de controle de posicionamento. A metodologia a ser aplicada para esse trabalho será fabricar um número significativo de peças mecânicas, utilizando os mesmos programas Arduino IDE e MATLAB. A fabricação dessas peças servirá como levantamento de um banco de dados para estudo de desenvolvimento de funções de interpolações matemáticas que trabalharão com mais de três eixos e mais quadrantes tridimensionais. Além do mais que o trabalho dessa monografia não pode englobar um levantamento estatístico mais robusto para reforçar a precisão de usinagem do protótipo da Router CNC de três eixos. Contudo, a usinagem de figuras simples em chapas de MDF como da figura 34 comprovou a possiblidade de utilização de microcontroladores de 8 bits para um controlar máquinas ferramentas CNC de forma confiável.

66 REFERÊNCIAS

BANZI, Massimo. Getting started with Arduino. O‟Reilly Media, 2008 BRESENHAM, Jack. Algorithm for control of a digital plotter. IBM Systems Journal, v. 4, n. 1, p. 25-30, Jan. 1965.

CAO, L; SCWARTZ, H. Oscillation, Instability and Control of Stepper Motor.

Nonlinear Dynamics, v. 18, n. 4, p. 383-404, apr. 1999.

CARDOZO, Willian Schroeder. Controle de motores de passo aplicado a um manipulador robótico. Dissertação de mestrado. Pós-Graduação em Engenharia Mecânica da PUC-Rio, 2012.

FABRICANTE de ferramentas e dispositivos especiais para usinagem. Revista Máquinas e Metais, v. 49, n. 566, mar. 2013.

FITZGERALD, A.; KINGSLEY JUNIOR, K.; STEPHEN, D. Máquinas Elétricas. 6. ed. Porto Alegre: Bookman, 2006.

HUGHES, A.; LAWRENSON, P. J. Electromagnetic Damping in Stepping Motors.

Proc. IEE, v. 122, n.8, p. 819-24, 1975.

KENJO, T.; SUGAWARA, A. Stepping motors and their microprocessor controls.

2. ed. Oxford: Oxford University Press, 2003.

LAMOTHE, André. The black art of 3D programming. Corte Madera: Wate Group Press, 1995.

OGATA, K. Engenharia de Controle Moderno. 4.ed. Upper Saddle River, Nova Jersey: Prentice Hall, 2003.

OLIVEIRA, V.A.; AGUIAR, M. L.; VARGAS, J. B. Sistemas de controle: aulas de laboratório. 3. Ed São Carlos: EESC-USP, 2005.

OSWALD, A; HERZOG, H.G.; Investigation f the usability of 2D – and 3D – FEM for hybrid Stepper Motor; IEEE International Electric Machines and Drives Conference; p. 535-542; Miami, FL; may, 2009.

OVERBY, Alan. CNC machining handbook building, programing and implementation. São Paulo: McGraw-Hill, 2011.

SABER, Mecatrônica Fácil - Integração entre sistemas CAD/CAM e geração de programas para máquinas CNC. ; Ano: 4; N° 25; Nov / Dez – 2005 SANTANA, Douglas Daniel Sampaio; SILVA, Patricia Andrade; OLIVEIRA, Ângela Luhmamm de. Sistema de controle de velocidade para mesa coordenada cartesiana utilizada em máquinas ferramenta. Revista de Ciências Exatas e Tecnologia, v. 3, n. 3, 2008.

67 WARD, Paul T; MELLOR, Stephen J. Structured development for real-time systems, v. 2, 1. ed: Prentice Hall, 1986.

ABNT 03.004, NBR 8190, Simbologia de Instrumentação, out, 1983.

68 APÊNDICE A – Firmware de Controle Principal

//************************************************************************* ********* // BotFaz uma Router CNC de 3 eixos controlada pelo Arduino Uno que aciona // um driver TB6560 para motores de passo que se comunica serialmente com o // computador. //************************************************************************* ********* // //

//************************************************************************* ********* // CONSTANTES //************************************************************************* ********* #define VERSION

(1)// VERSÃO DO FIRMWARE

#define BAUD

(57600)// VELOCIDADE DE COMUNICACÃO SERIAL

#define MAX_BUF

(64)// CAPACIADE DE ARMAZENAMENTO DE UMA MENSAGEM

#define SCALEMM(1092) // XX passos equivale a 1mm na minha máquina 1/16 #define SCALEZ(166666.67) // ZZ passos equivale a 1mm na minha máquina

// DIRECAO DO ARCO #define ARC_CW (-1) #define ARC_CCW (1) #define CM_PER_SEGMENT (0.2) //define a quantidade seguimentos no arco #define PI (3.14)

//************************************************************************* *********

69 // BIBLIOTECAS //************************************************************************* ********* #include <math.h> #include <stdio.h> #include <stlib.h> #include <AccelStepper.h>

//************************************************************************* ********* // ENDERECAMENTO DAS PORTAS //************************************************************************* ********* #define stope 2 #define DIRX_PIN 5 #define STEPX_PIN 4 #define ENABLEX_PIN 3 #define DIRY_PIN 8 #define STEPY_PIN 7 #define ENABLEY_PIN 6 #define DIRZ_PIN 11 #define STEPZ_PIN 10 #define ENABLEZ_PIN 9 #define SPINDLE 12 #define XZERO A0 #define YZERO A1 #define ZZERO A2 AccelStepper eixox(1, 4, 5); // eixo x AccelStepper eixoy(1, 7, 8); //eixo y AccelStepper eixoz(1, 10, 11); //eixo z

//************************************************************************* ********* // VARIﾃシEIS GLOBAIS //*************************************************************************

70 ********* double matlabx=0; double matlaby=0; double radius; double angle1; double angle2; double theta; // LOCALIZAÇÃO double xx=0, yy=0, zz=0; int microsteps; double ii=0; double jj=0; long int i=0; long int j=0; boolean fim = HIGH; char buffer[MAX_BUF]; int sofar;

// AONDE ARMAZENAR A MENSAGEM ATE OBTER ';'

// QUANTO EXISTE NO BUFFER ATE AGORA

double px=0; double py=0, pz=0;

// LOCALIZAÇÃO

double posx=0, posy=0, posz=0;

// VELOCIDADES float fr=0;

// VERSÃO HUMANA

long step_delay;

// DEPENDE DA MAQUINA

// modo de movimento char mode_abs=1;

// MODO ABSOLUTO DE MOVIMENTO?

//------------------------------------------------------------------------// PROGRAMA PRINCIPAL //------------------------------------------------------------------------/** * Primeira cosia que

maquina faz

*/ void setup() { DDRD = B11111011; // configura as PORTAS pins 0 to 8 output, 2 entrada

71 DDRB = B01111111; // configura as PORTAS 9 to 12 outputs, fim=digitalRead(stope); attachInterrupt(0, emergencia, FALLING); // funciona apenas eixo Z eixox.setMaxSpeed(3000); eixox.setAcceleration(1000); eixoy.setMaxSpeed(3000); eixoy.setAcceleration(1000); eixoz.setMaxSpeed(3000); eixoz.setAcceleration(1000); digitalWrite(ENABLEX_PIN, LOW); // DESabilita eixo X digitalWrite(ENABLEY_PIN, LOW); // DESabilita eixo Y digitalWrite(ENABLEZ_PIN, LOW); // DESAabilita eixo Z Serial.begin(BAUD); help();

// ABRE A COMUNICACAO

// MOSTRA A AJUDA

position(0,0,0); feedrate(200);

// COLOCA A POSICAO INICIAL // VELOCIDADE DE DEFAULT

ready(); }

/** * DEPOIS DA CONFIGURACAO DO SETUP SEGUE O LOOP INFINITO */ void loop() { // LEITURA DA SERIAL while(Serial.available() > 0) { char c=Serial.read(); Serial.print(c);

// DETECTA COMANDOS

// FAZ LEITURAS SERIAIS

// REPETE O COMANDO PARA SABER

if(sofar<MAX_BUF) buffer[sofar++]=c; if(buffer[sofar-1]==';') break;

// ARMAZENA O COMANDO

// TODA A MENSAGEM RECEBIDA

} if(sofar>0 && buffer[sofar-1]==';') { // TODA MENSAGEM DEVE TERMINAR COM PONTO E VIRGULA buffer[sofar]=0;

// LIMPA O BUFFER

Serial.print(F("\r\n"));

// eFEEEBACK

13 inputs

72 processCommand();

// PROCESSA O COMANDO

ready(); } } //------------------------------------------------------------------------// FUNCOES AUXILIARES //-------------------------------------------------------------------------

void rotacionax() { // 66 passos equivale a 1mm na minha MAquina digitalWrite(STEPX_PIN, LOW); delayMicroseconds(300); digitalWrite(STEPX_PIN, HIGH); delayMicroseconds(300);

} void rotacionay() { // 66 passos equivale a 1mm na minha maquina digitalWrite(STEPY_PIN, LOW); delayMicroseconds(300); digitalWrite(STEPY_PIN, HIGH); delayMicroseconds(300); } void rotacionaz() // EIXO Z E DIFERENTE EM PASSOS E DELAY { // 66 passos equivale a 1mm na minha maquina

73 digitalWrite(STEPZ_PIN, LOW); delayMicroseconds(300); digitalWrite(STEPZ_PIN, HIGH); delayMicroseconds(300); } /** * ATRASO DE UM VALOR APROPRIADO DE MICROSEGUNDOS * @input ms QUANTOS MILISEGUNDOS DE ESPERA */ void pause(long ms) { delay(ms/1000); delayMicroseconds(ms%1000); //

delayMicroseconds(ms);

//

delayMicroseconds

VALORES > ~16k. } /** * CONFIGURE O FEEDRATE (VELOCIDADE DOS MOTORES) * @input nfr A NOVA VELOCIDADE DE PASSOS/SEGUNDO */ void feedrate(float nfr) { step_delay = 1000000.0/nfr; fr=nfr; }

/ * CONFIGURE A POSIﾃイAO LOGICA * @input npx NOVA POSICAO DE x * @input npy NOVA POSIﾃイAO DE y */ void position(float npx,float npy, float npz) { // BOM PARA TESTAR A SANIDADADE DA MAQUINA px=npx; py=npy; pz=npz; }

Nﾃグ

FUNCIONA

PARA

74 // cx/cy - centro do circulo // x/y - posiçao final // dir - ARC_CW or ARC_CCW to direCAO do circulo static void arca(float x,float y,float cx,float cy) { int dir = ARC_CCW; // sentido anti-horário // calc raio double dx = posx-cx; double dy = posy-cy; double radius=sqrt(dx*dx+dy*dy); // encontra arco do raio

angle1=atan2(dy,dx); if(angle1<0) angle1=(PI*2.0)+angle1; angle2=atan2(y-cy,x-cx); if(angle2<0) angle2=(PI*2.0)+angle2; theta=angle2-angle1; if(dir>0 && theta<0) angle2+=2*PI; else if(dir<0 && theta>0) angle1+=2*PI;

theta=angle2-angle1; // get length of arc //float circ=PI*2.0*radius; //float len=theta*circ/(PI*2.0); // simplifies to //if(theta==0) theta=2*PI; double len = abs(theta) * radius; long int k, segments = floor( len / CM_PER_SEGMENT ); double difangulo=theta/segments; double nx, ny, angle3, scale; double somangulo=0; for(k=0;k<segments;++k) { // interpolação do arco por retas //scale = ((double)k)/((double)segments); somangulo+=difangulo; angle3 = ( somangulo) + angle1;

75 //angle3 = ( theta * scale ) + angle1; nx = cx + cos(angle3) * radius; ny = cy + sin(angle3) * radius;

// envia para o plano lineABS(nx,ny,0); } lineABS(x,y,0); } static void arch(float x,float y,float cx,float cy) { int dir = ARC_CW; // sentido horĂ&#x192;ÂĄrio // calc raio double dx = posx - cx; double dy = posy - cy; radius=sqrt(dx*dx+dy*dy); //Serial.println(radius); // calc do arco angle1=atan2(dy,dx); if(angle1<0) angle1=(PI*2.0)+angle1; angle2=atan2(y-cy,x-cx); if(angle2<0) angle2=(PI*2.0)+angle2; theta=angle2-angle1; if(dir>0 && theta<0) {angle2+=2*PI;} else if(dir<0 && theta>0) {angle1+=2*PI;} //Serial.println("angle1 e 2"); //Serial.println(angle1); //Serial.println(angle2); theta=angle2-angle1; //Serial.println("theta"); //Serial.println(theta); //if(theta==0) theta=2*PI; //get length of arc //float circ=PI*2.0*radius; //float len=theta*circ/(PI*2.0); //simplifies to double len = abs(theta) * radius;

76 //Serial.println("len"); //Serial.println(len); long int k, segments = floor( len / CM_PER_SEGMENT ); double difangulo=theta/segments; double nx=0, ny=0, angle3, scale; //Serial.println("segments"); //Serial.println(segments); Serial.println("Segmentos"); Serial.println(segments); Serial.println("Dados para matlab Ny,Nx"); double somangulo=0; for(k=0;k<segments;++k) { // interpolate around the arc //scale = ((double)k)/((double)segments); somangulo+=difangulo; //angle3 = ( theta*scale) + angle1; angle3 = (somangulo) + angle1; nx = cx + cos(angle3) * radius; ny = cy + sin(angle3) * radius; //matlabx+=nx; //matlaby+=ny; Serial.print(ny);// primeira coluna Serial.print(","); Serial.println(nx);// segunda coluna //envia para o plano lineABS(nx,ny,0); } lineABS(x,y,0); } static void line(float x,float y) { double d1 = x-posx; double d2 = y-posy; long ad1=abs(d1*SCALEMM);// 66 PASSOS EQUIVALE A 1MM

77 long ad2=abs(d2*SCALEMM); int dir1=x<0?LOW:HIGH; int dir2=y<0?LOW:HIGH; long over=0; long kk;

// bresenham's line algorithm. if(ad1>ad2) { for(kk=0;kk<ad1;++kk) { digitalWrite(DIRX_PIN, dir1); rotacionax(); //eixox.move(dir1); //eixox.run(); over+=ad2; if(over>=ad1) { over-=ad1; digitalWrite(DIRY_PIN, dir2); rotacionay(); //eixoy.move(dir2); //eixoy.run(); } pause(step_delay); hithome(); } } else { for(kk=0;kk<ad2;++kk) { digitalWrite(DIRY_PIN, dir2); rotacionay(); //eixoy.move(dir2); //eixoy.run(); over+=ad1; if(over>=ad2) { over-=ad2; digitalWrite(DIRX_PIN, dir1); rotacionax(); //eixox.move(dir1); //eixox.run(); } pause(step_delay);

78 hithome(); } } posx+=x; posy+=y; px=0; py=0; } // SOMENTE VALORES POSITIVOS static void lineABS(double newx,double newy, double newz) { double dx=newx-posx; double dy=newy-posy; double dz=newz-posz; int dirx=dx>0?LOW:HIGH; int diry=dy>0?LOW:HIGH; int dirz=dz>0?1:-1; //eixo invertido long adx=abs(dx*SCALEMM);// converte para passos long ady=abs(dy*SCALEMM); long adz=abs(dz*SCALEZ); long i; long over=0; if(adx>ady) { for(i=0;i<adx;++i) { digitalWrite(DIRX_PIN, dirx); rotacionax(); //eixox.move(dirx); //eixox.run(); over+=ady; if(over>=adx) { over-=adx; digitalWrite(DIRY_PIN, diry); rotacionay(); //eixoy.move(diry); //eixoy.run(); } //pause(step_delay);

79 if(posx==0&& posy==0){} else hithome() ; } } else { for(i=0;i<ady;++i) { digitalWrite(DIRY_PIN, diry); rotacionay(); //eixoy.move(diry); //eixoy.run(); over+=adx; if(over>=ady) { over-=ady; digitalWrite(DIRX_PIN, dirx); rotacionax(); //eixox.move(dirx); //eixox.run(); } //pause(step_delay); if(posx==0&&posy==0){} else hithome(); // teste dos switchs } } for(i=0;i<adz;i++){ eixoz.move(dirz); eixoz.run(); //digitalWrite(DIRZ_PIN, dirz); //rotacionaz(); if(posx==0&&posy==0){} else hithome(); //delayMicroseconds(1500); } px=0; py=0; pz=0; posx=newx; posy=newy; posz=newz;

80 } void lineREL(float newx,float newy) { long dx=newx; long dy=newy; int dirx=dx>0?LOW:HIGH; int diry=dy>0?LOW:HIGH; dx=abs(dx*SCALEMM); dy=abs(dy*SCALEMM); long i; long over=0; if(dx>dy) { for(i=0;i<dx;++i) { digitalWrite(DIRX_PIN, dirx); rotacionax(); //eixox.move(dirx); //eixox.run(); over+=dy; if(over>=dx) { over-=dx; digitalWrite(DIRY_PIN, diry); rotacionay(); //eixoy.move(diry); //eixoy.run(); } //pause(step_delay); hithome(); } } else { for(i=0;i<dy;++i) { digitalWrite(DIRY_PIN, diry); rotacionay(); //eixoy.move(diry); //eixoy.run(); over+=dx; if(over>=dy) {

81 over-=dy; digitalWrite(DIRX_PIN, dirx); rotacionax(); //eixox.move(dirx); //eixox.run(); } //pause(step_delay); hithome(); // teste dos switchs } } px=0; py=0; posx+=newx; posy+=newy; } void linexz(float newx,float newz) { long dx=newx*SCALEMM; long dz=newz*SCALEZ; int dirx=dx>0?LOW:HIGH; int dirz=dz>0?1:-1;// DIREÇÃO OPOSTO dx=abs(dx); dz=abs(dz); long i; long over=0; if(dx>dz) { for(i=0;i<dx;++i) { digitalWrite(DIRX_PIN, dirx); rotacionax(); //eixox.move(dirx); //eixox.run(); over+=dz; if(over>=dx) { over-=dx; //digitalWrite(DIRZ_PIN, dirz); //rotacionaz(); eixoz.move(dirz);

82 eixoz.run(); delayMicroseconds(1500); } //pause(step_delay); hithome(); } } else { for(i=0;i<dz;++i) { //digitalWrite(DIRZ_PIN, dirz); //rotacionaz(); eixoz.move(dirz); eixoz.run(); delayMicroseconds(1500*fr); over+=dx; if(over>=dz) { over-=dz; digitalWrite(DIRX_PIN, dirx); rotacionax(); //eixox.move(dirx); //eixox.run(); } //pause(step_delay); hithome(); } } px=0; pz=0; posx=posx+newx; posz=posz+newz; } void lineyz(float newy,float newz) { long dy=newy*SCALEMM; long dz=newz*SCALEZ; int diry=dy>0?LOW:HIGH; int dirz=dz>0?1:-1;// isso devido aos motores serem montados em posicoes opostas dy=abs(dy); dz=abs(dz);

83 long i; long over=0; if(dy>dz) { for(i=0;i<dy;++i) { digitalWrite(DIRY_PIN, diry); rotacionay(); //eixoy.move(diry); //eixoy.run(); over+=dz; if(over>=dy) { over-=dy; //digitalWrite(DIRZ_PIN, dirz); //rotacionaz(); eixoz.move(dirz); eixoz.run(); delayMicroseconds(1500); } //pause(step_delay); } } else { for(i=0;i<dz;++i) { //digitalWrite(DIRZ_PIN, dirz); //rotacionaz(); eixoz.move(dirz); eixoz.run(); delayMicroseconds(1500); over+=dy; if(over>=dz) { over-=dz; digitalWrite(DIRY_PIN, diry); rotacionay(); //eixoy.move(diry); //eixoy.run(); } //pause(step_delay); hithome(); } }

84 py=0; pz=0; posy=posy+newy; posz=posz+newz;

} float parsenumber(char code,float val) { char *ptr=buffer; while(ptr && *ptr && ptr<buffer+sofar) { if(*ptr==code) { return atof(ptr+1); } ptr=strchr(ptr,' ')+1; } return val; }

/** *

escreve

uma

string

seguida

por

um

var

flutuante

conveniente para debugar. * @input code a string. * @input val a flutuante. */ void output(char *code,float val) { Serial.print(code); Serial.println(val); }

/** * mostra a posição, feedrate, é o modo absoluto. */ void where() { output("X",posx); output("Y",posy); output("Z",posz); output("F",fr); Serial.println(mode_abs?"ABS":"REL");

na

linha

serial.

85 }

/** * mostra a ajuda */ void help() { Serial.print(F("Bot FAZ V")); Serial.println(VERSION); Serial.println(F("Digite ; no final dos Commandos:")); Serial.println(F("G00

[X(valor-mm)]

[Y(valor-mm)]

[Z(valor-mm)]

[F(feedrate)]; - plano xy movimento linear z sozinho")); Serial.println(F("G01

[X(valor-mm)]

[Y(valor-mm)]

[F(feedrate)];

-

movimento linear")); Serial.println(F("G02 [I(valor-mm)] [J(valor-mm)] [X(valor-mm)] [Y(valormm)] [F(feedrate)]; - movimento em arco horario")); Serial.println(F("G03 [I(valor-mm)] [J(valor-mm)] [X(valor-mm)] [Y(valormm)] [F(feedrate)]; - movimento em arco anti-horario")); Serial.println(F("G04 P[microseconds]; - delay")); Serial.println(F("G18 [X(valor-mm)] [Z(valor-mm)] [F(feedrate)]; - plano xz movimento linear")); Serial.println(F("G19 [Y(valor-mm)] [Z(valor-mm)] [F(feedrate)]; - plano yz movimento linear")); Serial.println(F("G54; - modo MANUAL")); Serial.println(F("G28; - Go HOME O Zero da maquina")); Serial.println(F("G90; - modo absoluto")); Serial.println(F("G91; - modo relativo")); Serial.println(F("G92 [X(steps)] [Y(steps)]; - muda posicao logica")); Serial.println(F("M3; - habilita spindle")); Serial.println(F("M5; - desabilita spindle")); Serial.println(F("M17; - habilita motores")); Serial.println(F("M18; - desabilita motores")); Serial.println(F("M100; - mensagem de ajuda")); Serial.println(F("M114; - informa posicao e velocidade")); } /** * realiza leitura do buffer e reconhece os comandos em codigo G.um G ou M por linha. */ void processCommand() {

86 int cmd = parsenumber('G',-1); switch(cmd) { case

00: // move linear feedrate(parsenumber('F',fr)); lineABS ( parsenumber('X',(mode_abs?px:0)) + (mode_abs?0:px), parsenumber('Y',(mode_abs?py:0)) + (mode_abs?0:py), parsenumber('Z',(mode_abs?pz:0)) + (mode_abs?0:pz) );

break; case

01: // move linear

feedrate(parsenumber('F',fr)); lineABS( parsenumber('X',(mode_abs?px:0)) + (mode_abs?0:px), parsenumber('Y',(mode_abs?py:0)) + (mode_abs?0:py), parsenumber('Z',(mode_abs?pz:0)) + (mode_abs?0:pz) ); case

02: // move arco horário

feedrate(parsenumber('F',fr)); arch( parsenumber('X',(mode_abs?xx:0)) + (mode_abs?0:xx), parsenumber('Y',(mode_abs?yy:0)) + (mode_abs?0:yy), parsenumber('I',(mode_abs?ii:0)) + (mode_abs?0:ii), parsenumber('J',(mode_abs?jj:0)) + (mode_abs?0:jj) ); break; case

03: // move arco

anti horário

feedrate(parsenumber('F',fr)); arca( parsenumber('X',(mode_abs?xx:0)) + (mode_abs?0:xx), parsenumber('Y',(mode_abs?yy:0)) + (mode_abs?0:yy), parsenumber('I',(mode_abs?ii:0)) + (mode_abs?0:ii), parsenumber('J',(mode_abs?jj:0)) + (mode_abs?0:jj)); break; case

04:

pause(parsenumber('P',0)*1000);

break;

// reside

case 17: //trabalha com plano XZ linearmente feedrate(parsenumber('F',fr)); linexz( parsenumber('X',(mode_abs?px:0)) + (mode_abs?0:px), parsenumber('Z',(mode_abs?pz:0)) + (mode_abs?0:pz) ); break; case 18: //trabalha com plano XZ linearmente feedrate(parsenumber('F',fr)); lineyz( parsenumber('Y',(mode_abs?px:0)) + (mode_abs?0:px), parsenumber('Z',(mode_abs?pz:0)) + (mode_abs?0:pz) ); break; case 28: gohome(); break; case 54: manual(parsenumber('X',(mode_abs?px:0)) + (mode_abs?0:px), parsenumber('Y',(mode_abs?py:0)) + (mode_abs?0:py) );

87 break; case 90:

mode_abs=1;

break;

// modo absoluto

case 91:

mode_abs=0;

break;

// modo relativo

case 92:

// configura a posicao logiica

position( parsenumber('X',0), parsenumber('Y',0), parsenumber('Z',0)); break; default:

break;

} cmd = parsenumber('M',-1); switch(cmd) { case 3: // habilita spindle horร ยกrio digitalWrite(SPINDLE, HIGH); break; case 5: // desliga spindle digitalWrite(SPINDLE, LOW); break; case 17:

// habilita motores

digitalWrite(ENABLEX_PIN, HIGH); digitalWrite(ENABLEY_PIN, HIGH); digitalWrite(ENABLEZ_PIN, HIGH); break; case 18:

// desabilita motores

digitalWrite(ENABLEX_PIN, LOW); digitalWrite(ENABLEY_PIN, LOW); digitalWrite(ENABLEZ_PIN, LOW); break; case 100:

help();

case 114:

where();

default:

break; break;

break;

} } /** * programa para mostra que a maquina esta pronta para receber comandos */ void ready() { sofar=0;

// limpa entrada do buffer

Serial.print(F(">"));

// sinal de pronto na entrada

88 } void gohome(){ int x0 = analogRead(XZERO); int y0 = analogRead(YZERO); int z0 = analogRead(ZZERO); while((x0<40)||(y0<40)||(z0<40)){ Serial.println("Voltando para Casa"); if (x0<40) { digitalWrite(DIRX_PIN, HIGH); rotacionax(); } else digitalWrite(ENABLEX_PIN, LOW); if (y0<40) { digitalWrite(DIRY_PIN, HIGH); rotacionay(); } else digitalWrite(ENABLEY_PIN, LOW); if (z0<40) { digitalWrite(DIRZ_PIN, LOW); rotacionaz(); } else digitalWrite(ENABLEZ_PIN, LOW); x0 = analogRead(XZERO); y0 = analogRead(YZERO); z0 = analogRead(ZZERO); } Serial.println("Estร ยก em Casa!!"); posx=0; posy=0; posz=0; para(); } void emergencia()

89 { digitalWrite(ENABLEX_PIN, LOW); // DESabilita eixo X digitalWrite(ENABLEY_PIN, LOW); // DESabilita eixo Y digitalWrite(ENABLEZ_PIN, LOW); // DESAabilita eixo Z digitalWrite(SPINDLE, LOW); Serial.println("Opa Fim de Curso"); detachInterrupt(0); } void hithome(){ int x0 = analogRead(XZERO); int y0 = analogRead(YZERO); int z0 = analogRead(ZZERO); fim = digitalRead(stope); while((x0>40)||(y0>40)||(z0>50)){ fim = digitalRead(stope); if(stope==LOW) {para();} if (x0>40) { digitalWrite(ENABLEX_PIN, LOW); } if (y0>40) { digitalWrite(ENABLEY_PIN, LOW); } if (z0>50) { digitalWrite(ENABLEZ_PIN, LOW); } x0 = analogRead(XZERO); y0 = analogRead(YZERO); z0 = analogRead(ZZERO); } } void para() {

90 digitalWrite(ENABLEX_PIN, LOW); digitalWrite(ENABLEY_PIN, LOW); digitalWrite(ENABLEZ_PIN, LOW); digitalWrite(SPINDLE, LOW); } void manual(float passox, float passoy){ boolean sentidox=passox>0?LOW:HIGH; boolean sentidoy=passoy>0?LOW:HIGH; digitalWrite(DIRX_PIN, sentidox); digitalWrite(DIRY_PIN, sentidoy); passox=abs(passox); passoy=abs(passoy); for (i=1; i<=passox;i++) { digitalWrite(STEPX_PIN, LOW); delayMicroseconds(300); digitalWrite(STEPX_PIN, HIGH); delayMicroseconds(300); } for (i=1; i<=passoy;i++) { digitalWrite(STEPY_PIN, LOW); delayMicroseconds(300); digitalWrite(STEPY_PIN, HIGH); delayMicroseconds(300); } passox=0; passoy=0; }

91

ANEXO A â&#x20AC;&#x201C; Datasheets de Componentes

Fuso Trapezoidal

Motor de Passo NEMA 23

92 Driver TB6560