Pedro Miguel Gonçalves da Costa Pereira Desenvolvimento de uma

Pedro Miguel Gonçalves da Costa Pereira

Desenvolvimento de uma aplicação de software que

converta Código-G numa linguagem de alto nível

interpretável por um controlador aberto da NI

Trabalho efetuado sob orientação por parte do

Professor Jaime Francisco Cruz Fonseca

E coorientação por parte do

Professor António Marques Pinho

Outubro 2014

Universidade do Minho

Escola de Engenharia

DECLARAÇÃO

Nome: Pedro Miguel Gonçalves da Costa Pereira

Endereço eletrónico: [email protected]

Telefone: 915076826

Número do Bilhete de Identidade: 13938039

Título dissertação: Desenvolvimento de uma aplicação de software que converta código G numa linguagem de alto nível

interpretável por um controlador aberto da NI.

Orientadores: Professor Jaime Francisco Cruz Fonseca

Professor António Marques Pinho

Ano de conclusão:

Designação do Mestrado: Mestrado Integrado em Engenharia Electrónica Industrial e de Computadores

Universidade do Minho, / /

Aos meus pais pelos sacrifícios que fizeram durante esta etapa!

À minha namorada por todo o apoio que me deu!

“A mente que se abre a uma nova ideia jamais voltará ao seu tamanho

original."

Albert Einstein

Pedro Miguel Pereira i

Agradecimentos

O conceção desta dissertação não seria possível sem o contributo direto e indireto de um

conjunto de pessoas, às quais pretendo expor os meus sinceros agradecimentos.

Primeiramente gostaria de agradecer ao meu orientador, Professor Jaime Francisco Cruz

Fonseca, não só por toda a disponibilidade demonstrada durante o desenvolvimento desta

dissertação nos momentos de tomada de decisões, como também pela confiança depositada em

mim para a concretização deste trabalho.

Agradeço ao meu coorientador, Professor António Marques Pinho, que em conjunto com o meu

orientador, criaram a possibilidade da realização desta dissertação na empresa Cert&Mec, Lda.

Devo agradecer também ao Engenheiro João Borges não só pelo tempo dispensado para me

transmitir conhecimento científico essencial sobre o sistema, como também pelo tempo dispensado

para resolver diversos contratempos que foram aparecendo, e ainda pela sua disponibilidade sempre

que foram surgindo dúvidas.

Um agradecimento especial à minha namorada, Bianca Caratão, por todo o apoio e orientação

que me deu quando mais necessitava, pelas palavras de conforto e serenidade essenciais nos

momentos menos bons, e ainda pela confiança depositada em mim, facilitando assim a superação

dos obstáculos que foram emergindo. O seu contributo foi fulcral para o culminar com sucesso desta

etapa.

Agradeço também aos meus companheiros de casa Eurico Moreira e João Lage, pelas

experiências vividas e conhecimento partilhado, assim como agradeço aos meus colegas de curso,

que se tornaram verdadeiros amigos durante o meu percurso académico.

Por fim, e de todo não menos importante, agradeço aos meus pais por sempre acreditarem nas

minhas capacidades e pelos sacrifícios que fizeram para que fosse possível hoje estar onde estou.

ii Pedro Miguel Pereira

Pedro Miguel Pereira iii

Resumo

Nos dias de hoje, devido ao evidente aumento da eficiência dos processos onde

procedimentos automáticos e autónomos são empregues, é inevitável projetar um sistema sem

equacionar a utilização de técnicas computadorizadas. A elaboração desta dissertação tem como foco

principal a integração de novas funcionalidades provenientes da evolução tecnológica, num sistema

automatizado.

De um modo mais detalhado, atualmente o manuseamento automático de máquinas a nível

industrial é dominado pelos sistemas de controlo numérico, baseados na linguagem de programação

denominada de Código-G. Um sistema deste tipo é definido como a operação de uma máquina

através de um conjunto de instruções constituídas por números, letras do alfabeto e símbolos que a

unidade de controlo consiga interpretar [2]. Tendo em consideração que o Código-G já foi

diversamente testado e corroborado, o objetivo desta dissertação é então desenvolver uma aplicação

de software que permita a conversão de instruções escritas nesta linguagem, numa linguagem de alto

nível interpretável pelos controladores abertos da National Instruments.

Posto isto, de acordo com a análise realizada do sistema físico no qual a aplicação concebida

será executada, foram então estabelecidas quais as instruções que se pretendem que sejam

reconhecidas pelo sistema, designadamente os comandos G00, G01, G02, G03, G20, G21, G90 e

G91. Não obstante, recorrendo à implementação de mecanismos de programação sempre com o

intuito de tornar o software desenvolvido o mais genérico possível, obteve-se um programa que

reconhece não só o conjunto de instruções escolhido, como também possui uma estrutura passível

de integrar facilmente novas instruções no mesmo.

Por fim, após realizados diversos testes utilizando ficheiros escritos em Código-G com

diferentes combinações das instruções escolhidas, foi possível confirmar o bom funcionamento da

aplicação de software desenvolvida. Mais especificamente, o programa concebido tem a capacidade

de executar movimentos retilíneos com diferentes velocidades, movimentos circulares numa gama de

0 a 360 graus, executar ficheiros em milímetros ou inches e ainda operar em modo absoluto ou

relativo.

iv Pedro Miguel Pereira

Pedro Miguel Pereira v

Abstract

Nowadays, due to the evident increased efficiency of processes where automatic and

autonomous procedures are used, it is inevitable designing a system without equating the use of

computerized techniques. The development of this master thesis is mainly focused on the integration

of new attributes arising from technological evolution, in an automated system.

In greater detail, nowadays the automatic handling machine at an industrial level is dominated

by the numerical control systems, based on a programming language called G-code. Such a system is

defined as the operation of a machine through a set of instructions consisting of numbers, letters of

the alphabet and symbols which the control unit is able to interpret [2]. Given that G-code has been

diversely tested and corroborated, the aim of this master thesis is then to develop a software

application that enables the conversion of instructions written in this language, in an interpretable

high-level language for the open controllers from National Instruments.

That being said, according to performed analysis of the physical system on which the

application is designed to run, were then established which instructions are intended to be recognized

by the system, namely the commands G00, G01, G02, G03, G20, G21, G90 and G91. Nevertheless,

the implementation of programming mechanisms always aiming to make the developed software as

generic as possible, allowed the creation of a program that recognizes not only the instruction set

defined, but also has a structure capable of integrating new commands easily.

Finally, after several tests performed using files written in G-code containing different

combinations of the chosen instructions, it was possible to confirm the proper functioning of the

developed software application. More specifically, the conceived program is able to perform rectilinear

movements with different velocities, circular movements with a range of 0 to 360 degrees, execute

files in millimeters or inches, and operate in absolute or relative mode.

vi Pedro Miguel Pereira

Pedro Miguel Pereira vii

Índice

Agradecimentos ....................................................................................................................................... i

Resumo .................................................................................................................................................. iii

Abstract ................................................................................................................................................... v

Índice de figuras ..................................................................................................................................... ix

Abreviaturas ............................................................................................................................................ xi

1. Enquadramento ............................................................................................................................... 1

1.1 Introdução ..................................................................................................................................... 2

1.2 Análise top-down do sistema a desenvolver ..................................................................................... 3

1.3 Estrutura da dissertação ................................................................................................................. 6

2. Estado da Arte ................................................................................................................................. 7

2.1 Tipos de movimento ....................................................................................................................... 8

2.1.1 Controlo numérico convencional ................................................................................................. 8

2.1.2 Controlo numérico computadorizado (CNC) ................................................................................ 9

2.1.3 Controlo numérico direto (CND)................................................................................................ 10

2.1.4 STEP-NC .................................................................................................................................. 12

2.1.5 Controladores de movimento abertos ....................................................................................... 13

2.2 Softwares utilizados ...................................................................................................................... 14

2.2.1 AdvaNum ................................................................................................................................. 14

2.2.2 Mach ....................................................................................................................................... 15

2.2.3 FlashCut CNC .......................................................................................................................... 16

2.2.4 G-Wizard Editor ........................................................................................................................ 17

2.2.5 CamSoft .................................................................................................................................. 18

2.2.6 NI Motion Control ..................................................................................................................... 18

2.3 Resumo ....................................................................................................................................... 19

3. Célula de Trabalho ......................................................................................................................... 21

3.1 Especificações físicas ................................................................................................................... 22

viii Pedro Miguel Pereira

3.2 Measurement & Automation Explorer (MAX) .................................................................................. 24

3.3 Resumo ....................................................................................................................................... 26

4. Design da aplicação de software .................................................................................................... 29

4.1 Princípio de funcionamento da aplicação ...................................................................................... 31

4.2 Manipulação Automática .............................................................................................................. 32

4.2.1 Carregar Ficheiro ..................................................................................................................... 33

4.2.2 Ajuste de Offset ........................................................................................................................ 34

4.3 Manipulação Manual .................................................................................................................... 36

4.4 Resumo ....................................................................................................................................... 38

5. Implementação .............................................................................................................................. 41

5.1 Separar Texto ............................................................................................................................... 42

5.1.1 Determinar o valor de cada parâmetro da instrução .................................................................. 45

5.2 Iniciar movimento......................................................................................................................... 48

5.3 Ajuste de Offset ............................................................................................................................ 56

5.4 Resumo ....................................................................................................................................... 60

6. Resultados ..................................................................................................................................... 63

6.1 Separar texto............................................................................................................................... 64

6.2 Início do Movimento ..................................................................................................................... 70

6.3 Ajuste do Offset ............................................................................................................................ 74

6.4 Resumo ....................................................................................................................................... 77

7. Conclusão e Trabalho Futuro ......................................................................................................... 79

7.1 Conclusão .................................................................................................................................... 80

7.2 Trabalho Futuro ........................................................................................................................... 81

8. Referências Bibliográficas ............................................................................................................. 83

Anexo I Lista dos principais comandos do Código-G ............................................................................... 85

Pedro Miguel Pereira ix

Índice de figuras

Figura 1- Esquema de funcionamento do sistema a desenvolver. ..................................................................... 4

Figura 2 - Exemplo de comandos escritos em Código-G. .................................................................................. 5

Figura 3 - Unidade de controlo de um sistema de controlo numérico convencional [6]...................................... 8

Figura 4 - Sistema CNC [7]. ............................................................................................................................ 9

Figura 5 - Ferramenta para gerar Código-G graficamente [15]. ....................................................................... 15

Figura 6 - Interface gráfica do software Mach3 [17]. ...................................................................................... 16

Figura 7 - Indicação da linha do programa onde existe um erro relativamente ao valor máximo de uma

coordenada [19]. .......................................................................................................................................... 17

Figura 8 - a) Interface gráfica para sistemas de CNC a laser. b) Interface gráfica para sistemas de CNC de

torneamento. [22]. ........................................................................................................................................ 18

Figura 9 - Máquina XYZ utilizada no âmbito desta dissertação. ....................................................................... 22

Figura 10 - Interior e exterior do quadro elétrico............................................................................................. 23

Figura 11 - Controlador e interface constituintes do módulo eletrónico. .......................................................... 24

Figura 12 - Axis Configuration. ....................................................................................................................... 25

Figura 13 - Torque Setting. ............................................................................................................................ 25

Figura 14 - Control Loop Settings. ................................................................................................................. 26

Figura 15 - Fluxo de informação no programa. ............................................................................................... 31

Figura 16 - Fluxograma do carregamento de um ficheiro. .............................................................................. 33

Figura 17 - Geometria do movimento referido para realização de cortes. ........................................................ 35

Figura 18 - Deslocamento face à origem do movimento em causa. ................................................................ 36

Figura 19 - Definição de um movimento circular. ........................................................................................... 37

Figura 20 - Fluxo de informação referente à janela de manipulação manual. .................................................. 38

Figura 21 - Fluxograma explicativo do funcionamento interno da opção “Separar Texto”. ............................... 44

Figura 22 - Fluxograma explicativo do método utilizado para determinar os parâmetros. ................................ 45

Figura 23 - Sequência de procedimentos para testar o primeiro parâmetro de cada instrução. ....................... 47

Figura 24 - Representação esquemática referente a execução de uma instrução. ........................................... 49

Figura 25 - Sequência de funções utilizada para dar início ao movimento. ...................................................... 51

Figura 26 - Deslocamento do centro da circunferência no eixo do Y. .............................................................. 53

Figura 27 - Deslocamento do centro da circunferência no eixo do X. .............................................................. 53

Figura 28 - Angulo a percorrer entre 0º e 180º. ............................................................................................. 54

Figura 29 - Angulo a percorrer entre 180º e 360º. ......................................................................................... 55

Figura 30 - Rotação do movimento referido. .................................................................................................. 58

Figura 31 - Definição do ângulo de rotação. ................................................................................................... 58

x Pedro Miguel Pereira

Figura 32 - Fluxograma do processo de ajuste do offset. ................................................................................ 60

Figura 33 - Janela inicial da aplicação desenvolvida. ...................................................................................... 65

Figura 34 - Janela que possibilita a escolha entre ajustar o offset ou carregar um ficheiro. ............................. 65

Figura 35 - Janela que permite a procura, leitura e divisão de um ficheiro. ..................................................... 65

Figura 36 - Exemplo de Código-G para execução de movimentos retilíneos com velocidade pré-definida. ........ 66

Figura 37 – Condições utilizadas para determinar qual o tipo e qual o valor do caractere em causa. .............. 67

Figura 38 - Preenchimento dos vectores com os caracteres da terceira instrução do ficheiro carregado. ......... 67

Figura 39 - Excerto de código utilizado para determinar um parâmetro decimal constituído por três carateres.

.................................................................................................................................................................... 69

Figura 40 - Valor das posições pretendidas referentes ao eixo do X e do Y para cada instrução. ..................... 69

Figura 41 - Exemplo de Codigo-G para execução de movimentos com variação de velocidade. ....................... 70

Figura 42 - Utilização dos valores obtidos, durante a invocação de funções referentes ao movimento da

máquina. ...................................................................................................................................................... 70

Figura 43 - Exemplo de Código-G contendo um movimento circular com offset do centro em dois eixos. ......... 71

Figura 44 - Representação gráfica do movimento descrito no Código-G da imagem anterior. .......................... 71

Figura 45 - Movimento circular ampliado. ...................................................................................................... 72

Figura 46 – Excerto de Código referente à implementação dos cálculos referidos........................................... 73

Figura 47 – Invocação da função referente ao movimento circular, utilizando os valores calculados. .............. 73

Figura 48 – Código-G representativo do movimento que se pretende executar na placa. ................................. 74

Figura 49 - Exemplo de um deslocamento e rotação involuntária de uma placa onde se realizará um

movimento com a geometria descrita no Código-G apresentado. .................................................................... 74

Figura 50 – Janela referente à opção “Ajuste de Offset”. ............................................................................... 75

Figura 51 – Excerto de código referente à implementação dos cálculos efetuados para determinar o ângulo de

rotação. ........................................................................................................................................................ 76

Figura 52 – Preenchimento dos vectores com os valores calculados. ............................................................. 76

Figura 53 – Invocação da função referente ao movimento retilíneo, utilizando o novo valor calculado. ............ 77

Pedro Miguel Pereira xi

Abreviaturas

CAD- Computer Aided Design

CAE- Computed Aided Engineering

CAM- Computer Aided Manufacturing

CAPP- Computer Aided Process Planning

CNC- Computer Numeric Control

DNC- Direct Numerical Control

ISO- International Organization for Standardization

MAX- Measurement & Automation Explorer

NI- National Instruments

PC- Personal Computer

STEP- Standard for the Exchange of Product Model Data

UMI- Universal Motion Interface

PCI- Peripheral Component Interconnect

xii Pedro Miguel Pereira

Capítulo 1- Enquadramento Pedro Miguel Pereira 1

Capítulo 1

1. Enquadramento

Mestrado Integrado em Engenharia Eletrónica Industrial e de Computadores

2 Pedro Miguel Pereira Capítulo 1- Enquadramento

1.1 Introdução

Atualmente num contexto industrial, um sistema cujo objetivo seja o fabrico de um

produto final, necessita quase que de modo indispensável ter em atenção diversos fatores, tais

como o custo, a qualidade, a eficiência e o tempo de conceção do produto. Estes fatores

levaram à implementação de metodologias e ferramentas de desenvolvimento de produtos que

permitam atingir esse objetivo, nomeadamente a utilização dos sistemas computacionais CAD

(Computer Aided Design), CAE (Computed Aided Engineering) e CAM (Computer Aided

Manufacturing). Essencialmente, o software de desenho assistido por computador (CAD) está

encarregue de facilitar o desenvolvimento do projeto e desenho técnico de um determinado

produto que se pretenda fabricar [1], o software de engenharia assistida por computador (CAE)

está encarregue de simular numericamente o modelo projetado, e por fim, o software de

manufatura auxiliada por computador (CAM) está associado ao processo de manuseamento da

máquina. Fundamentalmente, numa primeira fase, um projeto desenvolvido num sistema

computacional de desenho assistido é exportado num ficheiro do tipo CAD e posteriormente

importado para os softwares CAE e CAM de modo a que estes possam cumprir o seu propósito.

Um dos pontos cruciais para o desenvolvimento desta dissertação encontra-se na exploração dos

ficheiros tipo CAD gerados por um sistema computacional de desenho assistido. Os ficheiros

CAD, tal como já foi referido, contêm o projeto e desenho técnico de uma peça/produto que se

pretende desenvolver, ou seja, contêm informação sobre as coordenadas, dimensões e outras

especificações desse mesmo produto. Essa informação, juntamente com as instruções

fornecidas pelo software de produção auxiliado por computador (CAM), é essencial para que o

produto desejado evolua de algo estruturado num ambiente computacional até a sua produção a

nível físico.

Atualmente, o manuseamento automático de máquinas a nível industrial é dominado

pelos sistemas de controlo numérico. Um sistema deste tipo é definido como a operação de uma

máquina através de um conjunto de instruções constituídas por números, letras do alfabeto e

símbolos que a unidade de controlo consiga interpretar [2]. Um sistema de controlo numérico

baseia-se numa lista de movimentos escrita num código específico, denominado de “Código-G”,

cuja função é construir a ponte entre o programador e a máquina que se pretende controlar. Nos

dias de hoje, esta lista de movimentos pode ser criada automaticamente pelos softwares de

desenho assistido por



computador. Existem inúmeras instruções escritas nesta linguagem, desde instruções de

movimentos lineares retilíneos ou curvilíneos até instruções que ordenam a troca de ferramenta

de trabalho. Programar um sistema através da utilização de Código-G é sem dúvida um método

preciso e fiável para se obter o produto final desejado, no entanto, as mesmas características

que fazem esta linguagem simples e de fácil implementação, também a tornam limitada e pouco

flexível. Com base nessas debilidades surgem novas soluções, nomeadamente os controladores

de movimento abertos. A sua grande flexibilidade e utilização de linguagens de programação de

alto nível, a facilidade de integração de novas técnicas de automação no sistema onde estão

inseridos e a sua capacidade de autodiagnosticar o sistema em caso de problema durante a

produção do produto, são apenas algumas características relevantes que os sistemas podem

adquirir com este tipo de controlo.

Posto isto, esta dissertação pretende integrar as vantagens evidentes provenientes da

utilização dos softwares de desenho assistido por computador e da fiabilidade do Código-G com

as vantagens dos controladores abertos. Neste sentido, é criado um sistema com os melhores

atributos destes dois métodos de controlo, aumentando assim o leque de aplicações associadas

a sistemas baseados na utilização do Código-G, pois devido à flexibilidade dos controladores

abertos já referida anteriormente, será possível não só integrar facilmente diferentes periféricos

em sistemas onde previamente seria excessivamente complexo, como também surge a

possibilidade de introduzir novos atributos no sistema, desde a implementação de técnicas

avançadas de controlo até à interação direta com o ambiente em que está inserido.

O produto final obtido resultante desta dissertação de mestrado permite que um

sistema, cujo funcionamento se baseie em processos automáticos para o manuseamento de

uma máquina, adquira novas características essenciais para um eficaz acompanhamento da

evolução tecnológica.

1.2 Análise top-down do sistema a desenvolver

No âmbito do funcionamento deste sistema, o objetivo desta dissertação de mestrado é

então desenvolver uma aplicação que interprete os comandos escritos em Código-G, realize a

sua conversão para uma linguagem de alto nível e permita a respetiva execução do movimento

dos eixos.



Figura 1- Esquema de funcionamento do sistema a desenvolver.

De um modo sequencial, o funcionamento do sistema que se pretende desenvolver é o

seguinte: numa primeira fase é projetado o produto num software de desenho assistido por

computador, de seguida é gerado o Código-G correspondente ao mesmo, posteriormente através

de uma interface gráfica esse código é convertido para uma linguagem de alto nível interpretável

pelos controladores abertos da “National Instruments” (NI) e por fim esse novo código é

implementado numa máquina de três eixos que utiliza o toolkit de Motion Control da NI. A

interface gráfica referida será desenvolvida utilizando a linguagem de programação C#. Esta

linguagem permite não só conceber de um modo simples e eficaz um ambiente gráfico completo

e amigável para o utilizador, assim como possibilita a interação com diversos periféricos de

modo descomplicado. Nesta interface o ponto fulcral será o interpretador de Código-G, cuja

implementação passa por três pontos essenciais: primeiramente uma análise lexical, de seguida

uma análise sintática e por fim a conversão propriamente dita [3]. Tipicamente uma instrução

deste tipo tem o seguinte aspeto: “N…G…X…Y…Z…A…B…C…M…S…T…F…(END)” [3]. Cada

letra de um comando escrito nesta linguagem de programação tem associada um conjunto de

funções específicas e é denominada de “Address Character”, isto é, por exemplo, o caractere

especial “N” indica-nos o número da linha de uma determinada instrução, o caractere especial



“G” refere-se a um conjunto de comandos preparatórios, o caractere “M” está associado a

funções relacionadas com a máquina, entre outros. Estes caracteres especiais seguidos de um

valor numérico ou expressão dão origem às “Words” da instrução [4], por exemplo, adicionando

o valor numérico “01” logo de seguida ao caractere “G”, obtemos a Word “G01” que nos indica

que será realizada uma interpolação linear, outro exemplo seria a utilização da letra “M” para

formar a Word “M06”, indicativa de uma mudança automática de ferramenta. A figura seguinte

tem como objetivo demonstrar a estrutura de uma instrução de um ficheiro escrito em Código-G.

As combinações possíveis para criar uma instrução são imensas, no entanto devido a

detalhada documentação já existente sobre o significado de cada combinação [3], é possível

obter facilmente o seu objetivo. A visualização do Anexo 1 permite obter uma melhor perceção

sobre o propósito dos principais comandos escritos em Código-G. Posto isto, numa primeira

instância da aplicação, após a leitura de uma linha escrita nesta linguagem, esta é dividida em

várias partes de modo a conseguir identificar-se a utilização de alguma letra não reconhecida

pelo sistema ou se o valor de uma determinada Word se encontra fora dos limites.

Seguidamente é realizada uma análise sintática que permite a deteção de erros lógicos

associados à sintaxe na escrita de comandos em Código-G. Por fim, após serem verificados os

dois primeiros pontos, é efetuada a conversão dessa instrução para uma linguagem de alto nível

de acordo com as bibliotecas utilizadas pelos controladores da NI. Após concebido este software,

serão então realizados testes na máquina referida de modo a corroborar a funcionalidade do

mesmo.

Instrução

Word

Address Character

Figura 2 - Exemplo de comandos escritos em Código-G.



1.3 Estrutura da dissertação

A estrutura desta dissertação concebeu-se de acordo com os processos de desenvolvimento da

mesma.

No primeiro capítulo, “Enquadramento”, é realizada uma introdução com o propósito

contextualizar e expor o objetivo desta dissertação. É efetuada também uma análise top-down do sistema

a desenvolver com o intuito de mostrar a estrutura do mesmo.

Após realizada essa introdução, no capítulo dois, denominado de “Estado da Arte”, é realizada

uma revisão bibliográfica sobre a evolução dos sistemas de controlo utilizados na indústria, assim como

quais as interfaces utilizadas para interagir com os mesmos.

Segue-se então o terceiro capítulo, “Célula de Trabalho”, cujo propósito é expor a análise

realizada ao sistema físico no qual será executada a aplicação desenvolvida no âmbito desta dissertação.

Posto isto, o capítulo quarto aborda detalhes mais específicos sobre o software a desenvolver.

Denominado de “Design da aplicação de software”, neste capítulo recorrendo a fluxogramas e figuras

explicativas, é mostrada a estrutura da aplicação a nível de organização de processos, com o principal

intuito de facilitar a perceção do funcionamento do programa concebido.

Neste sentido, o capítulo cinco, “Implementação”, vem complementar o capítulo anterior,

especificando os métodos e procedimentos utilizados para transformar a estrutura projetada, num

software concreto e funcional. Novamente com auxílio de fluxogramas, figuras explicativas e ainda

apresentando os cálculos efetuados durante a execução de diversos processos, são então abordados os

métodos de programação utilizados para o desenvolvimento desta aplicação.

O capítulo seis, “Resultados”, vem corroborar todo o trabalho efetuado, ou seja, neste capítulo,

não é só demonstrado o bom funcionamento de todas as funcionalidades referidas sobre a aplicação

concebida, como também é exposta a interface desenvolvida que possibilita a interação entre o utilizador

e a célula de trabalho.

No capítulo sete, é apresentada uma conclusão relativamente ao processo de desenvolvimento

desta dissertação, assim como são comentados os resultados obtidos face aos resultados esperados. Por

fim, ainda neste capítulo, são propostas algumas sugestões para complementar o trabalho efetuado no

âmbito desta dissertação.

Capítulo 2- Estado da Arte Pedro Miguel Pereira 7

Capitulo 2

2. Estado da Arte


8 Pedro Miguel Pereira Capítulo 2- Estado da Arte

2.1 Tipos de movimento

2.1.1 Controlo numérico convencional

Os sistemas de controlo numérico convencional serviram de base para o

desenvolvimento de grande parte dos controladores aplicados atualmente para o manuseamento

automático de máquinas em processos industriais. Constituídos por uma unidade de controlo,

representada na figura 3, e a máquina que se pretende operar, os sistemas de controlo

numérico convencional vieram revolucionar por completo o processo de fabrico de um produto a

nível industrial [5].

Figura 3 - Unidade de controlo de um sistema de controlo numérico convencional [6].

A diminuição dos custos de produção, derivado do tempo não produtivo reduzido, a

precisão da peça concebida e o aumento da qualidade do produto final, são apenas alguns

atributos positivos presente nas linhas de produção devido à utilização destes sistemas.

O método mais utlizado para programar o controlador referido baseava-se na criação de

programas através da realização de perfurações numa fita, com uma determinada

predisposição. Essa fita perfurada, era então colocada no controlador, cuja função seria

interpretar esses furos de modo a conseguir manipular a máquina conforme pretendido pelos

criadores do programa. Assim que o produto final estivesse terminado, bastava colocar de novo

a fita na unidade de controlo para repetir o processo. De notar que estes programas em fita

perfurada eram concebidos de acordo com as limitações físicas da máquina, e por isso era

necessária a utilização de um pós-processador dedicado especificamente para cada máquina do

Leitor de fita

perfurada



sistema, com a capacidade de efetuar a tradução das perfurações realizadas, em movimentos a

executar pelas mesmas.

Derivado da rápida evolução tecnológica, o método de programação utilizado pelos

sistemas de controlo numérico convencional tornou-se quase obsoleto, pois face ao crescimento

da capacidade de processamento dos microprocessadores, a relação entre a complexidade na

criação de programas em fitas perfuradas e o produto final obtido, deixou de ser benéfica. Assim

sendo, surgem então os sistemas de controlo numérico computadorizado.

2.1.2 Controlo numérico computadorizado (CNC)

Um sistema de controlo numérico computadorizado, por definição, consiste na operação

de uma máquina através de um conjunto de instruções constituídas por números, letras do

alfabeto e símbolos que a unidade de controlo consiga interpretar [2].

Este tipo de sistema, ilustrado na figura 4, também é constituído pela unidade de

controlo e a máquina que se pretende operar, no entanto apresenta um novo método para

criação de programas e utiliza tecnologia mais avançada comparativamente à do controlo

numérico convencional. Derivado desses atributos, entre outras vantagens, destacam-se o

aumento da complexidade e precisão das peças a produzir [5], a realização de um trabalho

uniforme e sem intervenção humana direta na peça e a edição de programas junto à máquina.

Figura 4 - Sistema CNC [7].

A criação de programas em Código-G é o método mais utilizado para programar este tipo

de sistemas [8]. De acordo com a definição anteriormente apresentada, é num ficheiro escrito

em Código-G que estão contidas as instruções concebidas pelo programador alusivas aos

movimentos a serem executados pela máquina. Esta nova linguagem de programação começou

a ser largamente utilizada por imensos fabricantes e equipas de desenvolvimento de máquinas

Computador

embutido Zona de

manuseamento

do produto



CNC em todo o mundo, dando origem a diversas normalizações cujo objetivo seria criar um

formato geral de programação para sistemas de controlo numérico computadorizado. Embora

existam algumas normalizações que se destacam, como a norma ISO 6983 [5] [8], a nível

mundial não existe um consenso quanto a que norma deva ser utilizada.

Convém salientar que em sistemas CNC, o programa é desenvolvido de acordo com as

características físicas da máquina, tal como no controlo numérico convencional, e por isso

continua a ser necessário utilizar um pós-processador dedicado que tem como função interpretar

as instruções do ficheiro concebido em Código-G e traduzi-las para a máquina em causa [9].

Neste sentido, embora este tipo de controlo seja utilizado em grande escala a nível industrial, os

sistemas CNC também acarretam algumas desvantagens significativas, nomeadamente a nível

de hardware, devido à dificuldade inerente face à inserção de novos componentes ou à utilização

de novas técnicas de automação no sistema [10], a nível económico, pois o custo para adquirir

uma máquina CNC é consideravelmente elevado, e ainda a nível funcional, pois é de evidenciar

que este tipo de controlo não elimina completamente erros humanos, e muito dificilmente

fornece informação em tempo real sobre o estado do processo, fatores que são frequentemente

essenciais para o correto funcionamento de qualquer sistema.

Posto isto, novamente devido à progressiva evolução da tecnologia, a capacidade de

processamento do sistema de controlo embutido na máquina tornou-se limitada relativamente à

oferta no mercado. Contudo e principalmente devido à sua fiabilidade, precisão e fluência do

processo de produção, estes sistemas continuam a ser utilizados nos dias de hoje.

2.1.3 Controlo numérico direto (CND)

Um sistema que utilize controlo numérico direto pode ser definido como um sistema

baseado na utilização de um computador com a capacidade de operar diversas máquinas,

através de uma ligação direta e a tempo real.

Um sistema CND é, também, constituído por um controlador e a máquina que se deseja

operar, no entanto relativamente aos sistemas referidos anteriormente é acrescentada a

utilização um PC externo cuja capacidade de processamento é superior à dos processadores

utilizados até então nos sistemas CNC. O controlador destes sistemas continua a possuir um

pós-processador dedicado com a função descrita anteriormente, porem, o processamento de

informações técnicas essenciais para a manipulação da máquina deixa de ser efetuado por

hardware embutido nela mesma e passa a ser efetuado por hardware externo. Algumas das



vantagens inerentes à utilização destes sistemas são, o aumento da complexidade do produto

final, a possibilidade de controlar várias máquinas através de um só computador, a capacidade

de guardar um grande número de programas devido à utilização de memórias externas, a

facilidade de fazer upload dos programas desenvolvidos para o controlador, a flexibilidade na

criação e edição de programas, a possibilidade de utilizar softwares CAM e ainda a capacidade

de incluir no sistema interação entre ficheiros CAD, CAE e as máquinas que se pretendem

controlar.

Devido aos evidentes melhoramentos que a interação entre modelos CAD, CAE e CAM

fornece para um sistema, estes começaram a ser muito utilizados em diversas industrias. Ao

realizar funções industriais auxiliadas por computador, o processo de criação de um produto

final adquire atributos que são extremamente importantes e quase essenciais nos sistemas de

automação atuais, tais como, a simulação a duas e a três dimensões do design do produto final,

a eliminação de erros durante o projeto de uma peça, a visualização passo a passo do

manuseamento da peça efetuado pela máquina e ainda a imensa facilidade de partilha de

ficheiros CAD entre clientes e fabricantes.

A utilização massiva dos métodos computacionais referidos (CAD, CAE e CAM) deu

origem então ao aparecimento da norma internacional ISO 10303, também conhecida como

STEP (Standard for the Exchange of Product Model Data). Esta norma pretende uniformizar o

modo como se descreve informações digitais sobre um produto, de modo a que seja possível

uma partilha, entre sistemas, eficaz e rápida dos dados técnicos do mesmo [5] [11].

Novamente devido à evolução tecnológica, os sistemas de controlo numérico direto

adquiriram uma nova característica, a possibilidade de efetuar ligações sem fios. Os sistemas

que aplicam este método de controlo sem fios têm uma estrutura semelhante aos sistemas que

utilizam CND com ligações por cabo, no entanto efetuam a comunicação com os controladores

de cada máquina via wireless, oferecendo assim ao programador não só uma melhor supervisão

sobre todas as máquinas em funcionamento, sem a necessidade de realizar numerosas e por

vezes complexas ligações, como também uma maior facilidade para realizar uploads e

downloads entre o PC externo e o controlador.

Proveniente da robustez e versatilidade deste sistema, muitas são as indústrias que o

utilizam, como por exemplo a indústria Automóvel e a indústria Aeronáutica. Como é percetível,

esta metodologia contém características essenciais e altamente apelativas para um excelente

funcionamento de qualquer processo de produção industrial.



Contudo, derivado da exponencial evolução da tecnologia informática, atualmente as

máquinas de controlo numérico computacional utilizam processadores rápidos com capacidade

de utilização de memória interna elevada, tornando acessíveis diversos recursos que inicialmente

só estavam disponíveis em sistemas de controlo direto.

Em suma, quer os sistemas de controlo numérico computadorizado, quer os sistemas

de controlo numérico direto, wireless ou por ligação direta, são sistemas fortemente testados na

indústria e com características fundamentais para qualquer processo de manuseamento

automático de máquinas, todavia todos eles utilizam a definição apresentada inicialmente, ou

seja, todos eles se baseiam em controladores que processam instruções em Código-G, utilizando

a norma ISO 10303 para partilha de dados, algo que pode ser extremamente desvantajoso

devido às debilidades que essa característica traz para um sistema, principalmente no que diz

respeito à grande complexidade inerente face à inserção de novos componentes ou mesmo à

utilizaçã de técnicas mais avançadas.

2.1.4 STEP-NC

A grande dificuldade em integrar um fluxo bidirecional de informação no sistema, a

necessidade de elaboração de programas demasiados complexos para realizar um

manuseamento simples e o facto de ser quase impossível utilizar o mesmo Código-G em duas

máquinas CNC diferentes [8], são algumas das principais falhas inevitáveis dos sistemas de

controlo numérico atualmente utilizados na indústria. Com a finalidade de corrigir essas

debilidades surgem os sistemas baseados na norma ISO 14649, também conhecida como

STEP-NC. Tal como intuitivamente é sugerido através do nome, esta norma está relacionada

com a norma STEP (ISO 10303) referida anteriormente, mais especificamente, a norma STEP-

NC é uma extensão da norma STEP [12], ou seja, esta norma pretende também uniformizar o

modo como se deve realizar a partilha de informação digital sobre um produto, no entanto visa

ainda integrar o planeamento do processo de fabrico desse mesmo produto ou peça nessa

partilha de dados entre sistemas [5] [11] [13].

As vantagens inerentes à utilização deste tipo de controlo são, a adaptação dos

programas desenvolvidos às limitações da máquina, o fluxo bidirecional de informação, uma

maior autonomia por parte do sistema, um maior controlo por parte do utilizador e ainda o

armazenamento de toda a informação relativa sobre um produto num só ficheiro, conseguindo



assim acrescentar a possibilidade de integrar os modelos computacionais CAPP (Computer

Aided Process Planning) no sistema.

Embora estes sistemas tenham uma constituição semelhante aos sistemas de controlo

numérico direto já referidos, ou seja, compostos por um controlador, a máquina que se pretende

operar e um PC externo para fazer o processamento dos dados técnicos, ao contrário dos outros

sistemas que utilizam como base o Código-G e um pós-processador dedicado para cada

máquina, os sistemas STEP-NC possuem controladores capazes de interpretar diretamente os

dados provenientes dos ficheiros que contêm toda a informação referida [8] e traduzi-los para a

máquina, fornecendo automaticamente feedback ao utilizador sobre a possibilidade de execução

ou não das operações pretendidas no seu sistema.

A nível industrial este tipo de sistemas ainda não é muito usual, pois é um conceito

recente que necessita de ser testado e validado, contudo, derivado da capacidade de interação

entre os softwares CAD, CAE, CAM e CAPP, os sistemas baseados na norma STEP-NC são

altamente apelativos para qualquer tipo de indústria, colocando-os numa posição privilegiada

para revolucionar novamente os métodos de produção industriais atualmente dominados pelos

sistemas de controlo numérico.

2.1.5 Controladores de movimento abertos

Após realizada a análise dos sistemas de controlo numérico e dos sistemas STEP-NC, é

por fim abordado um tipo de controlo denominado de “Controlo Aberto”. Semelhantemente aos

sistemas descritos, estes são constituídos por um computador, um controlador e a máquina a

operar. Porém, a grande diferença relativamente aos sistemas referidos anteriormente encontra-

se principalmente nas características apelativas dos controladores utilizados, destacadamente, a

sua alta flexibilidade, a facilidade na criação de programas, a não exclusividade para cada

máquina e o muito baixo custo. Estes controladores possuem bibliotecas de funções próprias e

utilizam linguagens de alto nível comparativamente ao Código-G, facilitando assim a integração

de novas características no sistema, desde a interação entre a máquina e novos componentes

até à utilização de novas técnicas de controlo.

Atualmente os fabricantes destes controladores fornecem o software que permite a

programação dos mesmos, ficando a cargo do utilizador adaptar os controladores à máquina

que pretende controlar. Este novo método de programação de controladores permite não só uma



benéfica relação entre a complexidade da criação de programas e o manuseamento da máquina

pretendido, como também o desenvolvimento de softwares de simulação dedicados.

Embora estes controladores sejam extremamente apelativos a nível de custos e

funcionalidades, o facto de não se basearem em nenhuma das normas referidas e o facto de

representarem uma técnica de controlo para processos de fabrico industriais relativamente

recente, são duas das principais desvantagens em comparação com os sistemas de controlo

numérico atuais, contudo a panóplia de características apresentadas anteriormente que os

controladores de movimento abertos trazem para um sistema, é indicativa de um futuro

promissor na sua utilização a nível industrial.

2.2 Softwares utilizados

Presentemente, os softwares existentes para sistemas que implementam controlo

numérico direto, controlo numérico computacional ou controlo aberto, possuem atributos

essenciais para a operação de uma máquina de modo seguro, eficaz e simples. De seguida

serão abordados alguns dos softwares atualmente utilizados, apresentando as suas interfaces,

quer para execução de movimentos, quer para a simulação dos mesmos, com o intuito de

facilitar o entendimento das funcionalidades destas ferramentas computacionais, e ainda

destacando determinados atributos de maior interesse.

2.2.1 AdvaNum

Os softwares da AdvaNum são programas computacionais utilizados para simulação e

manuseamento de máquinas de controlo numérico, destacando-se particularmente os softwares

“AdvaNum NC Verification ” e “AdvaNum NC Editor”. Como principais características, o software

AdvaNum NC Verification distingue-se pela sua capacidade de simular o comportamento da

máquina utilizando modelos sólidos realistas, pela possibilidade de fazer o debug de um

programa escrito em Código-G utilizando breakpoints e também pela aptidão de executar o

programa step-by-step se o utilizador assim pretender [14].



Figura 5 - Ferramenta para gerar Código-G graficamente [15].

O software AdvaNum NC Editor é uma ferramenta bastante útil para editar programas

criados pelo utilizador ou até mesmo importados de outra fonte, disponibilizando as funções

básicas de copiar, colar, cortar e substituir e ainda oferecendo a possibilidade de desenvolver

um programa em Código-G de um modo gráfico, figura 5.

Este conjunto de softwares da AdvaNum é bastante interessante para quem pretende

criar um sistema de controlo numérico direto com uma boa capacidade de simulação e também

pretenda desenvolver os seus próprios programas em Código-G.

2.2.2 Mach

Outro exemplo de um programa utilizado em sistemas de controlo numérico é o

“Mach3”. Este software disponibiliza ferramentas para gerar Código-G automaticamente, permite

a utilização do software através de SmartPhones e tem como característica principal a

capacidade de “transformar” um computador num controlador CNC para máquinas de até 6

eixos [16]. A sua interface gráfica é extremamente completa e diversificada, Figura 6, com a

capacidade de gerar pulsos e alterar o valor das variáveis manualmente, visualizar os

movimentos da máquina em tempo real e ainda com a possibilidade de ser adaptada para a

vertente de ecrã táctil.



Figura 6 - Interface gráfica do software Mach3 [17].

É de salientar que embora este software transforme um PC num controlador para

máquinas de controlo numérico, é sempre necessário a utilização de um pós-processador

dedicado à máquina em questão. Não obstante, o Mach3 é muito completo e com

características bastante apelativas para a conceção de sistemas de controlo numérico robustos e

fiáveis.

2.2.3 FlashCut CNC

Os produtos da FlashCut CNC são excelentes soluções para quem pretende conceber

um sistema de controlo numérico completo e fácil de implementar. Os controladores fornecidos

pela empresa utilizam um software denominado de “FlashCut CNC 4.5”, que possui

diversificadas e excelentes capacidades, destacando-se, a fácil configuração do software ao

sistema onde vai ser utilizado, o fornecimento de informação que relaciona os limites físicos da

máquina com os valores das coordenadas das instruções escritas em Código-G, Figura 7, e

ainda a capacidade de executar ficheiros inversamente [18].



Figura 7 - Indicação da linha do programa onde existe um erro relativamente ao valor máximo de uma coordenada [19].

Convém também salientar que este software possui uma capacidade de previsão para o

tempo de execução do ficheiro carregado muito precisa, característica muito útil para realizar um

planeamento diário de produção normalmente necessário a nível industrial. Neste sentido, as

características de caracter prático deste software fazem dele um grande candidato para quem

pretende construir um sistema CNC pronto a utilizar.

2.2.4 G-Wizard Editor

O “G-Wizard Editor” é um completo, simples e poderoso software de edição, simulação e

debug de ficheiros escritos em Código-G. Os atributos a destacar desta ferramenta

computacional são a capacidade de verificar os percursos através de visualização gráfica,

simular a execução de ficheiros escritos em Código-G para realização de debug do programa,

disponibilização detalhada durante a simulação do valor de diversas variáveis características de

sistemas CNC, tais como, valor das coordenadas e velocidade de rotação, e ainda tem a

capacidade de fornecer “dicas” [20] que auxiliam a edição de programas para utilizadores

menos experientes.

Este software possui também a particularidade de fornecer a opção de configurar o

ambiente de simulação de acordo com diversos pós-processadores atualmente disponíveis no

mercado, permitindo assim descobrir erros no PC e não na máquina [20].

Posto isto, este software é muito interessante pois para além de ser completo na análise

de programas escritos em Código-G, é também bastante realista na simulação dos mesmos.



2.2.5 CamSoft

O software “CNC Professional Version 17.7” apresentado pela CamSoft é uma das

ferramentas computacionais mais completas a nível de funcionalidades atualmente existentes no

mercado. A possibilidade de visualização da máquina através de um ambiente gráfico enquanto

esta efetua as operações, a capacidade de inserir cálculos matemáticos nos programa escritos

em Código-G [21], a possibilidade de simular o estado de um pino E/S e ainda a utilização de

um método revolucionário que converte desenhos gráficos diretamente para movimentos de

eixos, são alguns dos atributos que contribuem para incentivar a aquisição deste software.

a) b)

Figura 8 - a) Interface gráfica para sistemas de CNC a laser. b) Interface gráfica para sistemas de CNC de torneamento. [22].

Dos imensos atributos interessantes desta ferramenta computacional, é de salientar

particularmente a nível de interface, os diferentes tipos disponíveis consoante o sistema CNC em

causa, Figura 8, assim como a disponibilidade de personalizar a interface de acordo com as

preferências do utilizador. Neste sentido, para além de ser um programa computacional

completo, destaca-se também pela sua grande capacidade de personalização, o que o torna

num software bastante apelativo.

2.2.6 NI Motion Control

O software “NI Motion Control” foi concebido para programação de controladores

abertos da National Instruments. Este é um software poderoso para programação de

controladores abertos que permite uma boa exploração das características que este tipo de

controlo tem para oferecer, nomeadamente, técnicas avançadas para feedback de sistemas em

malha fechada, high-performance e high-speed synchronization entre os pinos de entrada e saída



e ainda uma completa biblioteca de funções que pode ser acedida através das linguagens de

programação C, Visual Basic ou LabVIEW [23].

O “NI Motion Assistant”, tal como o nome indica, serve para auxiliar a implementação

das técnicas referidas, pois entre outras funcionalidades, permite a criação de trajetórias de

forma rápida e sem recurso à escrita de ficheiros em Código-G, simular esses mesmos

movimentos e ainda gerar código em linguagem C ou LabVIEW automaticamente (de acordo

com a biblioteca de funções da NI) a partir dessa simulação [24].

O “NI Motion Control” possui também a possibilidade de associar o módulo “LabVIEW

NI SoftMotion ”. A utilização deste módulo possibilita o desenvolvimento de aplicações para

controlo de movimentos através do ambiente gráfico do LabVIEW, uma funcionalidade que pode

bastante vantajosa para a configuração, teste e ajuste de um sistema [25] .

Posto isto, no que diz respeito ao desenvolvimento de programas para sistemas de

manuseamento automático de máquinas baseados em controladores abertos da NI, os softwares

referidos da National Instruments constituem uma ferramenta simples e intuitiva para a

programação dos mesmos.

2.3 Resumo

O estudo do funcionamento dos sistemas de controlo utilizados atualmente na indústria

é um importante ponto de partida para o desenvolvimento de qualquer aplicação que vise utilizar

um determinado método de controlo para manipular uma ou um conjunto máquinas. No âmbito

desta dissertação em particular, a nível de funcionalidades a implementar na aplicação de

software que se pretende desenvolver, o estudo dos sistemas de controlo numérico

computadorizado e dos sistemas de controlo aberto, permitiram obter uma melhor perceção

sobre quais os atributos de cada um deles, de modo a ser possível integra-los num só sistema. A

nível de interação com o utilizador, a pesquisa referente às interfaces e softwares atualmente

utilizados para comunicar entre o operador, o sistema de controlo e a máquina, foi de elevada

importância para realizar o design da aplicação de forma mais simples, completa e robusta.

Posto isto, após realizado um levantamento das tecnologias e softwares utilizados na

indústria atual no âmbito desta dissertação, será então efetuada uma análise da célula de

trabalho com o intuito de agregar os conhecimentos adquiridos durante a elaboração deste

estado da arte, com as capacidades e limitações do sistema onde será executada a aplicação a

desenvolver.



Capítulo 3- Célula de trabalho Pedro Miguel Pereira 21

Capítulo 3

3. Célula de Trabalho


22 Pedro Miguel Pereira Capítulo 3- Célula de trabalho

Primeiramente convém salientar que nenhuma montagem, quer mecânica, quer elétrica,

referente à célula de trabalho que vai ser abordada neste capítulo, foi concebida no âmbito do

desenvolvimento desta dissertação. Assim sendo, será efetuada uma análise superficial do

sistema físico utilizado, não obstante, para desenvolver o software pretendido é essencial

perceber o seu funcionamento, assim como os limites físicos, do sistema que se pretende

controlar.

3.1 Especificações físicas

A célula de trabalho que serviu de base para a implementação desta aplicação de

software é composta por três módulos principais, nomeadamente o módulo mecânico, o módulo

elétrico e o módulo eletrónico. O módulo mecânico é constituído por três eixos X, Y, e Z, três

servomotores para manipulação dos mesmos e a própria estrutura que suporta estes

componentes mecânicos, representada na Figura 9. Esta máquina possui uma área de trabalho

com as seguintes dimensões, 150x120x80mm, aproximadamente, representando diretamente

os valores máximos para os movimentos dos eixos X, Y e Z, respetivamente. A nível de

movimento do cursor da máquina, cada servomotor foi acoplado a um eixo e tem como função

movimenta-lo de acordo com as ordens provenientes das servodrivers.

Figura 9 - Máquina XYZ utilizada no âmbito desta dissertação.

Máquina

XYZ



No que diz respeito ao módulo elétrico deste sistema, este é constituído essencialmente

pelo quadro elétrico projetado e concebido para o mesmo, visível na Figura 10. Para além de ser

concebido com o propósito de realizar a interface entre a componente de potência e a

componente de controlo, este quadro elétrico está também encarregue de garantir que sistema

opere em condições de segurança. É de salientar que também foi instalado um sistema de

emergência, com o propósito de acionar uma paragem instantânea do módulo mecânico, caso o

utilizador detete algo não esperado.

Figura 10 - Interior e exterior do quadro elétrico.

O quadro contém ainda três servodrivers da SEW-Eurodrive, que têm como

funcionalidade efetuar a comunicação entre os servomotores e o controlador utilizado. Cada

servodriver possui um display de 7 segmentos com o propósito de informar o utilizador sobre o

seu estado de utilização. No arranque do sistema o valor zero é mostrado para informar que

ainda não é possível iniciar a comunicação entre o controlador e o sistema mecânico. Assim que

for mostrado o número um, estão reunidas as condições para dar início às inicializações da

placa de controlo. Posto isto, após essas inicializações estarem definidas, o sistema está pronto

para executar o movimento dos eixos, fornecendo como feedback o numero cinco.

Servodrivers

Botão de

Emergência

Interruptor de

acionamento



Por fim, o módulo eletrónico deste sistema engloba a utilização do controlador PCI-7344

e da interface UMI-7764, ambos da National Instruments, Figura 11. Entre outras

características, este controlador de movimento, PCI-7344, tem a capacidade de controlar até

quatro eixos, permite interpolações lineares, circulares, elípticas e esféricas, e é compatível com

as plataformas NI Measurement & Automation, NI Motion Assistant, NI LabVIEW, Microsoft C++ e

Microsoft Visual Basic. A UMI (Universal Motion Interface), tal como o nome indica, é o aparelho

utilizado para realizar a interface entre o controlador e as servodrivers que controlam os motores.

Figura 11 - Controlador e interface constituintes do módulo eletrónico.

Derivado do controlador escolhido, é possível aplicar ao sistema um método de controlo

aberto, usufruindo assim das diversas vantagens já referidas. No entanto, confirmando o que já

foi abordado anteriormente sobre este tipo de controlo, é de salientar que toda a montagem

mecânica, desde os eixos e a estrutura que os suporta, até ao acoplamento dos motores, foi

realizada por parte da entidade que optou por utilizar as placas de controlo da NI.

3.2 Measurement & Automation Explorer (MAX)

De modo a realizar uma análise completa do sistema utilizado, é necessário também

abordar o software MAX, fornecido pela National Instruments. Este software não só é utilizado

para configurar o controlador, como também é utilizado para parametrizar as servodrivers

referidas. Esta ferramenta computacional permite ainda executar alguns movimentos simples de

modo a verificar se as parametrizações estão realmente a ser aplicadas ou se ocorreu algum

imprevisto, fornecendo neste sentido feedback quanto ao estado do controlador.

De seguida serão expostas algumas imagens com o objetivo de demonstrar como são

realizadas algumas das parametrizações com recurso a este software.

UMI-7764

PCI-7344



Figura 12 – “Axis Configuration”.

A Figura 12 expõe a janela respetiva à configuração de um eixo. No menu do lado

esquerdo, é escolhido o eixo que se pretende parametrizar, e através da opção “Axis

Configuration” é possível especificar o tipo de motor que está a ser utilizado, especificar o tipo

de feedback e habilitar ou não o eixo selecionado.

Figura 13 – “Torque Setting”.

A Figura 13 representa a possibilidade de escolha por parte do utilizador do valor de

tensão que o terminal analógico deve enviar para o servodrive, definindo assim se os

movimentos de cada eixo serão mais repentinos (torque elevado) ou mais suaves (torque baixo).



Figura 14 – “Control Loop Settings”.

A imagem acima representa a possibilidade de definição dos parâmetros relativos ao

controlo do movimento propriamente dito, desde ganho proporcional, ganho integral e ganho

derivativo, até ao possível ganho de uma realimentação negativa de velocidade.

É de salientar que cada eixo pode ter configurações diferentes, ficando a cargo do

utilizador realizar e estudar aquilo que se adequa ao seu objetivo final. Neste sentido, após todas

configurações e parametrizações estarem concluídas para todos os eixos, as alterações

efetuadas são gravadas e a placa é inicializada com os valores definidos.

3.3 Resumo

Em suma, embora o objetivo desta dissertação seja o desenvolvimento de uma aplicação

de software, é importante perceber o contexto real a que a execução do mesmo se destina,

considerando todos os aspetos referidos neste capítulo. O conhecimento adquirido sobre os

constituintes físicos do sistema, designadamente sobre as componentes mecânica, elétrica e

eletrónica, e também sobre a ferramenta referente à parametrização do controlador, representa

não só uma parte essencial para que o objetivo desta dissertação fosse cumprido, como também

permitiram a nível pessoal adquirir uma nova sensibilidade para sistemas industriais.



Neste sentido, após analisadas as especificações do sistema, procedeu-se então a uma

ponderação sobre quais as instruções passiveis de serem executadas nesta célula de trabalho, e

qual o design da aplicação a adotar para que essas instruções consigam ser executadas.



Capítulo 4 - Design da aplicação de software Pedro Miguel Pereira 29

Capítulo 4

4. Design da aplicação de software


30 Pedro Miguel Pereira Capítulo 4 - Design da aplicação de software

Embora o objetivo desta dissertação já tenha sido exposto no primeiro capítulo, ainda que

de um modo generalista, antes de se proceder à explicação do design utilizado para o

desenvolvimento desta aplicação de software, convém detalhar um pouco o que se pretende

obter como produto final, para que toda a informação constituinte deste capítulo seja mais

facilmente entendida.

Neste sentido, após a análise do sistema físico, efetuou-se uma ponderação sobre quais

as instruções em código-G que se pretendem executar neste sistema, dentro das suas

características físicas. Considerando o contexto prático em que esta dissertação se enquadra e a

célula de trabalho descrita, definiu-se que o sistema deveria reconhecer as instruções G00, G01,

G02, G03, G20, G21, G22, G90 e G91. As primeiras quatro Words são referentes ao movimento

do cursor da máquina, mais especificamente, as instruções G00 e G01, são utilizadas para

realização de movimentos retilíneos em um, dois ou três eixos, contendo apenas uma diferença

entre elas relativamente à velocidade do movimento, dado que a Word G00 utiliza uma

velocidade pré-definida ao invés da Word G01 que possibilita a alteração de velocidade do

movimento em causa. As instruções G02 e G03, são referentes a movimentos circulares no

sentido horário e anti-horário respetivamente, e nenhuma delas permite alterar a velocidade que

está a ser utilizada para o movimento da máquina. Por outro lado, as Words G20, G21, G90 e

G91, não estão ligadas diretamente ao movimento da máquina mas sim às especificações

relativas ao ficheiro carregado. Mais detalhadamente, as instruções G20 e G21, representam a

unidade métrica a ser utilizada durante o processo de determinação dos parâmetros de cada

instrução, sendo que o valor 20 indica que o ficheiro carregado foi projetado em inches e o valor

21 indica uma projeção em milímetros. Relativamente às Words G90 e G91, estas são referentes

ao modo como o ficheiro foi projetado, ou seja, a instrução G90 significa que o ficheiro

carregado esta projetado para que as coordenadas do mesmo estejam em valores absolutos, isto

é, a sua posição é sempre referente à origem do movimento, e a instrução G91, é indicativa que

as coordenadas do ficheiro foram projetadas em valores relativos, ou seja, a sua posição é

sempre referente à posição da coordenada anterior.

Neste capítulo, a explicação do design do software concebido tem como propósito expor

quais as funcionalidades do mesmo, considerando não só a compatibilidade entre o sistema e as

instruções escolhidas para serem reconhecidas, como também pretende explicar outros detalhes

que foram necessários ponderar de modo a conseguir cumprir o objetivo desta dissertação.



4.1 Princípio de funcionamento da aplicação

Com o objetivo de facilitar o entendimento da aplicação desenvolvida, de seguida serão

evidenciadas as suas funcionalidades através do recurso a fluxogramas, começando por expor

de um modo mais generalista as capacidades do programa e mostrando posteriormente com

mais detalhe os processos fulcrais do mesmo. Estes fluxogramas pretendem dar a entender o

fluxo de informação dentro da aplicação, assim como quais as opções a escolher para criar esse

mesmo fluxo. Nesta descrição do funcionamento da aplicação, o conceito de início e final do

programa, normalmente utilizado em fluxogramas, foi adaptado à janela inicial ou final onde se

encontram os botões disponíveis para o utilizador selecionar, o conceito de processo foi

adaptado à seleção de um botão, o conceito de subprocesso é utilizado quando se providencia

algum tipo de informação ao utilizador, e por fim os blocos de decisão constituem fases do

estado de um processo após este ser selecionado. Quanto à estrutura do fluxograma, é de

salientar que no final de cada processo existe sempre a opção de voltar para o processo anterior,

repetir o processo em causa ou encerrar a aplicação. A imagem seguinte representa um

esquema sucinto das funcionalidades deste programa.

Figura 15 - Fluxo de informação no programa.

Ao executar esta aplicação, o utilizador defronta-se com duas opções iniciais,

designadamente, “Manipulação Automática” e “Manipulação Manual”. Estas duas opções são

representativas dos dois módulos principais do programa desenvolvido. Ao selecionar a opção



“Manipulação Automática”, pressupõe-se que o utilizador pretende manusear a máquina em

causa, com base num ficheiro de texto constituído por instruções escritas em Código-G. Neste

sentido é disposta a possibilidade de “Carregar Ficheiro” ou realizar um “Ajuste de Offset”. A

opção “Ajuste de Offset”, deriva do caris prático a que este programa se destina, isto é,

considerando que o objetivo desta aplicação é manipular a máquina XYZ referida para produção

de um produto final, grande parte das vezes a origem do sistema de eixos da maquina não é

coincidente com a origem do ficheiro a carregar, portanto na opção “Ajuste de Offset” o

utilizador fornece os dados necessários para fazer esse importante e por vezes essencial ajuste,

antes de carregar um ficheiro. Posto isto, após realizado esse ajuste de offset, assim que um

ficheiro seja carregado, o programa realiza automaticamente os cálculos necessários para

descobrir os novos valores das coordenadas. Deste modo o movimento dos eixos é iniciado com

os novos valores geométricos determinados até cumprir o seu propósito. É de salientar que na

eventualidade do utilizador pretender carregar um ficheiro sem realizar nenhum tipo de ajuste,

essa opção também é suportada. No final, o utilizador pode encerrar o programa, carregar um

novo ficheiro ou voltar para a página inicial.

Por outro lado, este programa tem também a capacidade de fornecer ao utilizador a

possibilidade de manusear a máquina de um modo não automático, ou seja, com movimentos

controlados diretamente pelo operador da máquina. Este modo denomina-se de “Manipulação

Manual” e suporta três tipos de movimentos, nomeadamente, retilíneos, circulares e

quadrangulares. Neste modo, ao contrário do que acontece quando se carrega um ficheiro, o

utilizador insere os parâmetros necessários para a realização do movimento em causa

diretamente na aplicação. Esta funcionalidade pode ser muito útil para verificar se os

constituintes físicos do sistema estão em bom funcionamento, se as parametrizações do módulo

mecânico estão a ser corretamente aplicadas e pode servir também para uma melhor adaptação

de um novo utilizador a célula de trabalho, antes de utilizar a opção de manipulação automática.

Posto isto, após realizada uma explicação geral das funcionalidades deste programa,

serão então abordados com mais detalhe alguns dos processos mais importantes do mesmo.

4.2 Manipulação Automática

Considerando o nível de detalhe de cada opção disponível na janela “Manipulação

Automática”, dividiu-se este subcapítulo nas duas partes constituintes da mesma.



4.2.1 Carregar Ficheiro

A opção “Carregar Ficheiro” encontra-se dentro do módulo de manipulação automática e

pode ser considerada como o processo mais importante deste programa. Assim que o utilizador

escolha esta opção exposta na página inicial, é aberta uma nova janela com as opções “Procurar

Ficheiro”, “Ler ficheiro” e “Separar Texto”. A figura seguinte demonstra o fluxo de informação no

processo de carregamento de um ficheiro até ao início do movimento.

Figura 16 - Fluxograma do carregamento de um ficheiro.

De um modo sequencial, ao selecionar o botão para procurar um ficheiro, o utilizador

fornece ao sistema a localização do ficheiro a carregar, de seguida ao clicar no botão para ler o

ficheiro, não só é inserido no sistema o conteúdo do ficheiro de texto escolhido, como também é

utilizada uma caixa de texto para mostrar ao utilizador esse mesmo conteúdo. No seguimento

destas opções, a opção para separar o texto representa o processo encarregue de realizar uma

análise lexical e sintática de todas as instruções constituintes do ficheiro carregado. Neste

sentido, caso exista algum erro desse género, é apresentada uma mensagem ao utilizador e o

programa retorna para a opção de procurar um ficheiro. Contudo, se o ficheiro não contiver

nenhum erro, as instruções são analisadas caractere a caractere, de modo a obter todos os



parâmetros que as constituem. Assim que os parâmetros estejam determinados e guardados, o

programa realiza automaticamente a conversão dessa informação escrita em Código-G, em

informação aceitável pela biblioteca de funções da NI Motion. Mais uma vez, se ocorrer algum

erro durante esta conversão, é mostrada uma mensagem ao utilizador e o programa volta para a

opção de procurar um novo ficheiro. Posto isto, após todos estes processos estarem concluídos

com sucesso, o utilizador deve então abrir a janela que possibilita o início do movimento

automático. Nesta fase, o utilizador apenas necessita de colocar o ID da placa que pretende

controlar e clicar em “Inicio do Movimento”. Esta opção encarrega-se de chamar todas as

funções necessárias da biblioteca referida, de acordo com as instruções do ficheiro, e utiliza

como variáveis para essas funções os parâmetros convertidos previamente. Assim que o

movimento estiver terminado, o utilizador é informado dessa situação, e o programa volta para a

janela “Carregar Ficheiro”. Neste momento, é atribuída ao utilizador a decisão de carregar um

novo ficheiro ou encerrar o programa.

4.2.2 Ajuste de Offset

Tal como a opção “Carregar Ficheiro”, a opção “Ajuste de Offset” faz parte da janela

referente à manipulação automática. Esta funcionalidade surge derivado do caracter prático e

aplicacional do software desenvolvido e serve de complemento ao carregamento de um ficheiro,

representando um processo essencial para adaptação dos parâmetros geométricos de um

ficheiro de texto genérico escrito em Código-G, ao sistema mecânico utilizado nesta dissertação.

Durante o desenvolvimento de um programa escrito em Código-G, é possível que a

pessoa encarregue dessa função, não tenha em consideração o sistema geométrico da máquina

que se pretende controlar, partindo do princípio que o movimento planeado começa na origem

de um sistema de eixos genérico ou num determinado ponto escolhido pelo programador, e

prossegue a sua execução com base nesse ponto inicial. Um exemplo explicativo da operação de

uma máquina nessas circunstâncias pode ser a simples realização de diversos movimentos

retilíneos, numa determinada predisposição, com o intuito de efetuar cortes numa placa

retangular, Figura 16.



Figura 17 - Geometria do movimento referido para realização de cortes.

Neste caso, o sistema de eixos da máquina está alinhado com o sistema de eixos que

serviu de base para a criação do movimento contido no ficheiro, isto é, é possível verificar que a

origem da máquina, ponto E, é coincidente com a origem assumida no programa desenvolvido,

ponto A.

No entanto, tendo em consideração as características físicas do sistema utilizado nesta

dissertação, a colocação da placa de metal referida seria efetuada por um processo externo,

sempre dependente do operador da máquina. Como é percetível, a tarefa de colocar essa

mesma placa de modo a que uma das extremidades dela coincida com o ponto de origem do

programa a executar, pode ser extremamente complexo e até mesmo impossível. Neste sentido,

a origem do movimento pode não ser coincidente com a origem máquina, Figura 18, e assim

sendo, se o ficheiro carregado fosse executado diretamente, o resultado obtido não seria o

resultado esperado, podendo até mesmo causar não só desperdício de material, como também

colocar em risco a segurança do sistema.



Figura 18 - Deslocamento face à origem do movimento em causa.

Posto isto, surge então a necessidade de se realizar um ajuste de modo a que a

execução do ficheiro desenvolvido corresponda às operações executadas pela máquina.

Assim que esse processo de adaptação tenha sido efetuado, o utilizador apenas

necessita de carregar o ficheiro que pretende executar para o sistema e o software realiza todas

as conversões necessárias de modo a que os movimentos da máquina, neste caso os cortes na

placa de metal, estejam em concordância o espectado.

É de salientar por fim que esta opção é apenas um complemento à opção que permite o

carregamento de um ficheiro, e assim sendo, fica ao critério do operador da máquina realizar

este ajuste ou não.

4.3 Manipulação Manual

A análise do design desta aplicação fica então completa com a explicação do

funcionamento da aplicação em modo manual. O objetivo deste programa, tal como já foi

explicado, é desenvolver uma aplicação para a realização de movimentos retilíneos e circulares

com base na leitura de um ficheiro, ou seja, de forma automática. Contudo, é importante

perceber o que é necessário para a preparação destes movimentos antes da sua execução,

assim como qual o propósito de cada parâmetro nesta tarefa. Com esse intuito, foi criada então

uma janela para “Manipulação Manual”, onde se encontram as seguintes três opções,

“Movimento Circular”, “Movimento Retilíneo” e “Movimento Quadrangular”. Cada uma destas



opções implica o fornecimento de diferentes parâmetros ao sistema e apenas é fornecida a

possibilidade de realizar cada um destes movimentos separadamente. Convém salientar desde

já que nesta aplicação, a nível de manuseamento manual, a velocidade e aceleração utilizadas

são constantes e pré-definidas.

No que diz respeito a movimentos retilíneos, os parâmetros necessários para preparação

dos mesmos é de caris intuitivo, ou seja, para além da colocação do ID da placa como é sempre

requisitado, é necessário indicar qual ou quais os eixos que se pretendem utilizar e qual

distancia a percorrer. A nível de movimentos circulares, o processo necessário referente a sua

preparação não é tão simples ou intuitivo como a preparação de movimentos retilíneos. Para

além dos parâmetros comuns a todos os movimentos, nomeadamente o ID da placa e quais os

eixos a utilizar, é necessário também fornecer informação sobre o plano onde se pretende

realizar o movimento circular, o raio desse movimento, o seu ângulo inicial e o seu ângulo de

percurso.

Figura 19 - Definição de um movimento circular.

Com o objetivo de esclarecer o propósito destes últimos três parâmetros é apresentada a

imagem acima, representativa de um movimento circular no sentido anti-horário, Figura 19. Esta

figura autoexplicativa representa os parâmetros geométricos referentes à execução de um

movimento circular nesta aplicação.

Por fim, a terceira opção, “Movimento Quadrangular”, não é mais que uma junção de

vários movimentos retilíneos, no entanto tem o importante propósito de fornecer ao utilizador

uma melhor perceção do comportamento da máquina face a movimentos executados nos eixos

X e Y.



Posto isto, agora que a preparação por trás da execução dos movimentos cruciais para o

funcionamento desta aplicação já foi explicada, é mostrado então o seguinte fluxograma com o

objetivo de expor o fluxo de informação necessário para a execução de um dos movimentos

disponíveis para seleção, assim como a sequência de opções a escolher para a realização do

mesmo.

Figura 20 - Fluxo de informação referente à janela de manipulação manual.

4.4 Resumo

Resumidamente, todos os processos descritos foram ponderados e otimizados de modo

a que o software desenvolvido tenha uma fácil interação com o utilizador, assim como um o fluxo

de informação simples entre cada processo. Derivado das possibilidades distintas que as duas

opções iniciais oferecem, designadamente, a manipulação automática da máquina através de

um ficheiro ou a manipulação manual inserindo diretamente os parâmetros no sistema,

considerando também a capacidade de se realizar o ajuste de offset referido, é possível afirmar

esta aplicação não só é completa a nível operacional, como também é robusta a nível de

algoritmia. Neste sentido, após ponderadas todas as funcionalidades necessárias para que o



software a desenvolver tenha a capacidade de ser aplicado na célula de trabalho utilizada no

âmbito desta dissertação, procedeu-se então à implementação do design exposto neste capítulo.



Capítulo 5 - Implementação Pedro Miguel Pereira 41

Capítulo 5

5. Implementação


42 Pedro Miguel Pereira Capítulo 5 - Implementação

Após explicado design da aplicação concebida, neste capítulo será apresentado como é

que a estrutura do software se vai definir, ou seja, como é que ela será implementada de modo

executar todos os processos referidos. Novamente recorrendo à elaboração de fluxogramas, e de

um modo progressivo a nível de detalhe, serão então abordados os métodos de programação

utilizados para a conceção deste software.

5.1 Separar Texto

Considerando o objetivo principal desta dissertação, nomeadamente a manipulação de

uma máquina de forma automática, o primeiro processo a ser concebido foi a realização do

parsing de instruções escritas no formato previamente referido, após o ficheiro estar inserido no

sistema. Neste sentido, assim que o utilizador carregue um ficheiro para o sistema e confirme o

seu conteúdo, ao selecionar a opção “Separar Texto”, inicia-se um conjunto de procedimentos

para realizar a separação das instruções.

De um modo sequencial, as instruções são inicialmente convertidas num conjunto de

caracteres que serão posteriormente concatenados de modo a formarem uma string por cada

instrução do ficheiro. De seguida dá-se início a um ciclo que percorre o vector onde foram

alocadas as strings referidas, com o intuito de analisar e converter em parâmetros toda a

informação guardada nas mesmas. Dentro desse ciclo, a primeira função executada é o teste ao

primeiro caractere do conjunto de caracteres que definem a string. Neste sentido inicia-se uma

análise lexical que permite verificar se o ficheiro contém algum Address Character que não seja

suportado pela aplicação. De um modo mais especificado, os Address Character aceites pelo

programa para a definição da primeira word de uma instrução são as letras X, Y, Z e G, logo se

for detetada outra letra, um número ou um caracter, o programa emite uma mensagem de erro.

Nesta situação cabe ao utilizador optar por carregar outro ficheiro ou continuar a análise do

mesmo, caso o erro encontrado não afete o produto final. Não obstante, a segurança da célula

de trabalho está sempre garantida pois assim que a análise do ficheiro estiver concluída e o

utilizador decida iniciar o movimento, é realizada uma verificação de todos os parâmetros

determinados e na eventualidade do valor dos mesmos ultrapassar o limite definido, a aplicação

desenvolvida informa o utilizador dessa situação e não executa nenhuma função referente ao

movimento da máquina. Caso o primeiro Address Character não entre em conflito com o

sistema, o programa continua a analisar a instrução até chegar ao final da mesma.



Mais detalhadamente é realizado novamente um teste, em forma de “swtich case”, para

determinar quais os caracteres que estão presentes entre o primeiro Address Character e o final

da instrução. Durante esta análise, no que diz respeito a caracteres numéricos e alfabéticos, se

for encontrado um número, o seu valor é guardado num vetor de inteiros, caso seja detetada

uma letra, é definido um conjunto de variáveis com o propósito de determinar quais os eixos a

utilizar no movimento consoante a letra encontrada. A nível de símbolos, se for detetado um

sinal menos (“-“) ou uma virgula (“,”), é ativada uma flag que servirá para alertar o programa

que o parâmetro em causa é negativo e/ou decimal. Tal como já foi previamente referido, as

instruções do ficheiro foram convertidas num conjunto de caracteres alocados num vetor, logo

cada caractere detetado possui um índice único. No que diz respeito ao caractere vírgula, este

índice é essencial para determinar onde colocar a mesma quando o parâmetro é constituído por

três ou mais inteiros. É de salientar ainda que no momento de deteção de uma letra ou quando

o software conclui a análise de uma instrução, é estabelecida uma variável (“tamanho do

parâmetro”) de acordo com o índice em questão, cujo propósito será definir o valor do

parâmetro que precede essa mesma letra ou o valor referente à ultima Word. Mais uma vez, se

for encontrado um caractere diferente daqueles que são espectáveis, o programa informa o

utilizador através de uma mensagem de erro e conforme a ação do utilizador, pode continuar a

sua análise, ignorando qualquer caractere entre o índice do caractere não reconhecido e a

próxima letra a ser encontrada.

Assim que o programa termine a análise e divisão de uma instrução, este prossegue

para o processo que testa e estabelece qual o valor de cada parâmetro. Este processo essencial

representa a transição entre parâmetros escritos em Código-G e parâmetros que serão utilizados

durante a invocação das funções da biblioteca da NI Motion. No momento em que todos os

parâmetros estejam determinados, os vetores referidos são “limpos” de modo a permitirem a

alocação de informação da instrução seguinte.

Posto isto, todo o procedimento descrito para análise e divisão de uma instrução, é

repetido conforme o número de instruções que o ficheiro contenha, até chegar ao final do

mesmo. A imagem seguinte, Figura 21, pretende expor o fluxo de informação durante a

execução dos procedimentos referidos. Convém também realçar que no fluxograma seguinte, o

inicio e final do mesmo corresponde à seleção por parte do utilizador das opões “Separar Texto”

e “Inicio do Movimento” respetivamente.



Figura 21 - Fluxograma explicativo do funcionamento interno da opção “Separar Texto”.

Tal como foi referido, um dos procedimentos essenciais durante o processo exposto na

imagem acima, é o teste e determinação do valor de cada parâmetro da instrução. Neste

sentido, é importante abordar com mais detalhe como se implementou esse procedimento.



5.1.1 Determinar o valor de cada parâmetro da instrução

Entre o final da análise de uma instrução e a “limpeza” dos vetores para começar a

analisar a próxima, é necessário determinar os valores dos parâmetros da instrução em causa. A

imagem seguinte, Figura 22, pretende demonstrar a função encarregue dessa tarefa.

Figura 22 - Fluxograma explicativo do método utilizado para determinar os parâmetros.

Explicando detalhadamente o fluxograma acima, inicialmente, utilizando novamente o

método “switch case”, realiza-se um conjunto de testes com o propósito de definir o tamanho do

parâmetro (a nível de carateres) de acordo com o valor da variável “tamanho do parâmetro” já

mencionada. Caso essa variável tenha valor igual a um, significa que o parâmetro em causa é

constituído apenas por um caractere numérico, e neste sentido esse mesmo caractere é

convertido diretamente para um inteiro. De seguida, o programa averigua se existe alguma flag

de sinal negativo ativa e de acordo com o índice correspondente quando esse símbolo foi



detetado, verifica se o parâmetro em causa é positivo ou negativo. Tal como é percetível pela

imagem, posteriormente multiplica o inteiro definido pelo valor “-1” ou não. Assim que o valor

estiver estabelecido, é realizada ainda outra multiplicação por uma constante referente à unidade

métrica em que o ficheiro se encontra, de modo a obter-se uma concordância entre os aspetos

geométricos do ficheiro carregado e os movimentos a executar pela máquina. Por outro lado, se

o valor da variável “tamanho do parâmetro” for superior a um e menor que cinco (valor máximo

permitido para esta variável por razões de segurança do sistema), é realizado um teste que

permite averiguar se o parâmetro em causa é decimal ou não. Para tal, primeiramente é

averiguado se a flag representativa da deteção de uma virgula está ativa, e de acordo com o que

foi explicado previamente, é utilizado o valor do respetivo índice no momento dessa deteção para

determinar onde colocar a virgula na string representante do parâmetro em causa, antes de se

proceder à sua conversão para inteiro. Por fim, o processo relativo à verificação do sinal de um

parâmetro e a respetiva multiplicação pela constante da unidade métrica já explicado, é

executado independentemente do estado da flag referente à existência de um valor decimal.

Assim que todos os parâmetros da instrução em causa estejam definidos, o programa

entra no processo que tem com função testar os valores encontrados. A realização deste teste

tem como propósito descobrir e estabelecer uma relação entre os parâmetros determinados e as

funções permitidas pelo sistema referentes ao Código-G. Logo à partida, é testado o primeiro

parâmetro da instrução em causa, aceitando como valores: 00, 01, 02, 03, 20, 21, 90 ou 91.

Caso seja detetado um dos parâmetros relativos ao movimento, o programa percorre a instrução

em causa e guarda os valores numéricos da mesma em vectores próprios de acordo com a letra

a que estão associados, isto é, por exemplo, na instrução “G00X100Y200”, os valores 100 e

200 serão guardados em vectores próprios, referentes à posição de cada eixo. As letras

presentes na instrução vão servir também para indicar quais os eixos que esta instrução

necessita para ser executada. Por outro lado, se for detetado o parâmetro 20 ou 21, referente à

unidade métrica utilizada, é necessário aplicar um procedimento diferente, ou seja, não é

possível guardar os valores diretamente. Explicando de um modo mais específico, as funções do

controlador utilizado neste sistema, referentes ao valor da posição pretendida, apenas aceitam

como varável um valor inteiro que representa o número de “counts” que o enconder tem que

percorrer. Neste sentido, a aplicação fica encarregue de converter qualquer uma das duas

unidades métricas referidas para um valor reconhecido pelo sistema, utilizando a já referida

constante de multiplicação da unidade métrica. Posto isto, se algum destes dois valores (20 ou



21) for detetado, a respetiva flag é ativada e tal como já foi referido no procedimento anterior, no

momento de determinação dos parâmetros uma das constantes abordadas é utilizada. Por fim,

para terminar a análise deste processo, será abordada então a possível deteção dos valores 90

ou 91. Nesta situação, o software apenas ativa a flag correspondente ao modo de operação a ser

utilizado, ou seja, ativa a flag “modo absoluto” se for encontrado o valor 90, ou ativa a flag

“modo relativo” se for detetado o valor 91. A diferença entre estes dois modos de operação já foi

explicada previamente no início do capítulo 4.

Por fim, convém também salientar que as instruções G20 ou G21 e G90 ou G91 são

espectáveis no início do ficheiro carregado, onde por norma estão localizadas. Caso contrário por

defeito definiu-se que a aplicação deve assumir que as unidades do ficheiro estão em “counts” e

que o modo a utilizar é o absoluto.

O fluxograma seguinte pretende expor de modo figurativo o processo explicado referente

ao teste de cada parâmetro.

Figura 23 - Sequência de procedimentos para testar o primeiro parâmetro de cada instrução.

De modo a finalizar a análise deste procedimento, convém apenas salientar que todo o

processo descrito é repetido para cada instrução do ficheiro. Assim que todos os procedimentos

relativos à opção “Separar Texto” estejam completados com sucesso, estão então reunidas as

condições para entrar no processo encarregue de manipular a máquina.



5.2 Iniciar movimento

A opção “Iniciar Movimento”, a par do processo descrito até agora, é igualmente

essencial para o funcionamento desta aplicação. Após estarem definidos todos os parâmetros, é

apresentada ao utilizador a possibilidade de abrir a janela representativa do início do movimento.

Nesta fase, o utilizador apenas necessita de colocar o ID da placa e clicar no botão “Iniciar

Movimento” para que a maquina execute o ficheiro previamente carregado. Mais uma vez,

diversos procedimentos foram implementados para garantir a concordância entre o ficheiro e os

movimentos da máquina, assim como a segurança durante a execução desses mesmos

movimentos, sem que o utilizador se aperceba dessas ações. A imagem abaixo, Figura 24,

mostra o fluxo de informação e os procedimentos que são executados assim que o utilizador

decida iniciar o movimento.



Figura 24 - Representação esquemática referente a execução de uma instrução.

Explicando o fluxograma acima de um modo detalhado, quando o botão referido é

selecionado, dá-se início a um ciclo “for” com o tamanho igual ao número de linhas do ficheiro

carregado. Cada iteração do mesmo significa a execução de uma instrução, e o final deste ciclo

representa que todas as instruções já foram executadas. Este ciclo pode ser considerado como o

procedimento principal dentro deste processo de início de movimento.

No início de cada iteração é realizado um conjunto de testes para averiguar qual o modo

de operação a utilizar durante o movimento da máquina, recorrendo a verificação do estado das

flags “modo absoluto” e “modo relativo” respetivamente. Na eventualidade de nenhuma destas

flags estar ativa, o programa assume por defeito que o ficheiro está em modo absoluto. Neste



seguimento, após definido esse modo de operação, é verificado se os valores das coordenadas

ultrapassam os limites de acordo com o modo de operação a utilizar. Embora durante o

processo “Separar Texto” os parâmetros sejam testados considerando o valor máximo permitido

para o valor de uma coordenada (no âmbito desta dissertação esse valor máximo é de cinco

caracteres), para se realizar uma verificação eficaz considerando o sistema físico utilizado é

necessário efetuar uma averiguação mais meticulosa. Se o ficheiro for projetado para

operacionalizar em modo absoluto, basta realizar uma comparação direta de todas as

coordenadas de cada eixo com o valor máximo permitido para o mesmo, para garantir que

nenhuma ultrapassa os limites. No entanto, caso um ficheiro seja projetado para operacionalizar

num modo relativo é necessário utilizar outro método para verificar se os limites físicos da

máquina são atingidos, ou seja, é necessário realizar um somatório de todas as coordenadas,

para cada eixo, e só depois é que se pode comparar ao valor máximo permitido para mesmo.

Este procedimento pode ser considerado um dos mais importantes do programa pois é ele quem

assegura a segurança da célula de trabalho. Posto isto, se estiveram reunidas as condições de

segurança e definido o modo de operação, a instrução é então executada.

A execução de uma instrução baseia-se na invocação de uma sequência de funções

essenciais para que o controlador utilizado consiga dar início ao movimento do cursor.

Independentemente do tipo de movimento, retilíneo ou circular, existem procedimentos e

funções que são sempre utilizados, ou seja, assim que é detetado uma instrução referente à

realização de um movimento, dá-se então início a uma sequência de funções específicas.

Primeiramente é invocada a função “flex_enable_axes”, com o propósito de ativar os eixos que

serão utilizados na execução da instrução em causa, de seguida é utilizada a função

“flex_read_csr_rt” para verificar se o controlador está apto para ser programado, depois é

definido o modo de operação através de função “flex_set_op_mode”, e para finalizar a

sequência, são utilizadas as funções “flex_load_acceleration” e “flex_load_velocity” para

estabelecer os valores da aceleração e velocidade respetivamente. Embora a aceleração esteja

definida igualmente para todos os movimentos, de acordo com as limitações físicas da célula de

trabalho, a velocidade pode ser alterada utilizando a instrução específica com essa

funcionalidade, nomeadamente o comando G01, sem ultrapassar os limites definidos pelo

software (5000counts/s).

A figura seguinte pretende demonstrar a sequência de funções explicada, assim como

expor as diferenças que se seguem após a completação da mesma.



Figura 25 - Sequência de funções utilizada para dar início ao movimento.

A partir desta fase, as funções invocadas já dependem do movimento a ser executado.

Assim sendo, caso a instrução em causa seja G00 ou G01, a próxima função a ser invocada é a

“flex_load_target_pos”, cujo propósito é informar o controlador sobre o valor da posição

pretendida. Esta posição é proveniente da leitura dos vetores referidos anteriormente, que

alocam os valores das coordenadas determinadas no processo “Separar Texto”. É de salientar



que esta função é invocada para cada eixo presente na instrução em causa. Por outro lado, se a

instrução a ser executada for G02 ou G03, inicialmente é utilizada a função

“flex_config_vect_spc” para definir o espaço vectorial onde se vai realizar o movimento circular.

Neste sistema, um espaço vectorial é definido por dois ou mais eixos e é utilizado quando se

pretende realizar movimentos interpolados. No âmbito desta dissertação, o espaço vectorial

definido representa a realização de movimento circulares nos eixos do X e Y em simultâneo.

Posto isto, a próxima função a ser utilizada é a “flex_load_circular_arc” e está encarregue de

fornecer ao controlador informação sobre os parâmetros já referidos necessários para a

realização de movimentos circulares, designadamente os valores do raio, ângulo inicial e ângulo

final, assim como qual o espaço vectorial definido.

Convém então nesta fase, salientar um aspeto importante no que diz respeito à

obtenção dos valores do raio, ângulo de início e ângulo final. Ao contrário das instruções que

representam movimentos retilíneo, os valores que constituem as instruções de movimentos

circulares não podem ser utilizados diretamente como variáveis para a função encarregue dos

movimentos circulares presente na biblioteca da NI. Quando se pretende realizar um movimento

circular recorrendo à programação em Código-G, são requisitados dois parâmetros: a posição

final após realizar esse movimento e um offset por eixo (relativo à posição de inicio do

movimento) correspondente à localização pretendida para o centro desse movimento circular. A

título de exemplo, uma instrução deste tipo seria: “G02 X2500 Y-670 I0 J-5000”, em que os

valores numéricos após as letras “X” e “Y” correspondem às coordenadas da posição final da

máquina depois de realizado o movimento, e os valores numéricos após as letras “I” e “J”

correspondem ao offset a aplicar ao eixo do X e eixo do Y respetivamente, de modo a situar o

centro da circunferência que contém o movimento. Posto isto, tornou-se então essencial utilizar

um método matemático para converter os parâmetros referidos em valores compatíveis com a

função “flex_load_circular_arc”. Neste sentido, de modo a executar as conversões referidas, o

programa realiza um conjunto de testes, com o propósito de determinar o limite geométrico do

movimento em causa, e consequentemente quais as funções matemáticas a serem aplicadas.

Mais especificamente, assim que uma instrução G02 ou G03 for detetada e devidamente

dividida, o primeiro parâmetro a ser testado é o offset relativo ao centro da circunferência a

realizar, face a posição final relativamente ao movimento anterior, ou seja, através do valor

associado à letra I e letra J respetivamente, primeiramente é verificado em quantos eixos está o



centro deslocado. As imagens seguintes pretendem exemplificar diferentes deslocamentos para

o ponto central da circunferência.

Figura 26 - Deslocamento do centro da circunferência no eixo do Y.

Figura 27 - Deslocamento do centro da circunferência no eixo do X.

Simultaneamente ao teste do offset, é efetuada uma serie de comparações entre a

posição inicial e final do movimento, quer para o eixo do X quer para o eixo do Y. A junção do

processo de verificação do offset utilizado, com a realização deste teste relativo às posições do

cursor, permite delimitar a variação angular em que o movimento foi projetado, mais

detalhadamente, através destas condições é determinado se o movimento foi projetado no

semicírculo respetivo à variação angular entre 0 e 180º (exclusive), se o movimento é de 180º

ou 360º, ou se o movimento está entre 180º e 360º (exclusive).

Após realizadas as condições referidas, são então efetuados os cálculos que vão

possibilitar a determinação dos valores necessários, de acordo com a condição em que o

movimento se insere. Neste sentido, convém detalhar que numa primeira fase, após realização

do teste relativo ao offset do movimento, os valores associados à letra I e J são utilizados para

(0,0)

(20000,10000)

(20000,15000)

(16464,6464)

(16464,1464)

(36464,1464)

(0,10000)

Y

X

Y

(0,0)

X

(0,10000)

(20000,10000)

(21464,13536)

(41464,13536)



calcular o raio do movimento. De seguida, utilizando o valor das coordenadas da posição inicial e

posição final, é calculado o valor médio entre esses pontos, que juntamente com o raio, servira

para ser utilizado no cálculo de um angulo auxiliar. Por fim, o valor do ângulo auxiliar é

multiplicado por dois, e consoante a condição referente às posições do movimento, poderá ser

diretamente esse o valor final para o angulo a percorrer ou ainda terá que ser realizada uma

subtração entre 360 e o dobro do valor do ângulo auxiliar obtido. As imagens seguintes

representam um movimento circular ampliado, com o intuito de exemplificar os cálculos

referidos.

Figura 28 - Angulo a percorrer entre 0º e 180º.

Cálculos a efetuar referentes à Figura 28, projetada em modo relativo:

𝑅𝑎𝑖𝑜 = |𝐽| = 5000

𝑃𝑜𝑛𝑡𝑜 𝑀é𝑑𝑖𝑜 = √(𝑋𝑑𝑒𝑠𝑙𝑜𝑐𝑎𝑑𝑜)2 + (𝑌𝑑𝑒𝑠𝑙𝑜𝑐𝑎𝑑𝑜)2

2

= √(2500)2 + (−670)2

2 = 1294.111664

Sin 𝛼 = 𝑃𝑜𝑛𝑡𝑜 𝑀é𝑑𝑖𝑜

𝑅𝑎𝑖𝑜 → 𝛼 = 15.00019°

𝜃 = 2 × 𝛼 = 30.00039° (ângulo na Figura 28-> 30°)

(20000,15000)

(22500,14330)

(20000,10000)



Figura 29 - Angulo a percorrer entre 180º e 360º.

Cálculos a efetuar referentes à Figura 29, projetada em modo absoluto:

𝑅𝑎𝑖𝑜 = |𝐽| = 5000

𝑃𝑜𝑛𝑡𝑜 𝑀é𝑑𝑖𝑜 = √(𝑋𝑏 − 𝑋𝑎)2 + (𝑌𝑏 − 𝑌𝑎)2

2

= √(16464 − 20000)2 + (6464 − 15000)2

2

= 4619.702155

sin 𝛼 = 𝑃𝑜𝑛𝑡𝑜 𝑀é𝑑𝑖𝑜

𝑅𝑎𝑖𝑜 → 𝛼 = 67.50911954°

𝜃 = 2 × 𝛼 = 135.0182391°

𝜑 = 360 − 𝜃 = 224.981760 (ângulo na figura 29-> 225°)

Em todas as situações expostas, o ângulo inicial do movimento é conhecido à partida

(0º, 90º, 180º ou 270º), pois em todos os movimentos das imagens existe apenas offset do

centro da circunferência em apenas um eixo. Neste sentido, convém por fim salientar que na

eventualidade de existir um offset do centro em dois eixos, a priori da execução destes cálculos,

é efetuado um calculo para determinar qual o ângulo inicial do movimento, a partir dos valores

de I e de J. Seguidamente, é aplicada uma matriz de rotação auxiliar às coordenadas referentes

(20000,15000)

(20000,10000)

(16464,6464)



ao movimento circular de modo a “colocar” o movimento circular em causa numa situação em

que seja possível aplicar as condições relativas à posição do cursor já referidas, e

consequentemente efetuar um dos três tipos de cálculos para o ângulo a percorrer.

Nesta fase, todas as condições estão reunidas para invocar a função preparatória

encarregue de realizar movimentos circulares, isto é, todas as variáveis a utilizar na função

“flex_load_circular_arc“ já foram calculadas.

Por fim, a nível de manipulação da máquina, antes de se iniciar o movimento circular,

tendo em consideração a Figura 19, é necessário movimentar o cursor da máquina para o

centro da circunferência e de seguida voltar a movimenta-lo na direção de um dos eixos de

acordo com o ângulo inicial definido, sendo que a distância a percorrer corresponde ao raio do

movimento. Para tal é efetuado o cálculo das coordenadas do centro da seguinte forma:

𝑋𝐶𝑒𝑛𝑡𝑟𝑜 = 𝑋𝑖𝑛𝑖𝑐𝑖𝑎𝑙 + 𝑂𝑓𝑓𝑠𝑒𝑡𝑥

𝑌𝐶𝑒𝑛𝑡𝑟𝑜 = 𝑌𝑖𝑛𝑖𝑐𝑖𝑎𝑙 + 𝑂𝑓𝑓𝑠𝑒𝑡𝑦

Posteriormente é realizado um deslocamento linear para esse ponto e será possível

então dar-se início ao movimento circular.

Posto isto, depois explicado este detalhe, continuando com a análise do fluxograma,

assim que a sequência de invocação das funções preparatórias tenha sido efetuada com

sucesso, incluindo as funções dependentes para cada movimento, é então invocada a função

“flex_start” responsável por iniciar o movimento. Associadas a esta função estão as funções

“flex_check_move_complete_status”, que representa o fornecimento de informação

relativamente ao estado do movimento, ativando uma flag assim que o movimento estiver

terminado, e “flex_stop_motion” que tem como função parar os eixos quando essa flag estiver

ativa. Nesta fase, a execução da instrução chegou ao fim e o programa “zera” as variáveis

relativas às funções referidas e volta ao início até percorrer o ficheiro todo, ou seja, até chegar à

última iteração do ciclo que representa o controlo de informação deste processo.

5.3 Ajuste de Offset

Um módulo à parte do que foi explicado até agora neste capítulo, é o processo de ajuste

de offset já referido no capítulo anterior. Com o intuito de facilitar a compreensão desta

funcionalidade, antes de se abordar o fluxo de informação neste processo, convém explicar de

um modo mais detalhado o que se pretende obter com a realização deste ajuste. Deste modo,



contribui-se também para uma melhor perceção relativamente aos parâmetros necessários a

inserir no sistema.

O método mais intuitivo para a realização de um ajuste deste tipo é a soma direta do

deslocamento da placa, a todas as coordenadas relativas ao movimentos, ou seja, somar o

deslocamento do ponto A em relação ao ponto E, Figura 18 a todas as coordenadas do ficheiro

referentes a movimentos. A introdução no programa de certos parâmetros por parte do

operador, nomeadamente as coordenadas do ponto A, é essencial para esse cálculo possa ser

efetuado e, posteriormente, o programa executado sem comprometer os fatores referidos. Neste

sentido o cálculo para cada ponto seria realizado da seguinte forma:

𝑋𝑓𝑖𝑛𝑎𝑙 = 𝑋𝑖𝑛𝑖𝑐𝑖𝑎𝑙 + 𝑋𝑝𝑜𝑛𝑡𝑜𝐴

𝑌𝑓𝑖𝑛𝑎𝑙 = 𝑌𝑖𝑛𝑖𝑐𝑖𝑎𝑙 + 𝑌𝑝𝑜𝑛𝑡𝑜𝐴

Exemplificando com o ponto B da Figura 18:

𝑋𝑓𝑖𝑛𝑎𝑙_𝑝𝑜𝑛𝑡𝑜𝐵 = 𝑋𝑖𝑛𝑖𝑐𝑖𝑎𝑙_𝑝𝑜𝑛𝑡𝑜𝐵 + 𝑋𝑝𝑜𝑛𝑡𝑜𝐴 = 3450 + 5000 = 8450 (𝐶𝑜𝑟𝑟𝑒𝑡𝑜)

𝑌𝑓𝑖𝑛𝑎𝑙_𝑝𝑜𝑛𝑡𝑜𝐵 = 𝑌𝑖𝑛𝑖𝑐𝑖𝑎𝑙_𝑝𝑜𝑛𝑡𝑜𝐵 + 𝑌𝑝𝑜𝑛𝑡𝑜𝐴 = 13531 + 5000 (𝐶𝑜𝑟𝑟𝑒𝑡𝑜)

Contudo, uma vez que a placa é colocada na célula de trabalho com auxílio a um meio

externo, é possível que para além de existir um deslocamento em relação à origem, exista

também uma rotação involuntária da mesma, tal como é visível na Figura 30. Caso essa rotação

aconteça, as arestas da placa deixaram de ser paralelas ao sistema de eixos da máquina, logo,

uma simples soma direta do valor das coordenadas do ponto A a todas as outras coordenadas,

não é o suficiente para realizar um ajuste de offset eficiente.



Figura 30 - Rotação do movimento referido.

Neste caso, o cálculo realizado anteriormente para o ajuste das coordenadas teria a

seguinte configuração:

𝑋𝑓𝑖𝑛𝑎𝑙_𝑝𝑜𝑛𝑡𝑜𝐵 = 𝑋𝑖𝑛𝑖𝑐𝑖𝑎𝑙_𝑝𝑜𝑛𝑡𝑜𝐵 + 𝑋𝑝𝑜𝑛𝑡𝑜𝐴 = 3450 + 5000 = 8450 (𝐸𝑟𝑟𝑎𝑑𝑜)

𝑌𝑓𝑖𝑛𝑎𝑙_𝑝𝑜𝑛𝑡𝑜𝐵 = 𝑌𝑖𝑛𝑖𝑐𝑖𝑎𝑙_𝑝𝑜𝑛𝑡𝑜𝐵 + 𝑌𝑝𝑜𝑛𝑡𝑜𝐴 = 13531 + 5000 = 18531 (𝐸𝑟𝑟𝑎𝑑𝑜)

Através da visualização da figura, é percetível que este cálculo deixou de poder ser

utilizado. Para revolver este problema, é necessário então introduzir o conceito de matriz de

rotação. Esta matriz possibilita o cálculo de todas as coordenadas de um movimento geométrico

realizado na placa, na eventualidade de existência de uma rotação involuntária. O objetivo da

utilização de uma matriz rotacional é descobrir qual o valor final das coordenadas do movimento,

após ser aplicado um determinado ângulo de rotação às coordenadas iniciais.

Figura 31 - Definição do ângulo de rotação.

Com base no ângulo descrito entre o ponto F, o ponto E e o ponto F’, sendo o ponto F a

coordenada inicial presente no ficheiro carregado, o ponto E a origem, e o

β



ponto F’ o ponto final após uma rotação é possível então aplicar a todas as coordenadas do

ficheiro original a matriz referida, de modo a calcular as coordenadas X e Y finais de cada ponto.

É de salientar ainda que o ângulo é positivo se o movimento for realizado de F para F’ e negativo

se o movimento tiver o sentido inverso. Não obstante, a matriz de rotação a utilizar tem o

seguinte formato:

[𝑋′

𝑌′] = [

cos 𝛽 − sin 𝛽sin 𝛽 cos 𝛽

] [𝑋𝑌

]

Exemplificando novamente com o ponto B, o cálculo seria o seguinte:

𝑋𝑓𝑖𝑛𝑎𝑙_𝑝𝑜𝑛𝑡𝑜𝐵 = cos 𝛽 × 𝑋𝑖𝑛𝑖𝑐𝑎𝑙_𝑝𝑜𝑛𝑡𝑜𝐵 − sin 𝛽 × 𝑌𝑖𝑛𝑖𝑐𝑎𝑙_𝑝𝑜𝑛𝑡𝑜𝐵

𝑌𝑓𝑖𝑛𝑎𝑙_𝑝𝑜𝑛𝑡𝑜𝐵 = sin 𝛽 × 𝑋𝑖𝑛𝑖𝑐𝑎𝑙_𝑝𝑜𝑛𝑡𝑜𝐵 + cos 𝛽 × 𝑌𝑖𝑛𝑖𝑐𝑎𝑙_𝑝𝑜𝑛𝑡𝑜𝐵

Posto isto, é de sublinhar que este cálculo só pode ser efetuado caso seja conhecido o

valor do ângulo de rotação, no entanto, este método pretende aplicar um offset com o objetivo

de corrigir um erro ao inserir a placa no sistema, logo, o valor do ângulo vai ser desconhecido e

também será necessário calcula-lo. Para determinar o valor desse ângulo, são utilizadas as

coordenadas de dois pontos, o ponto A e o ponto B, e também é fundamental informar o sistema

sobre comprimento da placa em causa. O comprimento da placa servirá para a realização de um

cálculo extra, para obtenção um ponto auxiliar. A partir destes três pontos, é definido um

triângulo com o intuito de aplicar o teorema de Coisin, descobrindo assim o ângulo que existe

entre a placa colocada no sistema e a origem. Equivalentemente, obtém-se o ângulo que existe

entre as coordenadas iniciais do ficheiro e as coordenadas finais a fornecer à máquina de todos

os pontos.

Novamente utilizando o ponto B, após determinado o valor do ângulo β (10º no exemplo

desenhado), é aplicada a matriz de rotação acima descrita para a realização do cálculo das

coordenadas:

𝑋𝑓𝑖𝑛𝑎𝑙_𝑝𝑜𝑛𝑡𝑜𝐵 = cos 𝛽 × 𝑋𝑖𝑛𝑖𝑐𝑎𝑙_𝑝𝑜𝑛𝑡𝑜𝐵 − sin 𝛽 × 𝑌𝑖𝑛𝑖𝑐𝑎𝑙_𝑝𝑜𝑛𝑡𝑜𝐵 = 5209 (Errado)

𝑌𝑓𝑖𝑛𝑎𝑙_𝑝𝑜𝑛𝑡𝑜𝐵 = sin 𝛽 × 𝑋𝑖𝑛𝑖𝑐𝑎𝑙_𝑝𝑜𝑛𝑡𝑜𝐵 + cos 𝛽 × 𝑌𝑖𝑛𝑖𝑐𝑎𝑙_𝑝𝑜𝑛𝑡𝑜𝐵 = 29544 (Errado)

Comparando os resultados obtidos com as coordenadas do ponto B na Figura 30,

verifica-se que o valor obtido não é o correto, concluindo-se portanto que aplicar apenas a matriz

de rotação pode não ser suficiente. Neste sentido, a solução final para o cálculo das novas

coordenadas passa por somar diretamente as coordenadas do ponto A a todas as coordenadas



do ficheiro inicial, e simultaneamente aplicar a matriz de rotação às mesmas. Posto isto, a

expressão final para o cálculo com o propósito de realizar um ajuste de offset de forma eficiente

seria:

𝑋𝑓𝑖𝑛𝑎𝑙 = (cos 𝛽 × 𝑋𝑖𝑛𝑖𝑐𝑎𝑙 − sin 𝛽 × 𝑌𝑖𝑛𝑖𝑐𝑎𝑙) + 𝑋𝑝𝑜𝑛𝑡𝑜𝐴

𝑌𝑓𝑖𝑛𝑎𝑙 = (sin 𝛽 × 𝑋𝑖𝑛𝑖𝑐𝑎𝑙 + cos 𝛽 × 𝑌𝑖𝑛𝑖𝑐𝑎𝑙) + 𝑌𝑝𝑜𝑛𝑡𝑜𝐴

Figura 32 - Fluxograma do processo de ajuste do offset.

5.4 Resumo

De modo a obter o produto final desejado no âmbito desta dissertação, foi necessário

definir determinados mecanismos a nível de programação, assim como utilizar ferramentas

matemáticas, para que o design projetado pudesse ser implementado. Relativamente aos

aspetos algorítmicos desta aplicação, é de salientar a preocupação exercida para que os

algoritmos explicados, quer para o processo de divisão de uma instrução, quer para dar início a

um movimento, fossem executados de um modo mais genérico possível, com o intuito de inserir

flexibilidade na aplicação. Convém também referir que embora o sistema físico não esteja pronto



para executar instruções “M”, a estrutura do software desenvolvido foi criada de modo a ser

possível incorporar facilmente a implementação para executar esse tipo de instruções. Por fim,

convém apenas referir que no que diz respeito ao processo para ajuste de offset, não só foi

necessário a utilização de funções informáticas trabalhadas para realizar este processo, como

também foi essencial a utilização de cálculos e teorias matemáticas, de modo ser possível

efetuar esse ajuste, e consequentemente, tornar esta aplicação verdadeiramente operacional.

Por fim, após efetuado o debug do software implementado e serem realizados diversos

testes com o intuito de verificar, não só o funcionamento do armazenamento das variáveis, como

também verificar se as funções invocadas utilizam os parâmetros corretos, foram então

executados movimentos na máquina com o objetivo de corroborar a aplicação desenvolvida.



Capítulo 6 - Resultados Pedro Miguel Pereira 63

Capítulo 6

6. Resultados

64 Pedro Miguel Pereira Capítulo 7- Conclusão e Trabalho Futuro

Derivado do caracter prático desta dissertação, tornou-se difícil transpor para um

documento escrito os resultados obtidos que permitiram confirmar a funcionalidade do software

desenvolvido, quando este foi testado na célula de trabalho. Não obstante, através de outros

mecanismos, nomeadamente utilizando screenshots durante o debug da aplicação concebida,

será demonstrado o bom funcionamento da mesma.

Neste capítulo, inicialmente será acompanhado passo a passo o processo encarregue de

separar uma instrução e determinar os valores provenientes da mesma. Depois serão

comprovados, recorrendo a um exemplo realista, os cálculos referentes ao ajuste de offset.

Seguidamente será demonstrada a correta invocação das funções referentes ao início do

movimento. Por fim, serão realçados alguns procedimentos essenciais relativos à conversão dos

parâmetros das instruções, mais especificamente, os mecanismos utilizados para determinar

valores decimais e valores negativos. É de salientar também que ao longo deste capítulo serão

expostos diversos screenshots não só da interface desenvolvida, como também do feedback

fornecido relativamente ao processo em execução.

6.1 Separar texto

O processo que tem como função separar os parâmetros de cada instrução, foi o primeiro

processo a ser testado. A opção “Separar Texto” representa uma parte fulcral da aplicação

desenvolvida, sendo a base para todos os procedimentos a nível de manipulação automática que

daqui advêm. A sequência de imagens seguinte pretende mostrar quais as opções a escolher

para carregar um ficheiro para o sistema (sem ajuste de offset). Neste sentido, a primeira figura

é representativa da janela inicial da aplicação desenvolvida, e tal como já foi referido, esta

contém as opções “Manipulação Automática” e “Manipulação Manual”. Para que seja possível

carregar um ficheiro, a opção que faculta a manipulação automática da máquina foi selecionada.

Assim sendo, aparece então a janela que possibilita um “Ajuste de offset” ou “Carregamento

ficheiro”, visível na Figura 34. Seguidamente é apresentada a janela referente ao carregamento

do ficheiro cuja função é procurar, ler e separar um ficheiro escrito em Código-G que o utilizador

pretenda executar.


Figura 33 - Janela inicial da aplicação desenvolvida.

Figura 34 - Janela que possibilita a escolha entre ajustar o offset ou carregar um ficheiro.

Figura 35 - Janela que permite a procura, leitura e divisão de um ficheiro.


Posto isto, após completados estes três passos, o ficheiro escrito em Código-G escolhido

pelo utilizador já está inserido no sistema e pronto para ser “trabalhado”.

Neste caso e a título exemplificativo, o primeiro ficheiro utilizado para a comprovação de

resultados está exposto na Figura 36:

Figura 36 - Exemplo de Código-G para execução de movimentos retilíneos com velocidade pré-definida.

Este ficheiro de texto escrito em Código-G contém movimentos retilíneos (G00) nos eixos

do X e do Y, com uma velocidade pré-definida, e com as coordenadas de cada instrução

projetadas em modo relativo (G91). Recorrendo novamente ao uso de screenshots, a sequência

de figuras seguinte pretende comprovar a explicação descrita no capítulo anterior no que diz

respeito à determinação dos parâmetros.

Tal como já foi referido, assim que o botão “Separar Texto” for selecionado, cada instrução

do ficheiro é dividida caractere a caractere. A Figura 37 demonstra o método utilizado para

determinar se o caractere em causa é do tipo “inteiro” ou “string”. Para tal, é testado o seu

valor de acordo com a tabela ASCII, ou seja, se o valor do caractere em causa for menor que 65

(código ASCII) e não coincidente com os valores dos símbolos ‘,’, nem ’-‘, cujo valor em ASCII é

igualmente menor que 65, o sistema está perante a deteção de um número inteiro. Caso o seu

valor seja superior a 65 e não coincidente com os valores das strings ’F’, ‘I’ ou ’J’, significa que

o software detetou uma letra representativa de um eixo, nomeadamente, “X”, “Y”, ou “Z”. Este

procedimento de deteção repete-se para os símbolos “,” e “-“, e parar as strings “F”, “I” e “J”,

representativas da velocidade do movimento, offset do X e offset do Y respetivamente. É de

salientar que caso nenhuma das condições seja verdadeira, o software informa o utilizador dessa

situação através de uma mensagem de erro.


Figura 37 – Condições utilizadas para determinar qual o tipo e qual o valor do caractere em causa.

Posto isto, conforme a verificação de veracidade de cada condição, o caractere em causa

é guardado de acordo com o seu tipo. Utilizando como exemplo a execução deste processo para

a terceira instrução do ficheiro referido, é possível verificar através da Figura 38 que cada

número presente na terceira instrução do mesmo, foi alocado num vetor de inteiros, e cada

string encontrada foi alocada numa vetor de strings.

Figura 38 - Preenchimento dos vectores com os caracteres da terceira instrução do ficheiro carregado.


Assim que forem detetados e guardados todos os caracteres de cada instrução, é então

executado o procedimento encarregue da concatenação e conversão dos caracteres alocados

nos vetores referidos, em parâmetros passiveis de serem utilizados pelas funções da biblioteca

da NI. Neste sentido, a Figura 39 pretende demonstrar o método utilizado para determinar o

valor do segundo parâmetro (a titulo de exemplo) da instrução em causa, ou seja, o

procedimento usado para inserir no sistema o valor “50,9” como primeira coordenada do eixo X.

Inicialmente recorrendo à variável “tamanho do parâmetro”, é realizada uma condição para

verificar quantos caracteres são necessários para definir o parâmetro referido, neste caso,

“tamanho do parâmetro” tem o valor “3”. Posto isto, recorrendo ao excerto de código da Figura

39, na primeira linha é possível verificar que este bloco de código encontra-se dentro de um

“switch case”. A variável que vai definir qual o “case” a utilizar vai ser o índice onde foi

encontrada a vírgula do parâmetro em causa, neste caso, com o valor “2”. Tendo em

consideração que o parâmetro em causa (50,9) é constituído por três números, de acordo com o

valor do índice referido, a vírgula será então colocada entre o segundo caractere numérico e o

terceiro, formando a string “segundo_parametro_string” visível na janela Watch1. Assim que

esta string esteja definida, é efetuada a sua conversão direta para uma variável do tipo decimal,

“numero_decimal”. Nesta fase, dado que o ficheiro foi projetado em milímetros (G21), é

realizada a conversão do número decimal determinado para counts, ou seja, após a

multiplicação do valor 50.9 (em milímetros) pela constante de conversão de milímetros para

counts, obtém-se o valor 3393 (em counts). Isto significa que um movimento da máquina de

50,9 mm corresponde então a um movimento de 3393 counts. Posto isto, convém salientar que

caso a flag correspondente à deteção de um sinal negativo estivesse ativa, seria realizada uma

multiplicação final do valor calculado em counts (3393) pela constante “-1”. Por fim, o valor final

obtido será alocado num vetor de acordo com o eixo a que está associado.


Figura 39 - Excerto de código utilizado para determinar um parâmetro decimal constituído por três carateres.

Posto isto, na Figura 40 é visível que todas as coordenadas do ficheiro em causa foram

convertidas e guardadas de acordo com o eixo que pretendem movimentar. Esses serão os

valores a serem utilizados pela função “flex_load_target_pos” durante o processo de preparação

de um movimento.

Figura 40 - Valor das posições pretendidas referentes ao eixo do X e do Y para cada instrução.


Após preenchidos os vetores correspondentes a todas as variáveis presentes no ficheiro,

desde posições e velocidades até offsets, é possível então dar-se início ao movimento projetado

6.2 Início do Movimento

De modo a continuar a comprovar o correto funcionamento da aplicação será então

abordada a invocação das funções relacionadas com o movimento da máquina, dependentes do

tipo de instrução a executar.

Para tal, inicialmente foi utilizado um ficheiro constituído por instruções que permitem a

variação de velocidade de um movimento, assim como instruções de movimentos com

velocidade pré-definida, Figura 41.

Figura 41 - Exemplo de Código-G para execução de movimentos com variação de velocidade.

Neste sentido, considerando a terceira instrução do ficheiro carregado, é possível visualizar

na imagem seguinte que no momento da invocação das funções referentes às posições dos

eixos e velocidade a utilizar, os valores usados estão de acordo com os valores presentes na

instrução em causa.

Figura 42 - Utilização dos valores obtidos, durante a invocação de funções referentes ao movimento da máquina.


É de salientar nesta fase que todos os vectores utilizados para armazenar os parâmetros,

são preenchidos individualmente e independentemente dos restantes. Neste sentido,

incrementado os índices dos vectores definidos para alocar o valor das coordenadas apenas

quando a instrução utiliza o eixo referente às mesmas, é possível manter a coerência entre todos

os parâmetros a utilizar na execução de uma determinada instrução.

Após comprovado funcionamento do software para o ficheiro da Figura 41, com o intuito

de corroborar a funcionalidade para movimentos circulares, o segundo exemplo utilizado é

referente à execução de um ficheiro que contém um movimento circular, Figura 43.

Figura 43 - Exemplo de Código-G contendo um movimento circular com offset do centro em dois eixos.

Convertendo as instruções acima expostas numa representação gráfica, o movimento

obtido seria o seguinte:

Figura 44 - Representação gráfica do movimento descrito no Código-G da imagem anterior.

(0,0)

(0,5000)

(20000,5000)

(19677,11079)

(39677,11079)

Y

X


Figura 45 - Movimento circular ampliado.

Posto isto, aplicando os cálculos já referidos ao movimento da Figura 44, e confirmando

neste caso que os cálculos explicados funcionam mesmo que seja projetado um movimento

circular com offset do centro em dois eixos, os resultados obtidos são os seguintes:

𝑋𝐶𝑒𝑛𝑡𝑟𝑜 = 𝑋𝑖𝑛𝑖𝑐𝑖𝑎𝑙 + 𝐼 = 23800

𝑌𝐶𝑒𝑛𝑡𝑟𝑜 = 𝑌𝑖𝑛𝑖𝑐𝑖𝑎𝑙 + 𝐽 = 8250

tan 𝛽 = 𝑂𝑓𝑠𝑒𝑡𝑌

𝑂𝑓𝑠𝑒𝑡𝑥= 40.53915174 °

𝐴𝑛𝑔𝑢𝑙𝑜 𝑖𝑛𝑖𝑐𝑖𝑎𝑙 = 40.53915174° (Angulo no desenho -> 40.5°)

𝑅𝑎𝑖𝑜 = √(𝑂𝑓𝑠𝑒𝑡_𝑋 2) + (𝑂𝑓𝑠𝑒𝑡_𝑌2) = √(38002) + (32502) = 5000.249994

𝑃𝑜𝑛𝑡𝑜 𝑀é𝑑𝑖𝑜 = √(𝑋𝑏 − 𝑋𝑎)2 + (𝑌𝑏 − 𝑌𝑎)2

2

= √(19677 − 20000)2 + (11079 − 5000)2

2

= 3043.787525

4. sin 𝛼 = 𝑃𝑜𝑛𝑡𝑜 𝑀é𝑑𝑖𝑜

𝑅𝑎𝑖𝑜 → 𝛼 = 37.49971662°

5. 𝜃 = 2 × 𝛼 = 74.99943323°

6. 𝐴𝑛𝑔𝑢𝑙𝑜 𝑎 𝑝𝑒𝑟𝑐𝑜𝑟𝑟𝑒𝑟 = −𝜃 = −74.99943323 (Angulo desenhado -> 75°)

O excerto de código seguinte demonstra a implementação das funções utilizadas para

realização dos cálculos referentes a movimentos circulares. É possível confirmar, através da

(19677,11079)

(23800,8250)

(20000,5000)


Figura 46, que os valores calculados teoricamente, correspondem aos valores obtidos durante a

execução da aplicação. Por fim, a Figura 47, tem como intuito demonstrar que os valores

calculados para as variáveis referentes a movimentos circulares, são utilizados no momento de

invocação da função “flex_load_circular_arc”.

Figura 46 – Excerto de Código referente à implementação dos cálculos referidos.

Figura 47 – Invocação da função referente ao movimento circular, utilizando os valores calculados.

Convém relembrar que antes da execução de qualquer cálculo, é realizado um conjunto de

testes para determinar a gama do ângulo que é percorrido no movimento. Caso esse valor seja

entre 0 e 180, são efetuados na íntegra os cálculos previamente mostrados, no entanto, na

eventualidade das condições realizadas determinarem que o valor desse angulo está entre 180 e

360, todos cálculos referidos são novamente aplicados, acrescentando apenas mais um detalhe

no final, sendo este respetivamente:

𝜑 = 360 − 𝜃


6.3 Ajuste do Offset

A última funcionalidade a ser testada no âmbito desta dissertação foi a realização de um

ajuste de offset. Sendo este novamente um processo de caracter fortemente prático referente à

opção de manipulação automática, para expor o correto funcionamento desta opção neste

documento, e de acordo com o exemplo de uma aplicação real apresentado no capítulo 4, foi

então utilizado um exemplo concreto de uma possível deslocação e rotação involuntária de uma

placa onde se pretende executar o ficheiro carregado da Figura 48. O ficheiro escrito em Código-

G correspondente à execução do movimento referido na placa é o seguinte:

Figura 48 – Código-G representativo do movimento que se pretende executar na placa.

Figura 49 - Exemplo de um deslocamento e rotação involuntária de uma placa onde se realizará um movimento com a geometria descrita no Código-G apresentado.

De acordo com o que já foi explicado previamente, será aplicada uma matriz de rotação

a todas as coordenadas presentes no ficheiro carregado. Neste sentido, é então essencial nesta

fase que o utilizador introduza os parâmetros necessários para a realização dos cálculos

referidos. A imagem seguinte pretende mostrar a janela que permite a inserção no sistema


desses mesmos parâmetros:

Figura 50 – Janela referente à opção “Ajuste de Offset”.

Explicando de modo sequencial as opções presentes nesta janela, ao “Ativar

Movimento”, o utilizador está a habilitar a possibilidade de controlar a máquina através do

teclado do computador. Esta funcionalidade vai possibilitar deslocar o cursor da mesma para os

pontos que vão permitir realizar os cálculos necessário e guardar as coordenadas do mesmo,

neste caso, o cursor deslocou-se para o ponto (5831, 2076). A opção “Guardar Comprimento”

tem como função inserir no sistema o comprimento da placa introduzido pelo utilizador. Por fim,

após completada esta sequência, ao selecionar a opção “Carregar Ficheiro”, a aplicação abre a

janela referente ao carregamento de um ficheiro já abordada neste capítulo. No entanto, nesta

situação já será considerado o ajuste de offset realizado, e conforme a determinação de cada

parâmetro através dos procedimentos já descritos, é aplicada no final uma matriz de rotação aos

mesmos. Neste sentido, antes de demonstrar o correto preenchimento dos vectores no que diz

respeito aos valores calculados para as novas coordenadas, convém mostrar também que o

valor obtido para o ângulo de rotação a utilizar na matriz de rotação referida, está de acordo com

o ângulo de rotação aplicado na Figura 49.


Figura 51 – Excerto de código referente à implementação dos cálculos efetuados para determinar o ângulo de rotação.

Posto isto, são então mostrados, na Figura 52, os valores finais a utilizar no momento de

invocação das funções referentes ao movimento da máquina, presentes nos vectores

“coordenadadas_rot_x” e “coordenadas_rot_y”, correspondentes às novas posições do eixo do

X e do Y respetivamente.

Figura 52 – Preenchimento dos vectores com os valores calculados.

Visualizando a imagem acima, e comparando com os valores das coordenadas após a

rotação, Figura 49, é possível afirmar que os valores obtidos após efetuados os cálculos

referidos, estão corretos. Posto isto, a imagem seguinte tem o intuito de demonstrar novamente

que no momento da invocação da função “flex_load_target_pos”, é utilizado o valor obtido para

o ponto H’ (por exemplo), proveniente de uma rotação do ponto H.


Figura 53 – Invocação da função referente ao movimento retilíneo, utilizando o novo valor calculado.

6.4 Resumo

De um modo resumido, através de uma análise dos resultados obtidos, é possível afirmar

que o software concebido executa com sucesso todos os processos explicados no capítulo da

implementação. Desde processos referentes à divisão de uma instrução, até ao movimento de

um eixo, foi possível comprovar de um modo detalhado o correto funcionamento da aplicação

desenvolvida.

Para complementar todos os resultados demonstrados através de screenshots e cálculos

neste capítulo, foram executados também testes práticos na célula de trabalho, comprovando

assim que o objetivo principal de desenvolver uma aplicação de software que seja

verdadeiramente funcional a nível industrial foi conseguido.

Por fim, é de salientar apenas que o programa concebido não só cumpre com os

requisitos propostos no âmbito desta dissertação, como também possui uma interface simples e

intuitiva, facilitando assim a sua utilização por parte de diferentes utilizadores.



Capítulo 7

7. Conclusão e Trabalho Futuro



7.1 Conclusão

No âmbito desta dissertação foi desenvolvida uma aplicação de carácter prático e

operacional, com o intuito de conceber uma interface que permitisse a comunicação entre

ferramentas de programação rigorosamente testadas em ambientes industriais para

manipulação de máquinas, e novas metodologias de controlo emergentes atualmente na

indústria. Neste sentido, de um modo mais detalhado, foi desenvolvido um software que permite

a leitura de ficheiros escritos em código-G e realize a respetiva conversão do mesmo para uma

linguagem de alto nível passível de ser interpretada por um controlador aberto da National

Instruments. O produto final desta dissertação abrange não só a conceção de uma aplicação

computacional para conversão de linguagens de programação, como também tem como

propósito efetuar a manipulação automática de uma máquina inserida num ambiente industrial.

Os controladores de movimento da NI são dispositivos que possuem características

extremamente apelativas, não só a nível económico face aos controladores atualmente

existentes, como também relativamente às suas funcionalidades e flexibilidade no que diz

respeito à criação de programas. Derivada dessa mesma flexibilidade, foi então possível utilizar a

linguagem de programação C# para o desenvolvimento da interface gráfica, usufruído assim da

sua simplicidade e robustez. A interface gráfica desenvolvida permite a inserção no sistema de

um ficheiro escrito em Código-G para manipulação automática da máquina utilizada no âmbito

desta dissertação, como também possibilita a capacidade de controlar essa mesma máquina

com recurso a parâmetros inseridos diretamente na aplicação.

Contudo, embora a interface desenvolvida seja a componente visual e interativa desta

aplicação, diversos processos foram implementados e estão constantemente a ser executados

conforme a seleção de um botão por parte do utilizador, desde a realização de uma análise

sintática e lexical das instruções contidas num ficheiro carregado, até à verificação do valor de

todos os parâmetros desse mesmo ficheiro.

Em suma, o produto final desta dissertação permite a realização de movimentos

autónomos, suportando neste sentido os comandos G00, G01, G02, G03, G20, G21, G90 e

G91. De um modo sequencial, relativamente a movimentos dos eixos da máquina XYZ, o

software desenvolvido suporta movimentos retilíneos sem e com controlo de velocidade (G00 e

G01) em três eixos, e movimentos circulares no sentido horário e anti-horário (G02 e G03). No

que diz respeito as unidades métricas, a aplicação desenvolvida aceita parâmetros projetados

em inches ou milímetros (G20 e G21). A nível de especificações, o programa suporta valores


Capítulo 7- Conclusão e Trabalho Futuro Pedro Miguel Pereira 81

positivos ou negativos, inteiros ou decimais, verificando sempre os limites dos mesmos de

acordo com a unidade métrica utilizada. Por fim, quanto ao modo de operação da máquina, esta

aplicação aceita os dois modos utilizados na escrita em Código-G para a execução de um

programa, nomeadamente o modo absoluto e o modo incremental (G90 e G91).

Posto isto, é de salientar que o desenvolvimento desta aplicação para além de ter como

propósito a conceção de um conversor de linguagens, tem também o principal objetivo de ser

um software passível de ser aplicado num ambiente industrial. Neste sentido, a conversão direta

das instruções referidas não seria suficiente para manusear a máquina de modo eficaz, surgindo

então o procedimento de ajuste de offset implementado neste programa. Com este processo, é

possível ajustar circunstâncias desfavoráveis no que diz respeito a especificações geométricas,

de modo a não interferirem no resultado final que se espera obter.

Concludentemente, o software desenvolvido é completo a nível de conversão das

instruções, é bastante operacional, e superou os testes realizados na célula de trabalho descrita.

Neste sentido, considerando todas as funcionalidades da aplicação concebida, é possível afirmar

que o objetivo, já exposto detalhadamente neste documento, foi cumprido.

7.2 Trabalho Futuro

De modo a complementar a aplicação de software desenvolvida nesta dissertação, seria

então útil implementar mais algumas funcionalidades na mesma.

A nível de conversão de instruções, uma vez que a estrutura do programa concebido foi

projetada com o intuito de ser o mais flexível possível, sugeria-se então a integração de novas

instruções, nomeadamente, comandos “M”, referentes a processos de maquinagem.

Por outro lado, no que diz respeito a métodos de controlo, sugeria-se o desenvolvimento de

mais uma opção que permitisse o controlo de parâmetros como ganho proporcionai, ganho

integral e ganho derivativo, consoante a instrução a ser executada.

No que diz respeito à operacionalidade do sistema, atualmente na ocorrencia de um erro,

quer em caso de falha durante a invoção de alguma das funções referidas, quer pelo antigir do

limite maximo definido, o programa desenvolvido bloquea o sistema por razões de segurança e

este necessita de ser reiniciado pelo utilizador. Neste sentido, poderá ser vantajoso desenvolver

uma solução em que permita resolver este problema de uma forma mais autonoma e com a

possibilidade de manter o sistema ativo.



Posto isto, aliando o software com estas novas funcionalidades, à célula de trabalho em

causa, seria obtido um leque mais alargado de aplicações associadas a processos autónomos,

passiveis de serem executadas pelo sistema utilizado no âmbito desta dissertação.


Capítulo 8- Referências bibliográficas Pedro Miguel Pereira 83

8. Referências Bibliográficas

[1] N. Zealand, “Simulation and optimization in a multi-process environment using STEP-NC,” pp.

2384–2391, 2009.

[2] S. Krar, G. Arthur, and P. Smid, Computer numerical control : simplified, Fisrt Edit. New York,

2000.

[3] P. Smid, CNC programming handbook : a comprehensive guide to practical CNC programming,

First Edit. New York, 2000.

[4] H. Hong, X. Zhang, and L. Chen, “Researh on a new model of numerical control program

interpreter,” 2010 2nd Int. Conf. Adv. Comput. Control, pp. 467–472, 2010.

[5] Y. Junyu and Z. Wei, “STEP integration of CAD/CAM & CAPP in numerical control machining,”

2009 16th Int. Conf. Ind. Eng. Eng. Manag., pp. 848–850, Oct. 2009.

[6] “History of numerical control,” 2014. [Online]. Available:

http://en.wikipedia.org/wiki/History_of_numerical_control. [Accessed: 25-Sep-2014].

[7] “CNC Milling Machine,” 2013. [Online]. Available: http://www.kingjoy-

hk.com/shebei_show.asp?id=39.

[8] P. Kr, A. Stoic, J. Kopa, M. Engineering, I. Ever, T. Cad, C. Statethe, F. Of, and C. N. C.

Programming, “STEP-NC : A New Programming Code for the CNC Machines,” vol. 55, pp. 406–417,

2009.

[9] F. Calabrese and N. Federico, “Design and Realization of a STEP-NC Compliant CNC Embedded

Controller Giovanni Celentano,” pp. 1010–1017, 2007.

[10] X. W. Xu, “STEP-NC and function blocks for interoperable manufacturing,” IEEE Trans. Autom.

Sci. Eng., vol. 3, no. 3, pp. 297–308, Jul. 2006.

[11] O. Hua-bing and S. Bin, “Research on the Conversion from Design Features to Machining

Features Faced on STEP-NC,” 2011 Third Int. Conf. Meas. Technol. Mechatronics Autom., vol. d, pp.

103–106, Jan. 2011.

[12] Q. Shu, G. Gong, and A. Sun, “Implementation of CAM System Integration Between STEP-NC and

UG,” 2010 Third Int. Conf. Intell. Networks Intell. Syst., pp. 657–660, Nov. 2010.


84 Pedro Miguel Pereira Capítulo 8- Referências bibliográficas

[13] P. Principles, “Notice of retraction.,” J. Indian Soc. Periodontol., vol. 18, no. 4, p. 425, Jul.

2014.

[14] “AdvaNum NC Verification,” 2005. [Online]. Available: http://www.advameric.com/vs.html.

[15] “AdvaNum Program Editor,” 2005. [Online]. Available: http://www.advameric.com/pe.html.

[16] “Mach3 General Features,” 2014. [Online]. Available:

http://www.machsupport.com/software/mach3/.

[17] “Mach3,” 2014. [Online]. Available: http://www.machsupport.com/software/mach3/.

[18] “Control Software - Highlights of What’s New in Version 4.5,” 2014. [Online]. Available:

http://www.flashcutcnc.com/cnc-controls/control-software.

[19] “Highlights of What’s New in Version 4.5,” 2014. [Online]. Available:

http://www.flashcutcnc.com/cnc-controls/control-software.

[20] “G-Wizard Editor,” 2012. [Online]. Available: http://www.cnccookbook.com/CCGWizardE.html.

[21] “CNC Professional - Features.” [Online]. Available: http://www.camsoftcorp.com/prod02d.asp.

[22] “NC Professional Example Operator Interfaces.” [Online]. Available:

http://www.cnccontrols.com/pgallery.htm#.

[23] “10 Essential Technologies for High-Performance Motion Control,” 2014. [Online]. Available:

http://www.ni.com/white-paper/2953/en/.

[24] “Ni Motion Assistant,” 2014. [Online]. Available:

http://sine.ni.com/nips/cds/view/p/lang/pt/nid/11091.

[25] “Módulo LabVIEW NI SoftMotion,” 2014. [Online]. Available:

http://sine.ni.com/nips/cds/view/p/lang/pt/nid/14234.

Anexo I

Lista dos principais comandos do Código-G

Comandos “G”

(Funções preparatórias.)

G00 Posicionamento rápido

G01 Interpolação linear

G02 Interpolação circular no sentido horário (CW)

G03 Interpolação circular no sentido anti-horário (CCW)

G06 Interpolação parabólica

G20 Programa projetado em Inches

G21 Programa projetado em Milímetros

G28 Retornar à posição zero da maquina

G40 Cancelar a compensação do diâmetro da ferramenta

G41 Compensar o diâmetro da ferramenta (Esquerda)

G42 Compensar o diâmetro da ferramenta (Direita)

G43 Compensar o comprimento da ferramenta (Positivo)

G44 Compensar o comprimento da ferramenta (Negativo)

G49 Cancelar a compensação do comprimento da ferramenta

G90 Programa projetado em modo absoluto

G91 Programa projetado em modo incremental

Comandos “M”

(Miscelânea de funções, maioritariamente relacionadas com a máquina.)

M02 Fim do programa

M03 Rodar a ferramenta no sentido horário (CW)

M04 Rodar a ferramenta no sentido anti horário (CCW)

M05 Desligar a rotação da ferramenta

M06 Mudar a ferramenta

M30 Fim do programa; Voltar ao início

Documents

Pedro Miguel Gonçalves da Costa Pereira Desenvolvimento de uma