Post on 09-Jul-2022
INSTITUTO FEDERAL DE SANTA CATARINA
GIOVANI ROPELATO
DESENVOLVIMENTO DE UM CONTROLADOR PARA
SISTEMA DE COORDENADAS XZ
DESCRITO EM VHDL E IMPLEMENTADO EM FPGA
Florianópolis
Abril, 2019
GIOVANI ROPELATO
DESENVOLVIMENTO DE UM CONTROLADOR PARA
SISTEMA DE COORDENADAS XZ
DESCRITO EM VHDL E IMPLEMENTADO EM FPGA
Dissertação apresentada ao
Programa de Mestrado em
Mecatrônica do Câmpus
Florianópolis do Instituto
Federal de Santa Catarina
para a obtenção do diploma
de Mestre em Mecatrônica
Orientador: Me. Francisco
Édson Nogueira de Melo
Florianópolis
Abril, 2019
CDD 629.8
R784d Ropelato, Giovani
Desenvolvimento de um controlador para sistemas de coordenadas XZ descrito em VHDL e implementado em FPGA [DIS] / Giovani Ropelato; orientação de Francisco Édson Nogueira de Melo – Florianópolis, 2019.
1 v.: il.
Dissertação de Mestrado (Mecatrônica) – Instituto Federal de Educação, Ciência e Tecnologia de Santa Catarina.
Inclui referências. 1. Sistema de coordenadas XZ. 2. Interpolação linear. 3. VHDL. I. Melo, Francisco
Édson Nogueira de. II. Título.
Sistema de Bibliotecas Integradas do IFSC
Biblioteca Dr. Hercílio Luz – Campus Florianópolis Catalogado por: Ana Paula F. Rodrigues Pacheco - CRB 14/1117
GIOVANI ROPELATO
DESENVOLVIMENTO DE UM CONTROLADOR PARA
SISTEMA DE COORDENADAS XZ
DESCRITO EM VHDL E IMPLEMENTADO EM FPGA
Este trabalho foi julgado adequado para obtenção do título de Mestre em
Mecatrônica, pelo Instituto Federal de Educação, Ciência e Tecnologia de Santa
Catarina, e aprovado na sua forma final pela comissão avaliadora
abaixo indicada.
Florianópolis, 26, abril de 2019.
__________________________________________________________________________________________________________________________________________ ___________________________________________________________________________________________________________________________________________________________________________________
Prof. Francisco Édson Nogueira de Melo, Me.
Orientador
Instituto Federal de Educação, Ciência e Tecnologia de Santa Catarina
Prof. Adriano Regis, Me.
Instituto Federal de Educação, Ciência e Tecnologia de Santa Catarina
Prof. Maurício Edgar Stivanello, Dr.
Instituto Federal de Educação, Ciência e Tecnologia de Santa Catarina
Prof. Fernando Michelon Marques, Me.
Instituto Federal de Educação, Ciência e Tecnologia de Santa Catarina
AGRADECIMENTOS
Gostaria de agradecer ao professor Édson por ter aceito o desafio de me
orientar nesse projeto. Sempre fui curioso por aprender a respeito da área de FPGA,
a qual eu desconhecia até a entrada no mestrado. O professor Édson, com paciência
e excelente didática, ao decorrer desse período, contribuiu muito para o meu
aprendizado.
Agradeço também ao Instituto Federal de Educação, Ciência e Tecnologia de
Santa Catarina – IFSC, instituição na qual me orgulho de fazer parte enquanto
estudante e professor. Agradeço aos professores do Programa de Mestrado em
Mecatrônica que muito me ensinaram ao decorrer das unidades curriculares que
cursei. Agradeço ao câmpus Chapecó, que ofereceu a estrutura necessária para a
realização desse projeto.
Aos amigos que contribuíram, dando hospedagem na cidade de Florianópolis,
dividindo hospedagem em Chapecó, trocando ideias e aconselhando, meus
agradecimentos. Em especial, agradeço ao meu amigo e colega de trabalho, professor
Fernando Michelon Marques, meu parceiro no projeto de pesquisa, no qual validei
minha dissertação.
Por fim, agradeço aqueles que estão comigo desde o começo: meu pai, minha
mãe e minha irmã. A sensibilidade e o carinho de vocês são exemplo e incentivo que
levo para minha vida.
“May the force be with you”.
(Star Wars)
RESUMO
O presente trabalho apresenta o desenvolvimento de um controlador para o
acionamento de motores de passo em um sistema de coordenadas XZ, utilizado em
um dispositivo High Speed Cutting, desenvolvido pelo Instituto Federal de Educação,
Ciência e Tecnologia de Santa Catarina, câmpus Chapecó. O controlador, descrito em
VHDL, é implementado no FPGA MAX 10 da Intel, e utiliza o sistema embarcado na
placa didática DE10 – LITE. O algoritmo desenvolvido no controlador é composto por
códigos de busca de zero máquina, movimentos manuais controlados via joystick
analógico, posicionamentos com interpolação linear entre os eixos das coordenadas
X e Z, rampas de aceleração e desaceleração e memória RAM para armazenamento
de trajetória. O código fonte é aberto aos usuários e pode ser utilizado em atividades
de ensino, pesquisa e extensão. A validação do algoritmo de interpolação linear é
realizada através do deslocamento da ferramenta por uma trajetória fixa, armazenada
na memória RAM, além disso, os cálculos de sincronismo são testados via simulação,
com o software ModelSim. Os ensaios de repetibilidade resultam num erro máximo de
posicionamento de 0,02 mm, para ambos os eixos.
Palavras-Chave: FPGA. VHDL. Sistema de coordenadas XZ. Interpolação linear.
ABSTRACT
This paper presents the development of a controller for driving stepping motors in a
XZ coordinate system, used in a High Speed Cutting device developed by the Instituto
Federal de Educação, Ciência e Tecnologia de Santa Catarina. The controller,
described in VHDL, is implemented in Intel 's MAX 10 FPGA, and uses the embedded
system in the DE10 - LITE board. The algorithm presents codes as home, manual
movements controlled via analog joystick, positions with linear interpolation between
X and Z axes, acceleration and deceleration ramps and RAM memory for path storage.
The source code is open to users and can be used in teaching, research and extension
activities. The validation of linear interpolation algorithm is performed by moving the
tool through a fixed path, stored in RAM, moreover, the synchronism calculations are
tested by simulation with the ModelSim software. Repeatability tests result in a
maximum position error of 0.02 mm for both axes.
Keywords: FPGA. VHDL. XZ coordinate system. Linear Interpolation.
LISTA DE FIGURAS
Figura 1 – Arquitetura PAL............................................................................. 18
Figura 2 – Arquitetura PLA............................................................................. 19
Figura 3 – Diagrama da macro célula............................................................ 20
Figura 4 – Arquitetura básica de CPLDs........................................................ 21
Figura 5 – Estrutura básica de um FPGA...................................................... 22
Figura 6 – Blocos Lógicos Configuráveis – CLB (a) e Módulo Lógico (b)...... 22
Figura 7 – Estrutura típica da família MAX 10................................................ 25
Figura 8 – Dados de configuração................................................................. 26
Figura 9 – Estrutura LAB no MAX 10............................................................. 27
Figura 10 – Estrutura LE no MAX 10............................................................. 28
Figura 11 – DE10-Lite.................................................................................... 29
Figura 12 – Modelo FPGA.............................................................................. 30
Figura 13 – Fluxo do projeto na ferramenta de software............................... 32
Figura 14 – Estrutura do Modelo PRODIP..................................................... 47
Figura 15 – Estrutura mecânica do sistema de coordenadas........................ 50
Figura 16 – Fluxograma operacional do sistema de coordenadas................ 52
Figura 17 – Projeto Elétrico – Parte de Potência........................................... 57
Figura 18 – Projeto Elétrico – Parte de Comando.......................................... 58
Figura 19 – Símbolos..................................................................................... 60
Figura 20 – Blocos adc e counter................................................................... 61
Figura 21 – Sinais da placa DE10-Lite e saídas para os drives de potência 61
Figura 22 – Variação de velocidade em modo manual.................................. 63
Figura 23 – Perfil de velocidade dos motores................................................ 64
Figura 24 – Formas de onda para interpolação linear dos motores............... 69
Figura 25 – Análise de repetibilidade com relógio comparador..................... 71
Figura 26 – Curva de Erros da Coordenada Z............................................... 75
Figura 27 – Curva de Erros da Coordenada X............................................... 78
Figura 28 – Octógono regular com lados de 5 mm........................................ 79
Figura 29 – Ferramenta construída para testes............................................. 81
Figura 30 – Trajetória percorrida pela ferramenta de teste............................ 83
Figura 31 – Leitura de corrente no motor X................................................... 84
Figura 32 – Corrente no motor da coordenada X........................................... 85
Figura 33 – Corrente no motor da coordenada Z........................................... 86
LISTA DE TABELAS
Tabela 1 – Tipos predefinidos no pacote padrão VHDL................................ 35
Tabela 2 – Comparativo de características: Motor de passo X Servomotor 54
Tabela 3 – Lista de materiais elétricos........................................................... 55
Tabela 4 – Configuração das dip switches, drive AKDMP16-7.2A................ 56
Tabela 5 – Análise de precisão da coordenada Z.......................................... 70
Tabela 6 – Análise de precisão da coordenada X.......................................... 70
Tabela 7 – Repetibilidade do eixo de coordenada Z...................................... 72
Tabela 8 – Repetibilidade do eixo de coordenada X...................................... 76
Tabela 9 – Resultados de cálculos para interpolação linear.......................... 80
LISTA DE QUADROS
Quadro 1 – Exemplo de código em VHDL............................................... 34
Quadro 2 – Construção WHEN ELSE...................................................... 36
Quadro 3 – Construção WITH SELECT................................................... 37
Quadro 4 – Construção CASE WHEN..................................................... 37
Quadro 5 – Construção IF ELSE............................................................. 38
Quadro 6 – Código VHDL para Somador Completo................................ 38
Quadro 7 – Utilização de Componentes em VHDL – Somador de 4 bits 39
Quadro 8 – FUNÇÃO em VHDL.............................................................. 40
LISTA DE ABREVIATURAS E SIGLAS
ADC – Analog to Digital Converter
ASIC – Application-Specific Integrated Circuit
CFM – Configuration Flash Memory
CLB – Configurable Logic Block
CNC – Comando Numérico Computadorizado
CPLD – Complex Programmable Logic Device
EDA – Electronic Design Automation
FPGA – Field Programmable Gate Array
GAL – Gereric Array Logic
IFSC – Instituto Federal de Educação, Ciência e Tecnologia de Santa Catarina
IHM – Interface Humano Máquina
IP – Intellectual Property
ISP – In System Programming
JTAG – Joint Test Action Group
LAB – Logic Array Block
LPM – Library of Parameterirez Module
LUT – Look Up Table
PAL – Programmable Array Logic
PID – Proporcional, Integral e Derivativo
PLA – Programmable Logic Array
PLD – Programmable Logic Device
PLL – Phase Locked Loop
PWM - Pulse Width Modulation
RTL – Register Transfer Level
SPLD – Simple Programmable Logic Device
UART – Universal Asynchronous Receiver Transmitter
UFM – User Flash Memory
USB – Universal Serial Bus
VHDL – Very High Speed Integrated Circuits – Hardware Description Language
SUMÁRIO
1 INTRODUÇÃO................................................................................................... 13
1.1 Contextualização....................................................................................... 13
1.2 Objetivos..................................................................................................... 16
1.2.1 Objetivo Geral........................................................................................ 16
1.2.2 Objetivos Específicos............................................................................. 16
2 REFERENCIAL TEÓRICO................................................................................ 17
2.1 Dispositivos lógicos programáveis.......................................................... 17
2.2 Família de FPGAs MAX 10 da Intel............................................................ 23
2.2.1 Configuração do dispositivo pela interface JTAG................................... 24
2.2.2 Blocos lógicos configuráveis no MAX 10................................................ 26
2.2.3 Kit didático DE10-LITE........................................................................... 28
2.3 Processo de Desenvolvimento do Projeto em FPGA.............................. 30
2.4 A linguagem de descrição de hardware VHDL......................................... 33
2.5 Estudos realizados na área: FPGA como controlador de eixos............. 41
3 METODOLOGIA................................................................................................ 47
3.1 Requisitos de projeto................................................................................. 48
3.2 Concepção do produto.............................................................................. 53
3.3 Desenvolvimento do protótipo.................................................................. 55
3.3.1 Projeto elétrico e lista dos materiais utilizados........................................ 55
3.3.2 Desenvolvimento e implementação do hardware................................... 59
3.3.2.1 Blocos adc e counter: o uso de propriedades intelectuais da Intel.... 62
3.3.2.2 Componentes desenvolvidos em VHDL........................................... 63
4 ANÁLISE DOS RESULTADOS......................................................................... 67
4.1 Simulação do algoritmo de interpolação linear....................................... 67
4.2 Ensaios de precisão e repetibilidade........................................................ 68
4.3 Análise da trajetória da ferramenta........................................................... 78
4.4 Leitura da corrente dos motores.............................................................. 82
5 CONCLUSÃO.................................................................................................... 87
REFERÊNCIAS.................................................................................................... 90
APÊNDICE A ....................................................................................................... 94
APÊNDICE B ....................................................................................................... 98
13
1 INTRODUÇÃO
1.1 Contextualização
O desenvolvimento tecnológico, desde o surgimento dos primeiros processos
automatizados tem, constantemente, modificado o campo da mecatrônica. A evolução
de diferentes tecnologias nas áreas da mecânica, eletrônica e computação, promove
profundas mudanças nos processos mecatrônicos, atribuindo a estes maior
flexibilidade e autonomia. Essas atribuições – flexibilidade e autonomia – tornaram-se
requisitos importantes para o desenvolvimento de tecnologias mecatrônicas, pois
contribuem nos meios produtivos, auxiliando o ser humano em tarefas fatigantes,
monótonas e uniformes, e também nas atividades pessoais, proporcionando
entretenimento, facilidade de comunicação à distância e acesso a informações.
O emprego dessas novas tecnologias se dá, principalmente, graças à evolução
de circuitos eletrônicos. A miniaturização da eletrônica, iniciada na década de 1940,
com a invenção do transistor, é elemento fundamental na construção de novos
produtos tecnológicos. O avanço da eletrônica tem contribuído de forma relevante
para a expansão tecnológica, devido ao fato de possibilitar a construção de
tecnologias cada vez mais rápidas e compactas.
Nesse contexto, empregam-se os dispositivos lógicos programáveis, dentre
eles o FPGA (Field Programmable Gate Array) que é objeto de estudo desta
dissertação. Os primeiros dispositivos lógicos programáveis, denominados PLDs
(Programmable Logic Devices), foram implementados a partir da década de 1970. De
acordo com Pedroni (2010, p. 413),
A ideia era construir circuitos combinacionais lógicos que fossem
programáveis. Todavia, ao contrário de microprocessadores, que podem
executar um programa, mas possuem hardware fixo, a programabilidade dos
PLDs se dá no nível do hardware. Em outras palavras, um PLD é um chip de
uso geral cujo hardware pode ser configurado para atender especificações
particulares.
Inicialmente, os dispositivos lógicos programáveis empregavam apenas portas
lógicas convencionais, o que possibilitava somente a configuração de lógicas
combinacionais. Desde então, devido ao constante desenvolvimento da tecnologia
14
digital, esses dispositivos evoluíram de forma significativa. Passaram a empregar,
sequencialmente, flip-flop e multiplexadores, em suas saídas – permitindo a criação
de lógicas sequenciais – e foram acrescidos da interface JTAG1, o que permitiu aos
dispositivos serem reconfiguráveis. Dessa forma, no final da década de 1980, foram
lançados os FPGAs. Segundo Pedroni (2010), FPGAs diferem-se dos PLDs em
arquitetura, tecnologia, características embutidas e custo.
O circuito lógico digital implementado no FPGA precisa ser especificado por
alguma ferramenta de descrição de hardware. Dentre essas ferramentas, apresenta-
se a linguagem VHDL (Very High Speed Integrated Circuits – Hardware Description
Language). A linguagem de descrição de hardware VHDL foi desenvolvida pelo
Departamento de Defesa dos Estados Unidos da América na década de 1980 e,
posteriormente, posta em domínio público. Conforme descreve Pedroni (2010, p. 433)
“VHDL é uma linguagem de descrição de hardware independente de tecnologia e de
fabricante. O código descreve o comportamento ou estrutura desejada, a partir do qual
um circuito físico correspondente é inferido pelo compilador”. Ainda, segundo o autor,
o código gerado, depois de escrito e simulado, pode ser usado para a implementação
física em um FPGA, ou para a fabricação de um circuito integrado de aplicação
específica – ASIC (Application-Specific Integrated Circuit). A linguagem VHDL é
difundida mundialmente e utilizada em grande escala em projetos onde deseja-se criar
uma síntese para circuitos digitais complexos. Para d’Amore (2012, p.3),
Devido a sua potencialidade, a linguagem VHDL é complexa, e muitas vezes
de difícil entendimento, dadas as inúmeras opções para modelar o
comportamento de um mesmo circuito. Entretanto, o entendimento de um
pequeno número de comandos, suficiente para o modelamento de estruturas
medianamente complexas, pode ser rapidamente atingido. A necessidade de
projetos mais complexos encaminha à procura por novos comandos levando
a uma maior compreensão das opções da linguagem.
FPGAs são comumente empregados em drives de acionamento e controle de
motores de precisão. Por serem uma solução com rápida resposta de processamento
e possibilitarem reconfiguração de hardware em campo, os fabricantes na área de
controle de movimentação desenvolvem em FPGAs o algoritmo de controle de seus
produtos. A Beckhoff, por exemplo, utiliza FPGA no controle das malhas de corrente
1 A interface JTAG é uma “porta para programação e teste definida pelo Joint Test Action Group, especificada no padrão IEEE 1149.1” (PEDRONI, 2010, p.414).
15
e posição nos drives da linha AX8000, para acionamento de motores de passo e
servomotores (BECKHOFF, 2018). Da mesma forma, a SEW, baseia o controle da
linha MOVIAXIS na utilização de FPGA (SEW, 2011). A fabricante brasileira WEG,
também utiliza FPGA no controle do servoconversor SCA06 (WEG, 2015).
Os controladores de movimentação de múltiplos eixos apresentam grande
aplicabilidade na área da mecatrônica, podem ser utilizados para acionar máquinas
de comando numérico computadorizado, como também movimentar manipuladores e
robôs industriais. Isto é, aplicam-se onde há a necessidade de sincronismo na
movimentação de diferentes eixos (CHO; LE; JEON, 2009).
Dada a ascensão da empregabilidade dos dispositivos lógicos programáveis, e
tendo em vista a necessidade crescente de criar-se produtos mecatrônicos de alta
precisão e com rápida resposta de processamento, apresenta-se aqui o uso do
dispositivo FPGA como controlador dos eixos das coordenadas X e Z em um
dispositivo de usinagem High Speed Cutting (corte em alta velocidade), desenvolvido
pelo Instituto Federal de Santa Catarina – IFSC – câmpus Chapecó.
O dispositivo de usinagem High Speed Cutting, em desenvolvimento no IFSC
– Chapecó, consiste em uma máquina de torneamento com corte em alta rotação,
utilizado para forçar o desgaste em ferramentas, uma vez que as mesmas operam
sob velocidades de corte acima das estipuladas pelos fabricantes.
O controlador desenvolvido nessa dissertação, limita-se ao acionamento dos
motores de passo que acionam o sistema de coordenadas X e Z, no qual está fixa a
ferramenta de corte. Para tanto, o controle é desenvolvido no FPGA modelo MAX 10,
do fabricante Intel, e utiliza o sistema embarcado na placa didática DE10-Lite. O
código fonte desenvolvido está aberto para ser utilizado pelos estudantes nas
atividades de ensino, pesquisa e extensão. O hardware é descrito na linguagem VHDL
e apresenta funções como busca de zero máquina, movimentos manuais comandados
via joystick com sinal analógico e posicionamentos em modo automático com
interpolação linear entre os motores.
A dissertação está segmentada da seguinte forma: os objetivos, principal e
específicos, são apresentados na seção 1.1; o referencial teórico, que fundamenta o
16
projeto desenvolvido nessa dissertação, é descrito no capítulo 2; o capítulo 3 descreve
a metodologia utilizada para o desenvolvimento do presente projeto, bem como,
enfatiza os passos dados para a realização do mesmo; os resultados obtidos em
diferentes ensaios são mostrados no capitulo 4; o capítulo 5 traz as conclusões e
considerações finais; posteriormente, apresentam-se as referências utilizadas como
embasamento teórico para a realização das diferentes etapas do projeto de
dissertação; e, complementando, os materiais de apoio são dispostos nos apêndices.
1.2 Objetivos
1.2.1 Objetivo Geral
Implementar uma solução lógica digital para dispositivos de movimentação de
múltiplos eixos, utilizando o FPGA e a linguagem de descrição de hardware VHDL
como ferramentas de controle dos mesmos.
1.2.2 Objetivos Específicos
• Desenvolver um controlador de velocidade para motores de precisão;
• Sincronizar a movimentação de motores de precisão;
• Criar um controlador para múltiplos eixos, de uso didático, que disponibilize seu
código aberto aos usuários;
• Armazenar as posições de trajetórias criadas para um sistema de múltiplos
eixos;
• Validar o controlador em um sistema de coordenadas de dois eixos.
17
2 REFERENCIAL TEÓRICO
2.1 Dispositivos lógicos programáveis
Os circuitos digitais destacam-se na área de produtos eletrônicos como uma
solução robusta e compacta. Ao passo que a indústria da eletrônica aprimora a
tecnologia empregada no desenvolvimento e fabricação de seus componentes, as
soluções digitais apresentam excelente empregabilidade para o controle de produtos
mecatrônicos. Os sistemas digitais, presentes nas mais variadas aplicações,
apresentam distintas configurações de hardware, que se assemelham por
manipularem o mesmo tipo de sinal, porém, se diferem quanto suas construções
físicas.
Uma solução digital, comumente aplicada para sistemas simples, é baseada no
uso de circuitos integrados de lógica padrão. Os mesmos possuem um número
limitado de circuitos digitais básicos (portas lógicas, flip-flops, comparadores,
decodificadores, contadores etc.) e, quando usados para sistemas complexos,
apresentam a desvantagem de gerar uma solução em hardware volumoso, composto
por inúmeros componentes. Outra solução, que apresenta grande aplicabilidade em
sistemas digitais, é o uso de microcontroladores. Os sistemas microcontrolados
integram soluções de alta complexidade e se caracterizam pela flexibilidade em suas
aplicações, pois possibilitam a alteração do programa que executa as tarefas
necessárias para a realização das soluções propostas. No entanto, o fato de
apresentarem uma solução via software, faz com que a resposta de processamento
seja mais lenta que uma solução via hardware. Em vista disso, há uma crescente
aplicabilidade em soluções baseadas na utilização de dispositivos lógicos
programáveis (PLDs). Estes dispositivos diferem-se de outros hardwares para
circuitos digitais no que tange a quantidade de combinações lógicas disponíveis em
um único chip – quando comparados a circuitos integrados de lógica padrão – e a
velocidade de resposta – quando comparados a sistemas microprocessados. Os
PLDs, dependendo da família lógica utilizada, podem disponibilizar centenas de
milhares de combinações lógicas reprogramáveis, além de interpretar e manipular
18
sinais digitais em velocidades extremamente rápidas (TOCCI; WIDMER; MOSS,
2011).
Os primeiros PLDs foram introduzidos em meados dos anos 1970 e empregam
apenas portas lógicas convencionais, o que possibilita somente a implementação de
circuitos combinacionais. Pela simplicidade desses dispositivos e limitação quanto a
aplicabilidade, atualmente são conhecidos como PLDs simples – SPLDs (Simple
Programmable Logic Devices).
A primeira classe de SPLDs desenvolvida foi chamada de Lógica de Arranjo
Programável (Programmable Array Logic - PAL). Uma PAL implementa o circuito
digital correspondente a uma soma de produtos, onde, as entradas digitais da mesma
são conectadas a portas lógicas AND, através de um arranjo configurável, fusíveis
são utilizados para selecionar as conexões desejadas. As portas AND são conectadas
a portas OR, seguindo um arranjo fixo. E estas, por sua vez, conectadas as saídas. A
arquitetura básica de uma PAL é ilustrada na Figura 1.
Figura 1 – Arquitetura PAL
Fonte: Pedroni (2010)
19
Outra classe de SPLDs, denominada PLA (Programmable Logic Array),
apresenta uma arquitetura de hardware configurável parecida ao de uma PAL, porém,
esta disponibiliza um arranjo configurável também para as entradas das portas OR,
como pode ser percebido na figura 2.
Figura 2 – Arquitetura PLA
Fonte: Pedroni (2010)
O Dispositivo de Arranjo de Lógica Genérica, ou simplesmente GAL (Generic
Array Logic), é um SPLD que apresenta a mesma arquitetura inicial quando
comparado a PAL, ou seja, um arranjo configurável de portas AND, seguido por um
arranjo fixo de portas OR. Todavia, na GAL o arranjo configurável não é realizado por
fusíveis, mas sim, por meio da memória EEPROM. Sua principal particularidade
encontra-se na saída do circuito lógico, pois o mesmo possui uma macro célula. A
macro célula, ilustrada na figura 3, contém uma porta XOR configurável, seguida por
um flip-flop do tipo D. Um multiplexador seleciona se o sinal de saída da GAL é
resultado do flip-flop (sinal registrado ou sequencial) ou da porta XOR (sinal
combinacional). Um segundo multiplexador permite que um sinal de retorno seja
obtido, o mesmo seleciona se o sinal é proveniente do flip-flop, de uma macro célula
adjacente, ou de sua saída. Ainda, existem mais três multiplexadores, um deles
seleciona se a saída da porta AND anterior deve, ou não, ser ligada a porta OR, outro
20
seleciona qual sinal controla o buffer de saída e, por fim, um último escolhe se o sinal
de saída deve ser enviado à macro célula adjacente (PEDRONI, 2010).
Figura 3 – Diagrama da macro célula
Fonte: Pedroni (2010)
Os SPLDs, por possuírem um hardware limitado a poucas combinações lógicas
básicas, foram substituídos pelos CPLDs (Complex Programmable Logic Devices). Os
CPLDs, além de disponibilizarem um grande número de I/Os, possuem a
característica de serem reconfiguráveis, pois, seus arranjos são concebidos via
memória EEPROM ou memória flash. No CPLD, uma interface JTAG é disponibilizada
ao usuário para configuração das combinações lógicas que, devido à memória não
volátil, permanecem salvas no dispositivo mesmo após sua desenergização.
Basicamente, um CPLD consiste em vários PLDs (geralmente GALs) encapsulados
em um único chip. Estes PLDs se comunicam por meio de um arranjo complexo e
programável, denominado Barramento de Interconexão, conforme ilustra a figura 4.
21
Figura 4 – Arquitetura básica de CPLDs
Fonte: Pedroni (2010)
Ademais, no que tange as diferentes estruturas dos dispositivos lógicos
programáveis, apresentam-se os FPGAs (Field Programmable Gate Array).
Diferentemente dos CPLDs que possuem sua estrutura física baseada em colunas de
blocos lógicos, os FPGAs dispõem de blocos lógicos arranjados de forma matricial.
Conforme visto na figura 5, FPGA é composto por três elementos básicos,
denominados: Blocos de I/O, Bloco Lógico Configurável (CLB) e Interconexões
Programáveis. Um CLB é constituído por vários módulos lógicos (Figura 6 – a),
equivalentes às macro células de um CPLD, que são conectados entre si por meio de
uma interconexão programável local. Os módulos lógicos são baseados em LUT 2, e
podem executar lógica combinacional, registrada (flip-flop) ou ambas (Figura 6 – b).
Outra característica exclusiva dos FPGAs é a possibilidade de alocar parte das
lógicas disponíveis no hardware para funções especificas, definidas pelos fabricantes,
como interfaces padrão de IOs, processadores de sinal, circuitos PLL (Phase Locked
Loop), memórias RAM, etc.
2 LUT (look up table – tabela de busca) é uma memória programável que gera lógica combinacional na forma de soma de produtos. Existe uma célula de memória para armazenamento do resultado para toda e qualquer combinação lógica das entradas de uma LUT. Uma LUT assemelha-se a função de uma PAL ou PLA (FLOYD, 2007).
PLD 1
PLD 2
PLD 3
PLD nBa
rra
me
nto
de
In
terc
on
exã
o
Dri
ve
rs d
e I
/O
22
Figura 5 – Estrutura básica de um FPGA
Fonte: Floyd (2007)
Figura 6 – Blocos Lógicos Configuráveis – CLB (a) e Módulo Lógico (b)
Fonte: Floyd (2007)
CLB
Bloco
de I/O
Bloco
de I/O
Bloco
de I/O
Bloco
de I/O
Bloco
de I/O
Bloco
de I/O
CLB
CLB CLB
CLB
CLB
Bloco
de I/O
Bloco
de I/O
Bloco
de I/O
Bloco
de I/O
Bloco
de I/O
Bloco
de I/O
Interconexões
programáveis
Módulo Lógico
Módulo Lógico
Módulo Lógico
Módulo Lógico
CLB
LUTLógica
associadaI/O
Módulo Lógico
(a)
(b)
Interconexão
programável local
23
Além disso, os fabricantes de FPGA disponibilizam diversos projetos de lógica
padrão, denominados de projetos de IP (Intellectual Property). Esses projetos são de
propriedade intelectual do fabricante e, portanto, seu código não é acessível ao
usuário. Os projetos IP têm como finalidade executar lógicas digitais complexas e
podem ser inseridos em aplicações específicas, conforme necessidade. Um exemplo
de projeto de propriedade intelectual é o processador embutido em algumas famílias
de FPGAs do fabricante Intel, denominado Nios II.
As tecnologias de memória empregadas em FPGA incluem SRAM (mais
utilizada – exige reconfiguração de hardware na energização do mesmo) e flash. Para
FPGAs baseados em SRAM, as informações de programação que definem como cada
bloco lógico funciona, quais blocos de IO são entradas e quais são saídas e, também,
como são interconectados, estão armazenadas em uma memória externa, transferida
por download para o FPGA quando o dispositivo é energizado (FLOYD, 2007).
2.2 Família de FPGAs MAX 10 da Intel
A família de FPGAs MAX 10, introduzida no mercado em 2014 pelo fabricante
INTEL, disponibiliza aos usuários vários recursos de hardware, sua estrutura típica é
apresentada na figura 7. Conforme visto na figura, seu arranjo consiste na alocação
de (INTEL, 2017c):
I. Logic Array Blocks (LABs): Nos FPGAs da Intel, os blocos lógicos configuráveis
(CLBs) – apresentados na figura 6 – recebem o nome de Logic Array Blocks – LABs.
Já os módulos lógicos, por sua vez, são chamados de Logic Element – LE3;
II. Embedder Memory Blocks: A família MAX 10 disponibiliza 9216 bits de
memória embarcada. Os bits de memória podem ser agrupados em diferentes blocos,
para que desempenhem as funções de RAM, ROM, registradores de deslocamento e
FIFO, conforme necessidade da aplicação;
3 Algumas famílias de FPGAs da Intel, como a STRATIX, denominam os módulos lógicos como Adaptive Logic Modules (ALMs). Um ALM, apesar de implementar a mesma função de um LE, dispõe de uma tecnologia de circuito digital diferente do mesmo.
24
III. Embedded Multiplier Blocks: O bloco multiplicador incorporado no MAX 10 pode
operar em dois modos distintos: apenas um multiplicador (18 bits X 18 bits) ou dois
multiplicadores independentes (9 bits X 9 bits cada);
IV. Clocks e Phase Locked Loops (PLL): A rede de clock global (GCLK) percorre
todos os quadrantes do MAX 10. Todos os recursos de hardware presentes no FPGA
podem utilizar o GCLK como fonte de clock. O MAX 10 também disponibiliza 4
circuitos PLLs que podem sincronizar a fase e a frequência de um oscilador controlado
por tensão (VCO) a um clock de referência de entrada;
V. I/O Banks: No MAX 10, os pinos de I/Os estão agrupados em blocos e dispostos
nas extremidades do dispositivo;
VI. Analog to Digital Converter (ADC): O FPGA MAX 10 possui até 2 canais de
entrada ADC (8 pinos por canal) que podem ler valores analógicos ligados
externamente ao dispositivo, ou ainda, averiguar a temperatura lida por um sensor
presente no próprio dispositivo (o sensor de temperatura está disponível somente no
canal 1 – ADC1). A resolução dos valores analógicos convertidos para digitais é de
12 bits;
VII. User Flash Memory (UFM): O MAX 10 dispõe de um bloco de memória flash do
usuário que armazena informações não voláteis;
VIII. Configuration Flash Memory (CFM): A memória flash de configuração interna
armazena o arquivo a ser implementado no FPGA de forma não volátil.
2.2.1 Configuração do dispositivo pela interface JTAG
Conforme ilustra a figura 8, nos dispositivos MAX 10, as instruções JTAG têm
precedência sobre o esquema de configuração interna. Usando o esquema de
configuração do JTAG, pode-se configurar diretamente o dispositivo CRAM através
da interface JTAG (pinos: TDI, TDO, TMS e TCK). O software Intel Quartus Prime gera
automaticamente um arquivo .sof (SRAM Object File) que é enviado ao FPGA através
do sistema JTAG Configuration (INTEL, 2017c).
25
Figura 7 – Estrutura típica da família MAX 10
Fonte: Intel (2017c)
Todavia, o dispositivo CRAM é volátil e sua informação se perde quando o
FPGA é desenergizado. Dessa forma, para que não se perca a configuração lógica
implementada pelo FPGA é necessário armazenar o arquivo da configuração lógica
na memória flash de configuração (CFM). Os dados de configuração gravados no
CFM fazem parte do arquivo .pof (Programmer Object File). Através da programação
no sistema JTAG ISP (In System Programming) é possível programar o .pof no flash
interno. Durante a configuração interna, os dispositivos MAX 10 carregam o CRAM
com dados de configuração do CFM.
26
Figura 8 – Dados de configuração
Fonte: Intel (2017c)
2.2.2 Blocos lógicos configuráveis no MAX 10
Nas famílias de FPGAs da Intel, os blocos lógicos configuráveis recebem o
nome de LAB e apresentam distintos recursos lógicos. No MAX 10, especificamente,
cada LAB é composto por 16 módulos lógicos, denominados LEs. Como pode ser
observado na figura 9, as conexões entre os circuitos lógicos podem ser estabelecidas
através de uma interconexão de link direto entre LABs adjacentes, utilizando a
interconexão local, ou por meio de interconexões programáveis de linha e coluna. A
interconexão de link direto permite que elementos vizinhos (à esquerda ou à direita)
estabeleçam conexão sem a necessidade de acesso às interconexões de linha e
coluna, o que melhora o desempenho e aumenta a flexibilidade do FPGA (INTEL,
2017b).
27
Figura 9 – Estrutura LAB no MAX 10
Fonte: Intel (2017b)
O LE é a menor unidade lógica presente no MAX 10. O mesmo é composto por
entradas, saídas e registradores, e pode desempenhar diferentes configurações
lógicas. Pode operar em modo normal – aplicações lógicas no geral e funções
combinacionais – ou aritmético – circuito somador, contador, acumulador ou
comparador. Seu registrador interno pode assumir a função de flip-flop do tipo D, T,
JK ou RS, conforme necessidade. Um LE tem a capacidade de estabelecer conexões
locais (conexão entre LEs dentro de um mesmo LAB), de linha, de coluna ou de link
direto. A figura 10 ilustra o diagrama de blocos da estrutura física de um LE.
28
Figura 10 – Estrutura LE no MAX 10
Fonte: Intel (2017b)
2.2.3 Kit didático DE10-LITE
O fabricante Terasic desenvolve kits didáticos para o uso de FPGA da INTEL.
Os kits, denominados por DEs (Development and Education), dispõem de periféricos
conectados ao FPGA e possibilitam a criação de lógicas para testes e
desenvolvimento de protótipos. Dentre esses kits, encontra-se o DE10-LITE.
O kit de desenvolvimento DE10-LITE, apresentado na figura 11, é composto
por um FPGA MAX 10 – Intel, interface USB Blaster, memória SDRAM de 64 MB, 2 x
20 GPIO, conectores para shields do Arduino Uno R3, conector VGA, 10 leds, 10 slide
switches, 2 push buttons, 6 displays de 7 segmentos com anodo comum, alimentação
externa de 5 VDC e 4 sinais de clock, sendo eles: dois sinais de 50 MHz usados como
29
fonte de clock para a lógica do usuário, um sinal de 24 MHz usado como referência
para a USB Blaster, e um sinal de 10 MHz conectado aos PLLs 1 e 3 do FPGA MAX
10 (as saídas dos mesmos são utilizadas como referência de clock do conversor ADC)
(TERASIC, 2018).
Figura 11 – DE10-Lite
Fonte: Terasic (2018)
O modelo de FPGA utilizado no kit de desenvolvimento DE10-Lite é o
10M50DAF484C7G que possui as características apresentadas na figura 12.
30
Figura 12 – Modelo FPGA
10M 50 DA F 484 C 7 G
Optional Suffix:
G - RoHS6
FPGA Fabric Speed Grade:
7 – Intermediária
Operation Temperature:
C - Comercial (0 a 85ºC)
Package Code:
484 - 484 pinos, 23 mm x 23 mm
Package Type:
F - Fineline BGA (FBGA)
Feature Options:
DA - Fonte dupla, recursos de
memória flash e sinais analógicos
Member Code:
50 - 50k de elementos lógicos
Family:
10M - INTEL MAX 10
Fonte: O Autor (2018)
2.3 Processo de Desenvolvimento do Projeto em FPGA
As conexões de hardware a serem implementadas em um dispositivo lógico
programável são definidas via software. Os fabricantes de PLDs disponibilizam a seus
usuários os softwares responsáveis pela configuração de seus dispositivos. A Intel,
por exemplo, dispõe do software Quartus Prime em versões pagas (pro e standard) e
gratuita (lite). O fluxo de um projeto executado no software Quartus Prime segue os
passos em uma sequência típica, apresentada na figura 13 (INTEL, 2016a):
1 – Especificação do Projeto: O projeto inicia com a especificação do circuito
desejado. O hardware pode ser especificado através de diagramas esquemáticos
(diagramas de blocos) ou por meio das linguagens de descrição de hardware VHDL e
Verilog (alto nível de abstração);
2 – Síntese: As ferramentas EDA (Electronic Design Automation) de análise
são responsáveis por executar uma elaboração e síntese do projeto. O arquivo
31
especificado em VHDL possui alto grau de abstração e nem sempre pode ser
diretamente sintetizado. Dessa forma, a etapa de elaboração (Analysis and
Elaboration) consiste em um processo interativo de simulações até que se encontre
uma descrição VHDL, equivalente ao arquivo especificado, que permita ser
sintetizada. Uma vez definida a descrição do arquivo VHDL, o projeto é sintetizado
(Analysis and Synthesis). A ferramenta de síntese, após analisar possíveis erros na
descrição do projeto, sintetiza o mesmo em duas etapas. A primeira etapa de
sintetização cria uma estrutura de componentes lógicos (portas lógicas, registradores,
etc) e suas interligações. Ao final dessa etapa, tem-se o projeto em nível RTL (Register
Transfer Level). A partir da estrutura RTL, dá-se início a segunda etapa de
sintetização, denominada por nível de portas (gate level), na qual o projeto passa a
conter a estrutura do hardware utilizado (LEs, blocos de memória, circuitos PLLs e
blocos de I/O). Na segunda etapa, é gerada uma lista (EDA Netlist Writer) que contém
os blocos a serem utilizados e as conexões necessárias entre os mesmos;
3 – Simulação Funcional: O circuito sintetizado é testado para verificar sua
correção funcional. Caso haja inconsistência no projeto, o mesmo retorna mensagens
de erro;
4 – Posicionamento e Interligação: Determina o posicionamento dos blocos
contidos na netlist e o melhor caminho para suas interconexões, considerando o
posicionamento dos pinos (pin planner) de I/O definidos pelo usuário;
5 - Análise de Tempo e Simulação: Os atrasos de propagação ao longo dos
vários caminhos no circuito montado são analisados para fornecer uma indicação do
desempenho esperado, além disso, o circuito montado é simulado para verificar tanto
a correção quanto o tempo de funcionamento. Caso haja inconsistência no projeto, o
mesmo retorna mensagens de erro;
6 – Programação e Configuração: O circuito projetado é implementado no
dispositivo através da interface JTAG.
32
Figura 13 – Fluxo do projeto na ferramenta de software
Fonte: Intel (2016a)
O software Intel Quartus Prime inclui uma ferramenta denominada TimeQuest
Timing Analyzer que executa uma análise detalhada de todos os atrasos de
temporização em um circuito que é compilado para implementação em FPGA. Os
problemas de temporização são mais significativos em circuitos que apresentam
caminhos longos, compostos por elementos lógicos combinacionais e registradores
em suas entradas e saídas, sendo o caminho que apresenta maior atraso denominado
por caminho crítico. A ferramenta permite localizar o caminho mais crítico e criar
algumas restrições de temporização ao mesmo. Além disso, a ferramenta disponibiliza
simulação de temporização e fornece uma indicação gráfica dos atrasos no circuito
implementado (INTEL, 2016b).
Design Entry
Design
Correct?
Synthesis
Functional Simulation
Fitting
Timing Analysis and Simulation
Timing
requirements
met?
Programming and Configuration
Yes
No
Yes
No
33
2.4 A linguagem de descrição de hardware VHDL
A linguagem VHDL surgiu no início dos anos de 1980 e foi planejada,
inicialmente, como uma ferramenta de documentação para o projeto de VHSIC (Very
High Speed Integrated Circuit) do Departamento de Defesa dos Estados Unidos da
América. O objetivo era desenvolver uma ferramenta que conseguisse substituir os
complexos manuais dos circuitos integrados. Para tanto, o governo estadunidense
contou com a parceria das companhias IBM, Texas e Intermetrics. Posteriormente,
devido a necessidade de facilitar a descrição de circuitos mediante linguagem textual,
a linguagem VHDL passou a incorporar, além da função de documentação, as funções
de descrição, síntese e simulação. A linguagem foi posta em domínio público e
padronizada pela IEEE em 1987, dando origem ao padrão IEEE 1076 (D’AMORE,
2012).
Um código desenvolvido em VHDL é composto por três partes: Biblioteca,
Entidade e Arquitetura (Library, Entity e Architecture).
No emprego de bibliotecas em VHDL, a cláusula LIBRARY identifica as
bibliotecas que podem ser referenciadas e a cláusula USE aponta partes das
bibliotecas que são necessárias à especificação do projeto. A biblioteca IEEE, por
exemplo, é muito empregada em projetos descritos em VHDL e seus pacotes mais
usuais são: std_logic_1164, std_logic_unsigned, std_logic_signed e std_logic_arith.
Algumas bibliotecas podem ser referenciadas por qualquer unidade de projeto sem a
inclusão da cláusula LIBRARY, como é o caso da biblioteca WORK - diretório criado
pelas ferramentas de compilação e simulação para armazenamento do resultado da
unidade de projeto (D’AMORE, 2012).
A entidade de um projeto é composta pela declaração – interface entre a
entidade e o ambiente externo – e arquitetura - especificação das relações entre
entradas e saídas da entidade. A declaração inicia com a palavra reservada ENTITY
e pode conter as cláusulas PORT (define o modo e tipo das entradas e saídas) e
GENERIC (entrada de informações estáticas para a unidade de projeto, internamente
tratada como uma constante). Existem quatro modos possíveis para uma porta: IN
(exclusivamente entrada), OUT (exclusivamente saída), BUFFER (saída que pode ser
34
referenciada internamente no código) e INOUT (bidirecional). O corpo da arquitetura
inicia com a palavra reservada ARCHITECTURE e as linhas de código que
especificam o projeto devem ser inseridas entre as palavras reservadas BEGIN e
END. Em VHDL, os comandos de código são executados de forma concorrente, ou
seja, a sequência com que os comandos são apresentados é irrelevante, pois estes
são executados simultaneamente. Porém, regiões de código sequencial podem ser
criadas pelo usuário, através da criação de processos e subprogramas.
Um exemplo de código desenvolvido em VHDL é apresentado no quadro 1.
Conforme visto no quadro, as entradas i1, i2 e as saídas o1, o2 são definidas do tipo
STD_LOGIC, conforme especificação do pacote std_logic_1164, da biblioteca IEEE.
A arquitetura logic, pertencente a entidade exemple, define a relação entre as saídas
e as entradas do projeto. A saída o1 é o resultado da combinação lógica OR entre as
entradas i1 e i2 (linha 11). A saída o2 é o resultado da combinação lógica AND entre
as entradas i1 e i2 (linha 12).
Quadro 1 – Exemplo de código em VHDL
1 LIBRARY ieee;
2 USE ieee.std_logic_1164.all;
3
4 ENTITY exemple IS
5 PORT ( i1, i2: IN STD_LOGIC;
6 o1, o2: OUT STD_LOGIC);
7 END exemple;
8
9 ARCHITECTURE logic OF exemple IS
10 BEGIN
11 o1 <= i1 OR i2;
12 o2 <= i1 AND i2;
13 END ARCHITECTURE;
Fonte: O Autor (2018)
Todo elemento presente no código que contém algum valor armazenado é
denominado objeto. Em VHDL, são definidas quatro classes de objetos, são elas:
35
CONSTANT (objeto com valor estático), VARIABLE (objeto no qual seu valor pode ser
alterado ao decorrer do código, utilizado em regiões de código sequencial), SIGNAL
(objeto no qual seu valor pode ser alterado ao decorrer do código, utilizado em regiões
de código sequencial e concorrente) e FILE (objeto que pode ser criado pelo usuário
para representação de um arquivo).
Os objetos, pertencentes as classes CONSTANT, VARIABLE e SIGNAL,
precisam ser declarados segundo um tipo predefinido. O tipo estabelece os valores
que o objeto pode assumir e as operações que podem ser realizadas pelos mesmos.
A transferência de valores entre objetos declarados com tipos diferentes não é
permitida. Para que isso aconteça, é necessária uma operação de conversão.
A tabela 1 apresenta os tipos predefinidos no pacote padrão VHDL,
relacionando os mesmos aos valores que podem assumir. Os tipos escalares são
ordenados e apresentam um valor único. Para o tipo INTEGER, o pacote padrão
define os subtipos NATURAL e POSITIVE. Os tipos REAL e TIME não são suportados
pelas ferramentas de síntese, são utilizados somente em simulações. Os tipos
compostos contêm um ARRAY de bits e caracteres para os tipos BIT_VECTOR e
STRING, respectivamente.
Tabela 1 – Tipos predefinidos no pacote padrão VHDL
Tipo predefinido Valor Exemplos
escalares
BIT um, zero 1, 0
BOOLEAN verdadeiro, falso TRUE, FALSE
CHARACTER caracteres ASCII A, b, c A, B, C, ?, (
INTEGER −231 − 1 ≤ 𝑥 ≤ 231 − 1 123, 16#7B#, 2#11_11_011#
subtipos
INTEGER
NATURAL 0 ≤ 𝑥 ≤ 231 − 1 123, 16#7B#, 2#11_11_011#
POSITIVE 1 ≤ 𝑥 ≤ 231 − 1 123, 16#7B#, 2#11_11_011#
REAL −3.65𝑥1047 ≤ 𝑥 ≤ +3.65𝑥1047 1.23, 1.23E+2, 16#7.B#E+1
TIME ps, ns, us, ms, sec, min, hr 1 us, 100 ps, 1 fs
compostos BIT_VECTOR 1, 0 “1010”, B”10_10”
STRING tipo character “texto”
Fonte: D’AMORE (2012)
36
Como salientado anteriormente, os códigos de comando, presentes na
arquitetura de um projeto VHDL, são executados concorrentemente. Ou seja, a
alteração do valor contido em um sinal leva à execução de todos os comandos
sensíveis ao mesmo, da mesma forma que, em um circuito, a mudança de um valor
em um determinado nó afeta todas as entradas ligadas a ele. Os comandos de
construção utilizados em regiões de código concorrente são WHEN ELSE e WITH
SELECT, que tem seus formatos apresentados nos quadros 2 e 3, respectivamente.
A construção WHEN ELSE consiste na transferência condicional de um sinal.
A ordem de definição das condições indica a precedência de execução, ou seja, a
primeira condição tem prioridade máxima, já a última tem prioridade mínima
(D’AMORE, 2012). Conforme demonstra o quadro 2, caso a condição 1 retorne um
valor verdadeiro, o valor contido na “expressao_a” é transferido ao sinal de destino.
Se a condição 1 retornar um valor falso, a condição 2 é testada, e assim,
sucessivamente. Caso nenhuma condição seja verdadeira, a última expressão é
transferida ao sinal de destino.
Quadro 2 – Construção WHEN ELSE
1 sinal_destino <= expressao_a WHEN condicao_1 ELSE --condicao1 = verdadeira
2 expressao_b WHEN condicao_2 ELSE --condicao2 = verdadeira
3 expressao_c; --nenhuma condicao verdadeira
Fonte: D’AMORE (2012)
A construção WITH SELECT estabelece a comparação entre uma expressão
de escolha e suas possíveis condições. Todas as condições precisam ser
consideradas na construção. A prioridade de execução é a mesma para toda e
qualquer condição (D’AMORE, 2012). O quadro 3 aponta que, caso a expressão de
escolha contenha um valor igual aquele apresentado na condição 1, o valor contido
na “expressao_a” é transferido ao sinal de destino. Isso ocorre para todas as linhas
de comparação.
37
Quadro 3 – Construção WITH SELECT
1 WITH expressao_escolha SELECT -- expressao_escolha =
2 sinal_destino <= expressao_a WHEN condicao_1, -- condicao_1
3 expressao_b WHEN condicao_2, -- condicao_2
4 expressao_c WHEN condicao_3 | condicao_4, -- condicao_3 ou condicao_4
5 expressao_d WHEN condicao_5 TO condicao_7, -- condicao_5 ate condicao_7
6 expressao_e WHEN OTHERS; -- condicoes restantes
Fonte: D’AMORE (2012)
Embora a linguagem VHDL seja predominantemente concorrente, é possível
criar regiões de código sequencial na mesma. Para tanto, emprega-se o bloco
PROCESS. Um processo é um comando executado concorrentemente às demais
especificações do projeto, que delimita uma região no código, a qual contém
comandos executados sequencialmente, semelhante às linguagens de programação.
O comando PROCESS dispõe de uma lista de sensibilidade composta por sinais
presentes no projeto. O código contido em um processo é executado toda vez que
houver a alteração do valor dos sinais existentes na lista de sensibilidade do mesmo.
Os comandos de construção utilizados em regiões de código sequencial são CASE
WHEN e IF ELSE, que tem seus formatos apresentados nos quadros 4 e 5,
respectivamente.
A construção CASE WHEN estabelece a comparação entre uma expressão de
escolha e suas possíveis condições. Todas as condições precisam ser consideradas
na construção. A prioridade de execução é a mesma para toda e qualquer condição.
Uma construção CASE WHEN permite que comandos diferentes possam ser criados
para cada condição verdadeira, estabelecendo diferentes sinais de destino. Inclusive,
para cada condição, é possível executar mais de um comando, como é o caso
apresentado na linha 6 do quadro 4 (D’AMORE, 2012).
Quadro 4 – Construção CASE WHEN
1 CASE expressao_escolha IS -- expressao_escolha =
2 WHEN condicao_1 => comando_a; -- condicao_1
3 WHEN condicao_2 => comando_b; comando_c; -- condicao_2
4 WHEN condicao_3 | condicao_4 => comando_d; -- condicao_3 ou condicao_4
5 WHEN condicao_5 TO condicao_9 => comando_d; -- condicao_5 ate condicao_9
6 WHEN OTHERS => comando_e; comando_f; -- condicoes restantes
7 END CASE;
Fonte: D’AMORE (2012)
38
A construção IF ELSE permite que comandos sequenciais sejam executados
seguindo uma ordem de condições. A primeira condição verdadeira encontrada é
executada (D’AMORE, 2012). As linhas 1 a 11, do quadro 5, apresentam uma
construção IF seguida por cláusulas ELSIF. Já as linhas 14 a 26, criam uma
construção composta por vários comandos IFs aninhados.
Quadro 5 – Construção IF ELSE
1 IF condicao_1 THEN 14 IF condicao_1 THEN
2 comando_sequencial; 15 IF condicao_2 THEN
3 comando_sequencial; 16 comando_sequencial;
4 ELSIF condicao_2 THEN -- clausula ELSIF opcional 17 ELSE
5 comando_sequencial; 18 comando_sequencial;
6 comando_sequencial; 19 END IF;
7 ELSIF condicao_3 THEN 20 ELSE
8 comando_sequencial; 21 IF condicao_2 THEN
9 ELSE -- clausula ELSE opcional 22 comando_sequencial;
10 comando_sequencial; 23 ELSE
11 END IF; 24 comando_sequencial;
12 25 END IF;
13 26 END IF;
Fonte: D’AMORE (2012)
A linguagem VHDL permite a interligação entre diferentes entidades de projeto
através da criação de componentes. Um componente é uma entidade de projeto
empregada na arquitetura de outra entidade. Com a utilização de componentes é
possível formar uma entidade mais complexa em um projeto hierárquico (D’AMORE,
2012). O quadro 6 apresenta a descrição VHDL de um circuito somador completo. No
presente código, os sinais a, b e cin (carry in) são somados e o resultado da equação
é depositado nas saídas c e cout (carry out).
Quadro 6 – Código VHDL para Somador Completo
1 LIBRARY ieee;
2 USE ieee.std_logic_1164.all;
3
4 ENTITY full_adder IS
5 PORT (a, b, cin: IN STD_LOGIC;
39
6 c, cout: OUT STD_LOGIC);
7 END full_adder;
8
9 ARCHITECTURE adder OF full_adder IS
10 BEGIN
11 c <= a XOR b XOR cin;
12 cout <= (a AND b) OR (a AND cin) OR (b AND cin);
13 END ARCHITECTURE;
Fonte: O Autor (2018)
O quadro 7 descreve um código VHDL que executa a soma de dois sinais de
entrada (x e y), ambos possuem a magnitude de 4 bits (nibble) e aloca o resultado da
operação na saída z, que possui a magnitude de 5 bits. Para tanto, faz uso do
componente full_adder, apresentado no quadro 6. Para que isso seja possível, é
necessário que a entidade full_adder esteja descrita no projeto, neste caso, a entidade
adder_nibble é hierarquicamente superior a full_adder. Como pode ser percebido no
quadro 7, o componente é declarado entre as linhas 11 e 14, seguindo a estrutura de
portas apresentada em sua entidade. O componente full_adder é solicitado quatro
vezes (linhas 19 a 22). Cada solicitação recebe um rótulo e executa a soma de três
sinais. Neste exemplo, os rótulos são: bit0 (soma os bits 0 das entradas x e y), bit1
(soma os bits 1 das entradas x e y e o carry out da soma anterior), bit2 (soma os bits
2 das entradas x e y e o carry out da soma anterior) e bit3 (soma os bits 3 das entradas
x e y e o carry out da soma anterior). Dessa forma, são executadas quatro somas,
uma para cada bit dos sinais de entrada.
Quadro 7 – Utilização de Componentes em VHDL – Somador de 4 bits
1 LIBRARY ieee;
2 USE ieee.std_logic_1164.all;
3
4 ENTITY adder_nibble IS
5 PORT (x, y: IN STD_LOGIC_VECTOR (3 DOWNTO 0);
6 z: OUT STD_LOGIC_VECTOR (4 DOWNTO 0));
7 END adder_nibble;
8
9 ARCHITECTURE adder_nibble OF adder_nibble IS
10
11 COMPONENT full_adder
40
12 PORT (a, b, cin: IN STD_LOGIC;
13 c, cout: OUT STD_LOGIC);
14 END COMPONENT;
15
16 SIGNAL carry: STD_LOGIC_VECTOR (3 DOWNTO 1);
17
18 BEGIN
19 bit0: full_adder PORT MAP ( a => x(0), b => y(0), cin => '0', c => z(0), cout => carry(1));
20 bit1: full_adder PORT MAP ( a => x(1), b => y(1), cin => carry(1), c => z(1), cout => carry(2));
21 bit2: full_adder PORT MAP ( a => x(2), b => y(2), cin => carry(2), c => z(2), cout => carry(3));
22 bit3: full_adder PORT MAP ( a => x(3), b => y(3), cin => carry(3), c => z(3), cout => z(4));
23 END ARCHITECTURE;
Fonte: O Autor (2018)
Em VHDL, FUNÇÃO é um subprograma que pode ser empregado em códigos
que apresentem comandos frequentemente utilizados. Dessa forma, os comandos
são isolados em uma função, melhorando o entendimento da descrição. Todos os
objetos presentes em uma função são descartados após sua execução, o valor
presente nos mesmos não é mantido (D’AMORE, 2012). Um exemplo no uso de
funções é apresentado no quadro 8. Como pode-se observar entre as linhas 8 e 13
da tabela, a função precisa ser descrita na região de declarações da arquitetura em
que a mesma está sendo invocada. A invocação da função é feita no corpo da
arquitetura, sempre que necessário (linha 16).
Quadro 8 – FUNÇÃO em VHDL
1 ENTITY adder IS
2 PORT (a, b: IN INTEGER RANGE 0 TO 15;
3 c: OUT INTEGER RANGE 0 TO 15);
4 END adder;
5
6 ARCHITECTURE adder OF adder IS
7
8 FUNCTION sum (a: INTEGER; b: INTEGER) RETURN INTEGER IS
9 VARIABLE c: INTEGER;
10 BEGIN
11 c:= a + b;
12 RETURN c;
13 END sum;
14
15 BEGIN
16 c <= sum (a, b);
17 END ARCHITECTURE;
Fonte: D’AMORE (2012)
41
2.5 Estudos realizados na área: FPGA como controlador de eixos
O setor metalmecânico, impulsionado pelo avanço tecnológico, sofre,
gradativamente, significativo desenvolvimento e, por consequência, apresenta novas
soluções para as atividades produtivas. No campo da usinagem, fabricantes de
máquinas e de sistemas de comando numérico aplicam grande investimento para o
desenvolvimento de novas tecnologias.
Dentre as tecnologias existentes para o campo da usinagem, o CNC do
fabricante Fanuc está presente em grande número nas atividades industriais.
Segundo informações do fabricante, a Fanuc é líder mundial em vendas e
aplicabilidades no setor. As soluções comercializadas pelo fabricante são
consideradas por muitos profissionais da área as que apresentam maior tecnologia
embarcada. Os sistemas de comando numérico computadorizado mais completos
disponibilizam, por exemplo, uma IHM (Interface Humano Máquina) touch screen e
um teclado alfanumérico para interação com o usuário. Através destes é possível
definir uma sequência de plano de corte, comandar partidas e paradas rápidas,
visualizar a sequência de operação e deslocamento dos eixos ao decorrer do
processo de usinagem. Os sistemas oferecem ainda acesso a diferentes alarmes que
podem surgir de operações indevidas ou problemas elétricos e desgastes e quebras
mecânicas. Há também algoritmos para gerenciamento de manutenção, que
apresentam ao usuário a vida útil dos equipamentos e informam a necessidade da
troca de peças e ferramentas. Estes sistemas podem ser acessados remotamente
através de redes industriais (FANUC, 2017). Além deste, outros grandes fabricantes
estão presentes no setor da usinagem e concorrem com tecnologias semelhantes.
Contudo, outras soluções, não tão robustas, também estão presentes em meios
industriais. Porém, por apresentarem um custo mais acessível e maior praticidade no
manuseio, comumente são mais utilizadas em meios acadêmicos. Dentre elas, se
destaca o software Mach3.
O Mach3 é um dos primeiros e mais populares programas de software CNC,
muito difundido e utilizado em ambientes industriais e acadêmicos, empregado no
acionamento de dispositivos que exijam controle de velocidade e posição.
42
Desenvolvido pela companhia Artsoft, o Mach3 pode ser instalado em computadores
pessoais e controlar o acionamento de motores de passo e/ou servomotores, através
das portas paralela ou USB.
Um hardware é necessário para o interfaceamento do computador com os
motores. Este hardware é configurado para receber os comandos digitais oriundos do
computador e acionar as bobinas dos motores. Além disso, o mesmo funciona como
driver de corrente, dimensionado para atender as necessidades de potência de uma
aplicação específica.
O software Mach3 interpreta os comandos procedentes de um código G, e
controla a velocidade e/ou posição dos motores conforme as especificações
interpretadas. Na interface de interação com o usuário, é possível comandar os eixos
de forma manual e automática, executar comandos passo a passo, visualizar a
posição real dos eixos controlados, programar o acionamento de relés auxiliares (ex:
acionar líquido refrigerante), entre outros (ARTSOFT, 2008).
Servomotores e motores de passo, comumente, são utilizados para o
acionamento de sistemas de múltiplos eixos. O controle de posicionamento,
velocidade e corrente desses motores de precisão é realizado por um dispositivo
eletrônico, denominado drive. Os fabricantes de drives para motores de precisão
desenvolvem em FPGAs o algoritmo de controle de seus produtos. A Beckhoff, por
exemplo, utiliza FPGA no controle das malhas de corrente e posição nos drives da
linha AX8000, para acionamento de motores de passo e servomotores (BECKHOFF,
2018). Da mesma forma, a SEW baseia o controle da linha MOVIAXIS na utilização
de FPGA (SEW, 2011). A fabricante brasileira WEG, também utiliza FPGA no controle
do servoconversor SCA06 (WEG, 2015).
Além das soluções comerciais amplamente difundidas para o campo da
usinagem, o meio acadêmico desenvolve pesquisas na área de tecnologias com o
intuito de atender as necessidades deste campo e potencializar a aplicabilidade de
soluções alternativas. No que se refere a aplicação do dispositivo lógico programável
FPGA, objeto de estudo proposto nessa dissertação de mestrado, verifica-se que
pesquisas já foram desenvolvidas nesse campo e, com elas, resultados interessantes
43
já foram alcançados. Em seguida, algumas dessas pesquisas são exibidas e
contribuem na fundamentação do trabalho por ora apresentado.
Carrica, Funes e González (2003) desenvolveram o controle de um motor de
passo, implementado em FPGA. A solução apresentada é dividida em três blocos de
função: gerador de perfil de velocidade, indexador, e driver de potência. Os dois
primeiros blocos estão embutidos em um controlador que agrega as funções de gerar
um perfil de velocidade para o motor de passo e transformar este perfil em intervalos
de pulsos, onde cada pulso gerado incrementa um passo para o motor.
Existem duas alternativas para a implementação deste controlador: a) na
alternativa de controle denominada off-line, a temporização entre os passos é
calculada antes do início do movimento, e armazenada em uma memória de dados
no FPGA, o que gera uma desvantagem, pois estes dados ocupam grande espaço de
memória no hardware; b) na alternativa de controle denominada online, o intervalo
entre um passo e outro é calculado em tempo real, o que dispensa a criação de uma
memória de dados para os intervalos de pulsos (CARRICA; FUNES; GONZÁLEZ,
2003). Segundo os autores (2003, p. 124, tradução nossa), “Este algoritmo
implementado em FPGA permite uma diminuição do tempo de processamento
equivalente desenvolvido por controladores clássicos de velocidade. Como
consequência, o motor de passo pode atingir altas velocidades nunca obtidas com
algoritmo padrão baseado em sistemas”.
Outra solução, que integra um controlador mais robusto, é apresentada por
Kung et al. (2015), a mesma utiliza um FPGA para o controle de três eixos acionados
por servomotores. Nesse caso, a solução proposta implementa um sistema de
múltiplos eixos comandados por servomotores e elabora um planejamento da
trajetória a ser percorrida pelos mesmos, a fim de sincronizar seus movimentos. Para
tanto, dentro de um único chip reprogramável, desenvolve um SOPC (System On a
Programmable Chip) composto por um FPGA e um microprocessador embutido no
mesmo. O planejamento de trajetória é desenvolvido dentro do microprocessador, são
aceitas trajetórias lineares, circulares e helicoidais. Já o comportamento dos eixos –
controle de posição, velocidade e corrente – é implementado no hardware, descrito
em VHDL (KUNG et al., 2015).
44
Uma terceira proposta, apresentada por Cho, Le e Jeon (2009), utiliza um
FPGA para controlar multiplos servomotores. Essa solução apresenta o controle de
movimentações de um sistema composto por múltiplos eixos, podendo ser empregado
em um manipulador robótico ou em uma máquina de Comando Numérico
Computadorizado. O chip de controle de movimento proposto tem muitas funções.
Essas incluem geração de perfil de velocidade, cálculo de interpolação, cálculo da
cinemática inversa, controle proporcional-integral-derivativo, realimentação de
contagem, integração de pulso, conversão de dados, geração de clock e interface
externa. Essas funções são projetadas usando VHDL e implementada em um FPGA
de acordo com a metodologia do projeto eletrônico. Isso permite uma amostra
altamente precisa, flexível, compacta, de baixo consumo de energia e de baixo custo.
Em outro estudo, Prado et al. (2017) implementam um bloco de controle PID
em um FPGA. O objetivo, segundo os autores, é utilizar o dispositivo lógico
programável como controlador de movimentos de um servomotor. Para tanto, o
hardware, descrito em VHDL, controla a saída do bloco PID conforme a variação da
leitura do sinal de erro, em função das variáveis de controle proporcional, integral e
derivativo. Inicialmente é realizado um comparativo entre o bloco PID desenvolvido
em VHDL (implementação em hardware) e o bloco PID simulado no software Simulink
(implementação em software). Ambos são submetidos a um mesmo sinal de entrada
e configurados com as mesmas variáveis de controle PID. Verifica-se, nessa
comparação, que o bloco implementado via software apresenta uma resposta mais
rápida e atinge o setpoint anteriormente ao bloco implementado via hardware.
Todavia, segundo os autores, apesar da diferença acima mencionada, o desempenho
da implementação via hardware pode ser aceitável para aplicações de controle em
ambientes industriais.
Posteriormente, a performance do bloco desenvolvido via hardware é testada
num braço robótico de três graus de liberdade, comandados via servomotor. Percebe-
se uma pequena variação entre a trajetória de deslocamento dos três motores em
relação a trajetória de referência. Os autores atribuem essa variação à influência da
dinâmica não-linear do servomotor ou à força de gravidade (PRADO et al., 2017).
45
Ademais, Bhatt e More (2014) utilizam um FPGA como controlador em um CNC
de três eixos. O hardware configurado no dispositivo interpola linearmente o
movimento dos eixos X, Y e Z, acionados por motores de passo. O controlador
implementado pelos autores comanda drives comerciais de motores de passo através
de sinais de pulso e direção.
As coordenadas para os eixos X, Y e Z são recebidas pelo FPGA através da
interface UART (Universal Asynchronous Receiver Transmitter), construída como
ferramenta de interação com dispositivos externos geradores de códigos de
movimentação. Assim que recebidas, as coordenadas são armazenadas
sequencialmente e enviadas aos drives dos seus respectivos eixos em forma de pulso
e direção.
Para validação do hardware configurado, Bhatt e More estipulam valores às
coordenadas X, Y e Z e utilizam um osciloscópio digital para leitura da simulação
executada. Os resultados, segundo os autores, confirmam que “o algoritmo de
implementação e o processamento simultâneo de hardware fazem com que o módulo
tenha um bom desempenho em tempo real. [...] A simulação e implementação em
FPGA de movimento direto no espaço 3D verifica a eficácia da abordagem proposta’”
(2014, p. 51, tradução nossa). Ainda, os autores indicam a utilização do mesmo em
atividades práticas com comando numérico computadorizado, robótica industrial e
instrumentação médica.
Por fim, Yu e Guo (2013) desenvolvem em seu estudo um controlador digital
que permite a variação gradativa da corrente nas bobinas de um motor de passo. O
intuito é substituir o controle analógico por um controle digital, eliminando a
necessidade de conversores digital-analógico (D/A). Para tanto, desenvolvem a
técnica de controle por micro passo.
O controle desenvolvido por Yu e Guo consiste em dividir um passo do motor
em 16 segmentos. Onde, cada segmento resulta em um degrau de corrente na bobina
do motor. Assim, a corrente do motor, para cada passo, resulta em 8 degraus de
subida e 8 degraus de descida.
46
O degrau de corrente consumido pelo motor é, na verdade, resultado de uma
modulação de largura de pulso (PWM) da tensão que alimenta o mesmo. Para a
obtenção dos segmentos de passo, os autores desenvolvem um comparativo entre
um sinal de dente de serra e valores pré-estabelecidos em uma memória ROM,
descrita em VHDL e implementada no próprio FPGA.
Os resultados do trabalho desenvolvido foram simulados pelas ferramentas
disponíveis no software do fabricante Intel e apresentam um controle preciso de
chaveamento da saída PWM, resultando em uma curva trapezoidal de velocidade
(aceleração de início constante – velocidade constante – desaceleração uniforme –
parada). Com base nas respostas obtidas, Yu e Guo afirmam que os resultados
experimentais indicam que o uso de FPGA para controlar o motor de passo pode
resultar num controle preciso do ângulo do motor e, com isso, não há necessidade de
um conversor D/A externo. Definem, ainda, este método como simples e de alta
precisão.
Partindo das necessidades e características do dispositivo de usinagem ora
automatizado, e considerando a factibilidade dos resultados obtidos nas pesquisas
apresentadas, o próximo capítulo descreve o controlador desenvolvido nesse projeto.
O mesmo apresenta um perfil de velocidade para os motores dos eixos X e Z e
conversão deste perfil em um intervalo de pulsos, interpolação linear dos eixos das
coordenadas X e Z, armazenamento de trajetória em memória RAM e interação com
dispositivo externo via GPIO.
47
3 METODOLOGIA
O desenvolvimento de um produto mecatrônico é composto por várias etapas,
pertencentes a uma metodologia, que precisam ser específicas e detalhadas para que
o produto possa ser desenvolvido dentro do planejado. A metodologia utilizada para o
desenvolvimento do controle do sistema de coordenadas com dois eixos segue o
Modelo PRODIP. O Modelo PRODIP foi utilizado inicialmente para projetos,
construção e testes de protótipos de máquinas agrícolas. Nessa aplicação, ponderou-
se, tanto modelos propostos em literatura, quanto uma pesquisa realizada em fábricas
desse setor. (OGLIARI, 2016). A figura 14 apresenta a estrutura do Modelo PRODIP.
Figura 14 – Estrutura do Modelo PRODIP
Fonte: Disponível em http://emc5302.ogliari.prof.ufsc.br/artigo/modelo-prodip. Acesso em 15 de ago. de 2018.
Segundo a ilustração da figura 14, na primeira etapa, denominada por
planejamento, é onde são definidas as ideias para a criação de um produto e onde é
estabelecido um plano para o desenvolvimento dessas ideias. O produto aqui definido
é: controlador para sistema de coordenadas XZ descrito em VHDL e implementado
em FPGA.
Com o produto planejado, é necessário projetá-lo. Essa é a segunda etapa: a
projetação. A primeira fase da projetação é o projeto informacional. Nessa fase são
estabelecidas as especificações que irão orientar o desenvolvimento técnico do
produto. Aqui, são levantados os requisitos, as especificações e os fatores que
48
influenciam no projeto do produto. Os requisitos de projeto são estabelecidos na seção
3.1.
A segunda fase da projetação é o projeto conceitual. As alternativas são
criadas, avaliadas e selecionadas, considerando a solução mais viável na relação
técnica/econômica. Aqui é definida uma concepção para o produto. Os estudos de
viabilidade e seleção de soluções para o produto são apresentados na seção 3.2.
O projeto preliminar é definido na terceira fase da projetação. Ele consiste em
definir um esboço do produto (layout) e, posteriormente, a fabricação do protótipo.
Aqui, também, são realizados os ensaios do protótipo, bem como é gerada a
documentação que contém dados da fabricação e ensaios do protótipo. A seção 3.3
descreve o protótipo desenvolvido nesse projeto.
O projeto detalhado finaliza a etapa da projetação. Aqui são finalizados os
detalhes do protótipo e é gerada a documentação final para a fabricação do produto.
Essa dissertação conclui as etapas de desenvolvimento do projeto ora apresentado.
Nesse trabalho, a etapa da projetação é seguida, cronologicamente, ao decorrer do
desenvolvimento do projeto de produto.
A etapa de implementação do produto consiste em produzir um lote piloto,
desenvolver um ferramental, comprar material necessário para a produção do produto
em grande escala, lançar o produto no mercado e monitorar o comportamento do
produto em campo. Essa etapa não é abordada nesse projeto, pois o mesmo delimita-
se ao desenvolvimento de um protótipo.
3.1 Requisitos de projeto
O Instituto Federal de Santa Catarina – IFSC, no câmpus Chapecó, desenvolve
um projeto de pesquisa na área de High Speed Cutting (Corte em Alta Velocidade)4,
que consiste na fabricação de um dispositivo de torneamento com corte em alta
rotação. Os dispositivos High Speed Cutting são utilizados em laboratórios de
4 Contemplado pelo Edital Universal de Pesquisa nº 2/2018 – PROPPI – IFSC.
49
pesquisa para análise do desgaste das ferramentas de corte, uma vez que as mesmas
operam sob velocidades de corte acima das estipuladas pelos fabricantes. No
ambiente industrial, o desgaste de ferramentas é um agente importante a ser
analisado, pois os tempos de troca de ferramentas em máquinas (set-up) ou a redução
de tempos de usinagem, influenciam de maneira significativa nos custos de produção
(BARBOSA, 2014). Além disso, o desgaste das ferramentas, quando analisado em
altas rotações, pode determinar a vida destes componentes em escala efetiva, dessa
forma, estimula a procura de empresas do setor de usinagem por laboratórios que
possuam dispositivos High Speed Cutting (MORELO, 2016).
De acordo com King (1985), um dispositivo High Speed opera entre 2000 e
6000 sfm (surface feet per minute)5. Valores inferiores a 2000 correspondem às
máquinas de usinagem convencionais e valores superiores a 6000 correspondem a
outra categoria de máquina de usinagem, denominada Very High Speed. O limite de
velocidade do eixo árvore, em rpm, surge da equação 1 e leva em consideração o
diâmetro das peças a serem usinadas no dispositivo High Speed.
𝑉𝑒𝑙 𝐸𝑖𝑥𝑜 Á𝑟𝑣𝑜𝑟𝑒 (𝑟𝑝𝑚) =𝑠𝑓𝑚 ∗
12𝜋
𝑑𝑖â𝑚𝑒𝑡𝑟𝑜 𝑝𝑒ç𝑎 (𝑝𝑜𝑙𝑒𝑔𝑎𝑑𝑎𝑠) (1)
O dispositivo de torneamento, em desenvolvimento no IFSC – Chapecó, é
projetado para usinar peças em Aço Inoxidável Austenítico Melhorado (SANMAC)
Forjado Recozido, com diâmetro de 50 mm. Assim sendo, o eixo árvore, de acordo
com a equação 1, deve girar em velocidades que variam de 0 a 11634 rpm. Para tanto,
o mesmo é acionado por um motor de indução que varia sua velocidade por meio de
um inversor de frequência, conforme a necessidade dos testes.
O deslocamento da ferramenta de corte é realizado através de um sistema de
coordenadas XZ. A movimentação dos eixos das coordenadas deve seguir uma
relação estipulada pelo usuário, dada em mm/rotação, ou seja, a velocidade de
5 Surface feet per minute – corresponde ao número de pés que um componente rotativo desloca em um minuto. Comumente utilizado na medição de velocidade de corte (velocidade superficial) em usinagem. 1 sfm equivale a 0,00508 m/s (KING, 1985).
50
avanço da ferramenta varia conforme a necessidade de desbaste do material usinado
por rotação do eixo árvore. A estrutura mecânica do sistema de coordenadas é
demonstrada na figura 15. De acordo com a figura, o deslocamento linear de ambos
os eixos é realizado por fusos de esfera (a), com passo de 5 mm. Além dos elementos
de transmissão, são utilizados elementos de apoio: a guia linear (b) dá sustentação a
movimentação da estrutura mecânica; os rolamentos (c) conectam o eixo dos motores
aos fusos de esfera; os acoplamentos (d) fixam os fusos de esfera a estrutura
mecânica.
Figura 15 – Estrutura mecânica do sistema de coordenadas
Fonte: O autor (2018)
Nessa dissertação objetiva-se projetar e implementar o controlador
responsável pela movimentação dos eixos X e Z. Para o desenvolvimento do
controlador proposto é preciso obter as informações relacionadas a sua aplicabilidade,
isto é, estabelecer os requisitos de projeto necessários para o correto funcionamento
do sistema de deslocamento linear por coordenadas. Nesse sentido, com base nas
51
características da máquina de usinagem, o sistema de coordenadas dos eixos X e Z
segue as seguintes especificações de projeto:
I. Precisão e Repetibilidade: é necessário que as peças usinadas apresentem
precisão e repetibilidade de medidas inferiores a 0,03 mm;
II. Tipo de material a ser usinado: as peças usinadas são de Aço Inoxidável
Austenítico Melhorado (SANMAC) Forjado Recozido e possuem diâmetro inicial de 50
mm. De acordo com os cálculos do dimensionamento mecânico, apresentados no
APÊNDICE A, o torque dos motores a serem utilizados é de 1,8 N.m para a
coordenada do eixo Z e 0,4 N.m para a coordenada do eixo X;
III. Velocidade de operação: o deslocamento de avanço da ferramenta, enquanto
estiver usinando para fins de análise de desgaste, varia entre 0,1 e 0,4 mm por rotação
do eixo árvore (KING, 1985). Considerando as características da transmissão
mecânica, apresentada na figura 15, a cada volta do motor, o eixo da coordenada
desloca 5 mm. Além disso, considerando que o avanço máximo do motor é 0,4 mm
por rotação do eixo árvore e estipulando que a máxima velocidade do eixo árvore é
de 10000 rpm, então, tem-se que a rotação dos motores, para ambos os eixos, deve
variar de 0 a 800 rpm;
IV. Movimentos: a ferramenta deve assumir as funções de torneamento transversal
(deslocamento do eixo X), torneamento longitudinal (deslocamento do eixo Z) e
torneamento bidirecional cartesiano (deslocamentos dos eixos X e Z com interpolação
linear entre eles). Além disso, é preciso realizar movimentos suaves que sigam
rampas de aceleração e desaceleração;
V. Comandos: os comandos de movimentação dos eixos são recebidos através
de botoeiras dispostas em um painel; sensores de fins de curso limitam o
deslocamento dos eixos e servem de referência de zero máquina (referenciamento
dos eixos); há a necessidade de movimentos manuais, controlados via joystick
analógico; a trajetória de posicionamento deve ser salva em uma memória do
controlador;
VI. Sequência operacional: a sequência de funcionamento do sistema de
coordenadas deve seguir as especificações descritas no fluxograma, apresentado na
52
figura 16; o sistema precisa ser energizado por um disjuntor, disposto em um painel;
após energização é necessário executar um comando de busca de zero máquina para
que os eixos das coordenadas referenciem-se em razão de um ponto zero inicial; com
os eixos referenciados, há a possibilidade de realizar movimento manuais, através de
um joystick analógico que varia a velocidade dos motores em modo manual; a
trajetória a ser executada é salva em uma memória, para executá-la é necessário
selecionar o modo automático, através de uma botoeira manual/automático, e
pressionar o comando partir automático.
Figura 16 – Fluxograma operacional do sistema de coordenadas
Fonte: O autor (2018)
53
3.2 Concepção do produto
O objetivo principal do trabalho realizado é desenvolver um sistema de
movimentação de motores de precisão, baseado na aplicação do dispositivo FPGA.
O mesmo, além de controlar o sistema de coordenadas, deve servir de subsídio
didático, podendo ser utilizado em disciplinas, projetos de pesquisa e extensão,
desenvolvidos e ofertados pelo IFSC – Chapecó. Portanto, o controle de
movimentação dos motores utiliza a placa didática DE10-Lite, composta pelo FPGA
MAX10 da Intel, a qual possui 10 unidades disponíveis para utilização no IFSC –
Chapecó.
Além do controlador, é necessário analisar e selecionar a melhor solução
técnica e econômica para a motorização dos eixos das coordenadas X e Z. No que
compete a aplicações que necessitam de precisão e repetibilidade de posicionamento,
atualmente, motores de passo e servomotores tem despontado como as melhores
soluções disponíveis. A escolha entre um ou outro se dá em função de alguns fatores
a serem considerados, tais como: atender os requisitos de precisão de
posicionamento angular; atender os requisitos de torque e velocidade; analisar a
necessidade de controlar o torque do motor; verificar a necessidade de detectar perda
de posição ou medir a posição real da carga para correção de folgas mecânicas.
(PARKER, 2003).
Segundo a Kalatec, empresa que atua na área da automação industrial, os
motores de passo oferecem boa performance quando operam com até 900 rpm, para
velocidades acima dessa, o uso do mesmo não é recomendado. Já os servomotores,
podem operar com velocidades muito superiores a esta, podendo chegar a 3000 rpm,
dependendo de sua construção física. Quanto a resolução, a empresa comercializa
drives de motor de passo que permitem que o motor, na função micropasso, opere
com até 51200 ppr (pulsos por revolução), ao passo que os servomotores,
comercializados pela mesma, possuem realimentação via encoder, com 17 bits de
resolução, o que permite que os mesmos trabalhem com 160000 ppr (tendo como
opcional encoder de 20 bits – 1280000 ppr). Diferentemente dos servomotores, os
motores de passo geralmente operam no modo malha aberta, ou seja, em aplicações
54
onde haja a possibilidade de perda de posição, os mesmos precisam ser
realimentados via sensor externo. As famílias de servomotores, normalmente, são
projetadas para operarem com capacidade de torque superior aos motores de passo,
a Kalatec, por exemplo, comercializa servomotores que apresentam torque nominal
de 1,26 a 47,74 N.m, e motores de passo que apresentam torque estático que variam
de 0,12 a 13 N.m. Quanto ao custo dos mesmos, um conjunto de servoacionamento
(motor, drive e cabos) pode chegar a valores muito superiores ao custo de um conjunto
de acionamento via motor de passo (motor e drive) (KALATEC, 2018).
Com base nas informações levantadas, a tabela 2 apresenta um comparativo
entre as características de um servomotor da marca Delta, modelo ECMA-C20604-
ES, acionado pelo drive modelo ASDA-B2, e de um motor de passo da marca Kalatec,
modelo KTC-HT23-397, acionado pelo drive modelo KTC-STR-3. Segundo as
informações da tabela, os dois motores apresentam um torque que atende as
necessidades do projeto; os servomotores possuem uma resolução maior, quando
comparados aos motores de passo; a solução com servoacionamento chega a custar
seis vezes mais que a solução com motor de passo.
Considerando as necessidades do projeto ora desenvolvido, apresentadas na
seção 3.1, ambos possuem as características técnicas necessárias para serem
implementados na motorização do sistema de coordenadas. Dada a grande diferença
no preço, o motor de passo se apresenta como a solução econômica mais viável,
portanto, o mesmo é selecionado para a aplicação.
Tabela 2 – Comparativo de características: Motor de passo X Servomotor
Motor de passo Servomotor
Motor
Modelo KTC-HT23-397 ECMA-C20604-ES
Fabricante Kalatec Delta
Torque 1,25 Nm 1,27 Nm
Resolução 200 - 100400 ppr* 160000 ppr
Máxima Rotação Não informado 3000 rpm
Realimentação Não Encoder
Preço do motor** R$ 95,00 R$ 1.080,00
Drive
Modelo KTC-STR-3 ASDA-B2
Fabricante Kalatec Delta
Tensão de alimentação 48VDC 220VAC
Preço do drive e cabos** R$ 415,00 R$ 2.000,00
* resolução obtida com a utilização do drive KTC-STR-3
** os orçamentos foram realizados no segundo semestre de 2018
Fonte: O autor (2018)
55
3.3 Desenvolvimento do protótipo
A partir das especificações estabelecidas para o projeto e das alternativas
criadas e selecionadas como solução para o mesmo, essa seção apresenta o
desenvolvimento do controlador implementado no FPGA MAX10 – Intel, bem como as
ligações elétricas necessárias para recebimento dos comandos e acionamento dos
motores.
3.3.1 Projeto elétrico e lista dos materiais utilizados
A tabela 3 apresenta a lista dos materiais elétricos utilizados no projeto e
fornece uma relação de preço dos mesmos. Os materiais correspondentes aos itens
1 a 4 (controlador, motor de passo, drive de potência para motor de passo e
transformador) não foram adquiridos especificamente para o projeto, os mesmos já
estavam disponíveis para utilização no IFSC – Chapecó. Dessa forma, o motor de
passo utilizado no projeto apresenta um torque 3 vezes maior ao torque necessário,
calculado para o projeto. Considerando a utilização dos itens já disponíveis, o custo
de materiais elétricos e eletrônicos para o projeto reduz-se a 20% do valor informado
na tabela 3.
Tabela 3 – Lista de materiais elétricos
ITEM MATERIAL DESCRIÇÃO QUANTIDADE PREÇO
1 Controlador Placa didática com FPGA MAX 10. Fab: Terasic / Modelo: DE10-LITE
1 R$ 200,00
2 Motor de passo Motor com 52 kgf.cm / 5 N.m e 5 A/fase. Fab: Akiyama / Modelo: AK85H/3.75-1.8
2 R$ 600,00
3 Drive para motor Drive de 7.2 A, 18~80 VAC. Fab: Composul Modelo: AKDMP16-7.2A
2 R$ 850,00
4 Transformador Transformador monofásico 220 VAC / 48 VAC 5 A
2 R$ 400,00
5 Fonte 5 V Fonte de 5 V, 2 A 1 R$ 15,00
6 Painel elétrico Painel metálico com dimensões de 50 x 40 x 20 cm
1 R$ 180,00
7 Joystick analógico Joystick analógico 0-5 V, 3 eixos + push-button. Modelo: JH-D400X-R4 10K
1 R$ 60,00
8 Fim de curso Fim de curso com contato mecânico 4 R$ 20,00
9 Botoeiras de comando Botão com 1 contato NA 2 R$ 40,00
56
10 Botoeira de emergência Botão com 1 contato NF 1 R$ 25,00
11 Seletora 2 posições Seletora com 1 contato NA 1 R$ 30,00
12 Disjuntor Geral Disjunto unipolar 1 R$ 30,00
13 Cabos de comando Cabo colorido para ligação elétrica no painel
50 m R$ 25,00
TOTAL R$ 2.475,00
Fonte: O autor (2018)
As conexões elétricas, de potência e comando, são apresentadas nas figuras
17 e 18, respectivamente. Na figura 17, o ajuste das dip switches segue as
especificações do fabricante do drive de motor de passo, Composul. Conforme
especifica a tabela 4, as dip switches são ajustadas para que o motor opere com
corrente de 5,14 A (SW1, SW2 = ON e SW3 = OFF) e com redução de corrente para
velocidade de zero rpm (SW4 = OFF). Além disso, o motor é ajustado para operar com
400 pulsos por revolução (SW5, SW6, SW7, SW8 = ON) (COMPOSUL, 2018).
Considerando que o sistema de coordenadas desloca 5 mm a cada volta do motor, o
ajuste em 400 pulsos por revolução no motor, possibilita que o sistema de
coordenadas apresente uma precisão de 0,0125 mm, desconsiderando possíveis
folgas mecânicas. Com essa resolução, se procura atender a especificação de projeto
que estipula uma precisão e repetibilidade inferior a 0,03 mm.
Tabela 4 – Configuração das dip switches, drive AKDMP16-7.2 A
Micro passo PPR SW5 SW6 SW7 SW8
Corrente SW1 SW2 SW3
2 400 ON ON ON ON 2,40 A ON ON ON
4 800 OFF ON ON ON 3,08 A OFF ON ON
8 1600 ON OFF ON ON 3,77 A ON OFF ON
16 3200 OFF OFF ON ON 4,45 A OFF OFF ON
32 6400 ON ON OFF ON 5,14 A ON ON OFF
64 12800 OFF ON OFF ON 5,83 A OFF ON OFF
128 25600 ON OFF OFF ON 6,52 A ON OFF OFF
256 51200 OFF OFF OFF ON 7,20 A OFF OFF OFF
5 1000 ON ON ON OFF
10 2000 OFF ON ON OFF SW4 = OFF - redução de corrente para velocidade 0 rpm; ON - corrente 100% para velocidade 0 rpm
20 4000 ON OFF ON OFF 25 5000 OFF OFF ON OFF 40 8000 ON ON OFF OFF 50 10000 OFF ON OFF OFF
100 20000 ON OFF OFF OFF 200 40000 OFF OFF OFF OFF
Fonte: Composul (2018)
57
Figura 17 – Projeto Elétrico – Parte de Potência
Fonte – O autor (2018)
58
Figura 18 – Projeto Elétrico – Parte de Comando
Fonte – O autor (2018)
59
3.3.2 Desenvolvimento e implementação do hardware
O controle de movimentação e posicionamento dos motores de passo é
implementado no FPGA MAX10, da Intel. O hardware é descrito majoritariamente em
VHDL e faz uso de propriedades intelectuais dispostas pelo fabricante.
No software Quartus Prime é possível criar um símbolo que representa um
componente descrito em VHDL, o mesmo recebe o nome de Block Symbol File
(arquivo .bsf). A figura 19 mostra os símbolos, que são fragmentos de diagrama
esquemático, desenvolvidos nesse projeto. Conforme visto na figura, os símbolos
criados são: a) home – executa o comando de busca de zero máquina para os
motores; b) move_manual: responsável pelo acionamento dos motores em modo
manual; c) speed_profile: define um perfil de velocidade para os motores, quando em
modo automático, estabelecendo interpolação linear entre os mesmos; d) ram –
armazena 32 posições, com 16 bits cada, para definição de trajetórias; e) controller –
comanda demais componentes conforme comandos externos.
Além disso, o projeto é composto também pelos componentes adc e counter,
apresentados na figura 20, que utilizam propriedades intelectuais da Intel. O bloco adc
é um conversor de sinal analógico para digital, utilizado para a leitura da posição do
joystick, e o bloco counter é um contador, utilizado para leitura de passos dos motores.
Os sinais de referência de clock, vcc e gnd são lidos da placa DE10-Lite e
empregados pelos blocos criados na aplicação. Além desses, a figura 21 ilustra o
acionamento das saídas digitais utilizadas para acionamento dos motores, enviando
aos drives de potência os sinais de pulso, direção e habilitação.
60
Figura 19 – Símbolos
Fonte: O Autor (2018)
61
Figura 20 – Blocos adc e counter Figura 21 – Sinais da placa DE10-Lite e saídas para os drives de potência
Fonte: O Autor (2018) Fonte: O Autor (2018)
62
3.3.2.1 Blocos adc e counter: o uso de propriedades intelectuais da Intel
A biblioteca de propriedades intelectuais da Intel disponibiliza a utilização de
um grupo de módulos parametrizados, denominados LPMs (Library of parameterized
modules). A biblioteca LPM é composta por componentes que executam funções
aritméticas, tais como, contagem (LPM_COUNTER); divisão (LPM_DIVIDE);
multiplicação (LPM_MULT); adição e subtração (LPM_ADD_SUB); e comparação
(LPM_COMPARE). Os LPMs possuem estruturas configuráveis e podem ser
personalizados de acordo com os requisitos do projeto do usuário. O
LPM_COUNTER, por exemplo, executa contagens binárias e pode ser empregado
com as funções de incremento, decremento ou ambas. Além disso, disponibiliza o uso
opcional das funções: clear, load e set (síncrono e assincrono); count enable, clock
enable, carry_in, e carry_out (INTEL, 2017a). Nesse projeto, os blocos counter
utilizam o componente LPM_COUNTER para definição da posição real do motor.
Como pode ser visto na figura 20, empregam-se dois contadores, um para cada motor.
O sinal step é conectado a entrada de contagem do contador (clock); o sinal dir indica
se a contagem é crescente ou decrescente (updown); o sinal clear zera a contagem
de forma assíncrona (aclr); o sinal real_pos indica a posição real do motor, dada em
número de passos (data_out).
Outra propriedade intelectual da Intel, por ora empregada, é a ADC Controller
for DE-series Board, propriedade que possibilita a leitura de sinais analógicos
conectados as placas DE. Na placa DE10-Lite, utilizada nesse projeto, pode-se
efetuar a leitura de seis sinais analógicos (0 – 5 V) com resolução de 12 bits cada.
Essa propriedade intelectual utiliza uma referência de clock de 10 MHz, oriundo da
DE10-Lite e conectado aos PLLs 1 e 3 do FPGA MAX 10 (INTEL, 2018). Nesse
projeto, a ADC Controller for DE-series Board é utilizada para leitura dos
potenciômetros presentes no joystick (bloco adc, figura 20). Os mesmos definem a
velocidade de deslocamento dos motores quando em modo manual. Os sinais anaX
e anaZ, correspondentes aos eixos X e Z, são conectados aos canais 0 e 1,
respectivamente, do bloco adc.
63
3.3.2.2 Componentes desenvolvidos em VHDL
Os componentes desenvolvidos em VHDL estão dispostos no Apêndice B, os
mesmos implementam as lógicas correspondentes às funções apresentadas na figura
19, de acordo com a sintaxe da linguagem VHDL apresentada na seção 2.4. De uma
maneira geral, a velocidade dos motores, tanto para modo manual, quanto para modo
automático, é dada em pulsos de referência por passo do motor, ou seja, relaciona
quantos pulsos de referência precisam ser contados para que o motor dê um passo.
O sinal de referência utilizado é de 50 MHz, proveniente da placa DE10-Lite.
Quando em modo manual, a velocidade de operação dos motores segue um
sinal analógico de 12 bits, oriundo da movimentação de um joystick. A figura 22 ilustra
o comportamento da velocidade em relação a leitura do sinal analógico. Os valores
extremos, 0 e 4095, indicam que o joystick se encontra nas posições máximas de
operação, então, para estas condições, a velocidade do motor é a máxima (o motor
dá um passo a cada 50000 pulsos de referência). Os valores 1791 e 2304 indicam o
início da movimentação do motor, então, para estas condições, a velocidade do motor
é a mínima (o motor dá um passo a cada 100000 pulsos de referência). Os valores
compreendidos entre 1791 e 2304 indicam que o joystick se encontra na posição de
repouso, para esta condição a velocidade de operação é zero, ou seja, o motor
permanece parado.
Figura 22 – Variação de velocidade em modo manual
Fonte: O Autor (2018)
0
10.000
20.000
30.000
40.000
50.000
60.000
70.000
80.000
90.000
100.000
puls
os d
e c
lk p
or
pa
sso
no
mo
tor
entrada analógica (12 bits)
Velocidade em modo manual
0 1791 2304 4095
64
Quando em modo automático, o componente responsável pela movimentação
automática lê sinais de entrada referentes à distância a ser deslocada pelos motores,
velocidade da ferramenta e tempo de aceleração. Através desses sinais de entrada,
é construído um perfil de velocidade para os motores, ilustrado na figura 23. Os
motores X e Z iniciam e finalizam seus movimentos simultaneamente e seguem os
mesmos tempos de aceleração e desaceleração. A velocidade para cada um dos
motores é calculada de acordo com o deslocamento dos mesmos, ou seja, quanto
maior o deslocamento de um determinado eixo, maior será a velocidade do mesmo.
Conforme exemplifica a figura 23, o motor 1 opera com a velocidade 1, enquanto o
motor 2 opera com a velocidade 2, sendo a segunda velocidade o dobro da primeira,
isso porque o deslocamento percorrido pelo motor 2 é o dobro do deslocamento
percorrido pelo motor 1.
Figura 23 – Perfil de velocidade dos motores
Fonte: O Autor (2018)
Como o deslocamento da ferramenta se dá em função da movimentação dos
motores dos eixos X e Z, sabe-se, através da trigonometria, que o quadrado da
distância a ser percorrida pela ferramenta é igual à soma dos quadrados das
distâncias percorridas pelos eixos X e Z. Esse cálculo é demonstrado na equação 2,
onde, os deslocamentos são dados em número de passos do motor.
𝑑𝑒𝑠𝑙𝑜𝑐𝑎𝑚𝑒𝑛𝑡𝑜 𝑓𝑒𝑟𝑟𝑎𝑚𝑒𝑛𝑡𝑎2 = 𝑑𝑒𝑠𝑙𝑜𝑐𝑎𝑚𝑒𝑛𝑡𝑜 𝑚𝑜𝑡𝑜𝑟 𝑥 2 + 𝑑𝑒𝑠𝑙𝑜𝑐𝑎𝑚𝑒𝑛𝑡𝑜 𝑚𝑜𝑡𝑜𝑟 𝑧2 (2)
Deslocamento Ferramenta
or 2 (passos)
Velocidade
(rotações/s)
Deslocamento motor 2
(rotações)
Tempo
(s)Tempo de
Aceleração
Velo
cid
ade 2
Tempo de Desaceleração
Tempo de Posicionamento
Deslocamento motor 1
(rotações)
Velo
cid
ade 1
Velo
cid
ade F
err
am
enta
Tempo com Velocidade Constante
65
A velocidade de operação dos motores, em rotações por segundo e em pulsos
de referência por passo no motor, é apresentada nas equações 3 e 4,
respectivamente. De acordo com as equações, para que o motor atinja a velocidade
(3), em rotações por segundo, é preciso que o mesmo rotacione um passo em seu
eixo a cada (4) pulsos lidos do sinal de referência.
𝑣𝑒𝑙𝑜𝑐𝑖𝑑𝑎𝑑𝑒 𝑚𝑜𝑡𝑜𝑟 (𝑟𝑝𝑠) =𝑑𝑒𝑠𝑙𝑜𝑐𝑎𝑚𝑒𝑛𝑡𝑜 𝑚𝑜𝑡𝑜𝑟 (𝑝𝑎𝑠𝑠𝑜𝑠)
𝑑𝑒𝑠𝑙𝑜𝑐𝑎𝑚𝑒𝑛𝑡𝑜 𝑓𝑒𝑟𝑟𝑎𝑚𝑒𝑛𝑡𝑎∗ 𝑣𝑒𝑙𝑜𝑐𝑖𝑑𝑎𝑑𝑒 𝑓𝑒𝑟𝑟𝑎𝑚𝑒𝑛𝑡𝑎 (𝑟𝑝𝑠) (3)
𝑣𝑒𝑙𝑜𝑐𝑖𝑑𝑎𝑑𝑒 𝑚𝑜𝑡𝑜𝑟 (𝑝𝑢𝑙𝑠𝑜𝑠 𝑟𝑒𝑓/𝑝𝑎𝑠𝑠𝑜) =𝑓𝑟𝑒𝑞𝑢ê𝑛𝑐𝑖𝑎 𝑑𝑒 𝑟𝑒𝑓𝑒𝑟ê𝑛𝑐𝑖𝑎 (𝐻𝑧)
𝑟𝑒𝑠𝑜𝑙𝑢çã𝑜 𝑚𝑜𝑡𝑜𝑟 ∗ 𝑣𝑒𝑙. 𝑚𝑜𝑡𝑜𝑟 (𝑟𝑝𝑠) (4)
As rampas de aceleração e desaceleração são definidas em função da
velocidade dos motores e do tempo de aceleração/desaceleração dos mesmos. Com
base em análises da figura 23, sabe-se, através do cálculo integral, que o
deslocamento percorrido pelos eixos X e Z é obtido através da área resultante entre a
função velocidade e um intervalo de tempo conhecido. No intervalo de tempo em que
a velocidade varia linearmente de zero a velocidade de operação (aceleração
constante), o deslocamento dos eixos é obtido através da equação 5.
𝑝𝑎𝑠𝑠𝑜𝑠 𝑛𝑜 𝑚𝑜𝑡𝑜𝑟 𝑝𝑎𝑟𝑎 𝑎𝑐𝑒𝑙𝑒𝑟𝑎𝑟 =𝑣𝑒𝑙. 𝑚𝑜𝑡𝑜𝑟 (𝑝𝑢𝑙𝑠𝑜𝑠 𝑟𝑒𝑓/𝑝𝑎𝑠𝑠𝑜) ∗ 𝑡𝑒𝑚𝑝𝑜 𝑎𝑐𝑒𝑙𝑒𝑟𝑎çã𝑜 (𝑠) ∗ 𝑟𝑒𝑠𝑜𝑙𝑢çã𝑜 𝑚𝑜𝑡𝑜𝑟
2 (5)
A equação 6, efetua o cálculo da quantidade de pulsos de referência lidos
durante a aceleração e desaceleração dos motores. Isso quer dizer que, durante um
intervalo de tempo com (6) pulsos de referência, o motor rotaciona (5) passos.
𝑝𝑢𝑙𝑠𝑜𝑠 𝑟𝑒𝑓𝑒𝑟ê𝑛𝑐𝑖𝑎 𝑝𝑎𝑟𝑎 𝑎𝑐𝑒𝑙𝑒𝑟𝑎𝑟 = 𝑓𝑟𝑒𝑞𝑢ê𝑛𝑐𝑖𝑎 𝑑𝑒 𝑟𝑒𝑓𝑒𝑟ê𝑛𝑐𝑖𝑎 (𝐻𝑧) ∗ 𝑡𝑒𝑚𝑝𝑜 𝑎𝑐𝑒𝑙𝑒𝑟𝑎çã𝑜 (𝑠) (6)
O intervalo de tempo entre os passos do motor durante a aceleração é
estabelecido através de uma sequência numérica decrescente, obtida através de uma
progressão aritmética finita. Através da equação geral para a soma dos termos de
uma progressão aritmética, tem-se:
66
𝑆𝑛 =(𝑎1 + 𝑎𝑛 ) ∗ 𝑛
2 → 𝑎𝑛 =
(𝑆𝑛 ∗ 2)
𝑛− 𝑎1 (7)
𝑝𝑎𝑠𝑠𝑜 𝑚𝑎𝑖𝑠 𝑙𝑒𝑛𝑡𝑜 𝑛𝑜 𝑚𝑜𝑡𝑜𝑟 (𝑝𝑢𝑙𝑠𝑜𝑠 𝑟𝑒𝑓/𝑝𝑎𝑠𝑠𝑜) =
(𝑝𝑢𝑙𝑠𝑜𝑠 𝑟𝑒𝑓𝑒𝑟ê𝑛𝑐𝑖𝑎 𝑝𝑎𝑟𝑎 𝑎𝑐𝑒𝑙𝑒𝑟𝑎𝑟 ∗ 2)
𝑝𝑎𝑠𝑠𝑜𝑠 𝑛𝑜 𝑚𝑜𝑡𝑜𝑟 𝑝𝑎𝑟𝑎 𝑎𝑐𝑒𝑙𝑒𝑟𝑎𝑟− 𝑣𝑒𝑙. 𝑚𝑜𝑡𝑜𝑟 (𝑝𝑢𝑙𝑠𝑜𝑠 𝑟𝑒𝑓/𝑝𝑎𝑠𝑠𝑜)
(8)
A razão entre os passos durante a aceleração segue o termo geral de uma
progressão aritmética:
𝑎𝑛 = 𝑎1 + (𝑛 − 1) ∗ 𝑟 (9)
𝑟 =𝑎𝑛 − 𝑎1
𝑛 − 1 → 𝑟𝑎𝑧ã𝑜 𝑒𝑛𝑡𝑟𝑒 𝑝𝑎𝑠𝑠𝑜𝑠 𝑛𝑎 𝑎𝑐𝑒𝑙𝑒𝑟𝑎çã𝑜 =
𝑝𝑢𝑙𝑠𝑜𝑠 𝑟𝑒𝑓𝑒𝑟ê𝑛𝑐𝑖𝑎 𝑝𝑎𝑟𝑎 𝑎𝑐𝑒𝑙𝑒𝑟𝑎𝑟 − 𝑣𝑒𝑙𝑜𝑐𝑖𝑑𝑎𝑑𝑒 𝑚𝑜𝑡𝑜𝑟 (𝑝𝑢𝑙𝑠𝑜𝑠 𝑟𝑒𝑓/𝑝𝑎𝑠𝑠𝑜)
𝑝𝑎𝑠𝑠𝑜𝑠 𝑛𝑜 𝑚𝑜𝑡𝑜𝑟 𝑝𝑎𝑟𝑎 𝑎𝑐𝑒𝑙𝑒𝑟𝑎𝑟 − 1
(10)
A equação 11 descreve o comportamento do motor durante a aceleração. A
cada passo dado, o contador de passos é incrementado e, através do termo geral de
uma progressão aritmética, a quantidade de pulsos de referência para um passo no
motor diminui, seguindo a relação estabelecida na equação 10, variando do passo
mais lento do motor (equação 8) até o passo correspondente à velocidade nominal
(equação 4).
𝑝𝑎𝑠𝑠𝑜 𝑛𝑜 𝑎𝑐𝑒𝑙𝑒𝑟𝑎𝑟 (𝑝𝑢𝑙𝑠𝑜𝑠 𝑟𝑒𝑓/𝑝𝑎𝑠𝑠𝑜) =
𝑣𝑒𝑙. 𝑚𝑜𝑡𝑜𝑟 (𝑝𝑢𝑙𝑠𝑜𝑠 𝑟𝑒𝑓/𝑝𝑎𝑠𝑠𝑜) + (𝑝𝑎𝑠𝑠𝑜𝑠 𝑛𝑜 𝑚𝑜𝑡𝑜𝑟 𝑝𝑎𝑟𝑎 𝑎𝑐𝑒𝑙𝑒𝑟𝑎𝑟 − 𝑐𝑜𝑛𝑡𝑎𝑑𝑜𝑟 𝑝𝑎𝑠𝑠𝑜𝑠 − 1) ∗ 𝑟𝑎𝑧ã𝑜 (11)
Durante a desaceleração, o comportamento do motor segue o cálculo
apresentado na equação 12. A relação é inversa da apresentada na equação 11. No
início da desaceleração, a quantidade de pulsos de referência para um passo no motor
aumenta, seguindo a relação estabelecida na equação 10, variando do passo
correspondente à velocidade nominal (equação 4) até o passo mais lento do motor
(equação 8).
𝑝𝑎𝑠𝑠𝑜 𝑛𝑜 𝑑𝑒𝑠𝑎𝑐𝑒𝑙𝑒𝑟𝑎𝑟 (𝑝𝑢𝑙𝑠𝑜𝑠 𝑟𝑒𝑓/𝑝𝑎𝑠𝑠𝑜) =
𝑣𝑒𝑙. 𝑚𝑜𝑡𝑜𝑟 (𝑝𝑢𝑙𝑠𝑜𝑠 𝑟𝑒𝑓/𝑝𝑎𝑠𝑠𝑜) + (𝑝𝑎𝑠𝑠𝑜𝑠 𝑚𝑜𝑡𝑜𝑟 𝑝𝑎𝑟𝑎 𝑎𝑐𝑒𝑙𝑒𝑟𝑎𝑟 − (𝑑𝑒𝑠𝑙𝑜𝑐𝑎𝑚𝑒𝑛𝑡𝑜 𝑚𝑜𝑡𝑜𝑟 − 𝑐𝑜𝑛𝑡𝑎𝑑𝑜𝑟 𝑝𝑎𝑠𝑠𝑜𝑠)) ∗ 𝑟𝑎𝑧ã𝑜 (12)
67
4 ANÁLISE DOS RESULTADOS
A fim de analisar se o sistema de coordenadas atende às especificações de
projeto, alguns ensaios são realizados no mesmo. O detalhamento dos ensaios, bem
como seus resultados, é apresentado a seguir.
4.1 Simulação do algoritmo de interpolação linear
O software ModelSim, ferramenta de simulação desenvolvida pela Mentor
Graphics, é utilizado para simulação funcional e validação de partes do código
desenvolvido em VHDL. Através do mesmo, são geradas formas de onda,
apresentadas na figura 24, que ilustram o comportamento da entidade de projeto
speed_profile. (INTEL, 2017d).
A figura 24 apresenta o resultado dos cálculos, presentes na entidade de
projeto speed_profile, referentes a criação de um perfil de velocidade e interpolação
linear para os motores dos eixos das coordenadas X e Z. Na simulação, os motores
X e Z deslocam 15 e 30 passos, respectivamente, num intervalo de 3000 ps; durante
o tempo de aceleração, de 0 a 1000 ps, o motor do eixo X desloca 5 passos, iniciando
com o passo mais lento de 100 pulsos de referência, e finalizando com o passo mais
rápido de 20 pulsos de referência. A razão entre os passos, na aceleração do motor
X, é de 20, ou seja, cada passo dado para acelerar é 20 pulsos de referência menor
que o anterior; seguindo o mesmo tempo de aceleração, de 0 a 1000 ps, o motor do
eixo Z desloca 10 passos, iniciando com o passo mais lento de 50 pulsos de
referência, e finalizando com o passo mais rápido de 10 pulsos de referência. A razão
entre os passos, na aceleração do motor do eixo Z, é de 4, porém, a razão não é um
resultado inteiro, então, como não existe fração dos pulsos de referência lidos, os
passos no acelerar seguem ora razão de 4 e ora razão de 5. Para situações reais,
onde os valores de razão e tamanho de passo são bem maiores que o simulado, o
arredondamento se torna irrelevante; do instante de 1000 a 2000 ps, os passos para
os motores operam com intervalos de tempo constante, o motor do eixo X desloca 5
passos a cada 20 pulsos de referência e o motor do eixo Z desloca 10 passos a cada
68
10 pulsos de referência; do instante de 2000 a 3000 ps, a desaceleração dos motores
segue a razão inversa da ocorrida na aceleração; a velocidade e o deslocamento do
motor do eixo Z são duas vezes maiores, quando comparados ao motor do eixo X.
Com base na simulação apresentada na figura 24, deduz-se que os cálculos
desenvolvidos na entidade de projeto speed_profile condizem com o comportamento
de uma progressão aritmética para os instantes de aceleração e desaceleração dos
motores. Além disso, a interpolação linear entre os mesmos é perceptível, uma vez
que as acelerações e desacelerações são simultâneas e, durante esse período, a
quantidade de passos dados por cada motor é proporcional ao deslocamento do
mesmo.
4.2 Ensaios de precisão e repetibilidade
Para análise da precisão de posicionamento do sistema de coordenadas X e Z
são estipulados quatro posicionamentos de avanço para ambos os eixos, fazendo com
que os mesmos se desloquem por todo o percurso das coordenadas. Inicialmente, o
eixo Z é deslocado para as posições de 62,50, 125,00, 187,50 e 250,00 mm em
relação à posição de zero máquina. Para cada deslocamento são realizadas cinco
medições diretas da posição de avanço. O instrumento de medição utilizado é um
paquímetro, com resolução de 2 centésimos de milímetro, da marca Mitutoyo. As
indicações obtidas são apresentadas na tabela 5. Conforme apresenta a tabela, a
indicação do paquímetro é a mesma para todas as repetições. Sendo assim, a média
entre as repetições é o próprio valor indicado pelo instrumento de medição, e o desvio
padrão, que expressa o grau de dispersão das indicações obtidas, é zero.
69
Figura 24 – Formas de onda para interpolação linear dos motores
Fonte – O autor (2018)
70
Tabela 5 – Análise de precisão da coordenada Z
Análise de precisão da coordenada Z
Repetição Indicação do instrumento de medição para as posições de:
62,50 mm 125,00 mm 187,50 mm 250,00 mm
1 62,50 125,00 187,50 250,00
2 62,50 125,00 187,50 250,00
3 62,50 125,00 187,50 250,00
4 62,50 125,00 187,50 250,00
5 62,50 125,00 187,50 250,00
Média 62,50 125,00 187,50 250,00
Desvio Padrão 0,000 0,000 0,000 0,000
Fonte: O autor (2018)
A mesma análise pode ser feita para a tabela 6, que apresenta as indicações
obtidas nas medições do posicionamento da coordenada X. Para este caso, o eixo X
é deslocado para as posições de 37,50, 75,00, 112,50 e 150,00 mm em relação à
posição de zero máquina. Para cada deslocamento são realizadas cinco medições
diretas da posição de avanço. O instrumento de medição utilizado é o mesmo
paquímetro utilizado nas medições do eixo Z.
Tabela 6 – Análise de precisão da coordenada X
Análise de precisão da coordenada X
Repetição Indicação do instrumento de medição para as posições de:
37,50 mm 75,00 mm 112,50 mm 150,00 mm
1 37,50 75,00 112,50 150,00
2 37,50 75,00 112,50 150,00
3 37,50 75,00 112,50 150,00
4 37,50 75,00 112,50 150,00
5 37,50 75,00 112,50 150,00
Média 37,50 75,00 112,50 150,00
Desvio Padrão 0,000 0,000 0,000 0,000
Fonte: O autor (2018)
A análise de repetibilidade dos posicionamentos é realizada com a leitura de
relógios comparadores, da marca Mitutoyo, com precisão de 1 centésimo de
71
milímetro. São utilizados quatro relógios comparadores para a medição de avanço e
recuo dos dois eixos. O posicionamento dos mesmos é ilustrado na figura 25.
Figura 25 – Análise de repetibilidade com relógio comparador
Fonte: O autor (2018)
O ensaio de repetibilidade consiste em deslocar os eixos das coordenadas X e
Z, individualmente, para as posições apresentadas nas tabelas 5 e 6. Inicialmente, o
eixo da coordenada Z é deslocado da posição 0,00 mm para a posição 62,50 mm. Ao
atingir a posição de avanço, o relógio comparador (a), responsável por essa indicação,
é ajustado para indicar uma posição de 0,00 mm. Posteriormente, o eixo da
coordenada Z é deslocado para a posição de zero máquina, 0,00 mm. Ao atingir a
posição de recuo, o relógio comparador (b), responsável por essa indicação, é
ajustado para indicar a posição de 0,00 mm. Uma vez ajustadas as posições dos
relógios comparadores, o movimento de avanço e recuo é repetido cinco vezes para
cada uma das condições: velocidade de 200 rpm e aceleração de 0,1 s; velocidade
72
de 200 rpm e aceleração de 0,5 s; velocidade de 400 rpm e aceleração de 0,1 s;
velocidade de 400 rpm e aceleração de 0,5 s; velocidade de 600 rpm e aceleração de
0,1 s; velocidade de 600 rpm e aceleração de 0,5 s; velocidade de 800 rpm e
aceleração de 0,1 s; velocidade de 800 rpm e aceleração de 0,5 s.6 O procedimento,
posteriormente, é realizado também para as outras posições de avanço da
coordenada do eixo Z. Dessa forma, os movimentos de avanço e recuo são repetidos
160 vezes. A tabela 7 apresenta as indicações dos instrumentos de medição para as
condições descritas acima.
Tabela 7 – Repetibilidade do eixo de coordenada Z
Velo
cid
ade
Acele
ração
Repetição
Leitura do Relógio Comparador (resolução de 0,01 mm) - Ajuste inicial em 0,00 mm
62,50 mm 125,00 mm 187,50 mm 250,00 mm
Leitura Relógio Desl.
Total
Leitura Relógio Desl.
Total
Leitura Relógio Desl.
Total
Leitura Relógio Desl.
Total Avanço Recuo Avanço Recuo Avanço Recuo Avanço Recuo
200 r
pm
0,1
s
1 0,00 0,00 62,50 0,00 0,00 125,00 0,00 0,00 187,50 0,00 0,00 250,00
2 0,00 0,00 62,50 0,00 0,00 125,00 0,00 0,00 187,50 0,00 0,00 250,00
3 0,00 0,00 62,50 0,00 0,00 125,00 0,00 0,00 187,50 0,00 0,00 250,00
4 0,00 0,00 62,50 0,00 0,00 125,00 0,00 0,00 187,50 0,00 0,00 250,00
5 0,00 0,00 62,50 0,00 0,00 125,00 0,00 0,00 187,50 0,00 0,00 250,00
Média 62,500 Média 125,000 Média 187,500 Média 250,000
Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,000
0,5
s
1 0,00 0,00 62,50 0,00 0,00 125,00 0,00 0,00 187,50 0,00 0,00 250,00
2 0,00 0,00 62,50 0,00 0,00 125,00 0,00 0,00 187,50 0,00 0,00 250,00
3 0,00 0,00 62,50 0,00 0,00 125,00 0,00 0,00 187,50 0,00 0,00 250,00
4 0,00 0,00 62,50 0,00 0,00 125,00 0,00 0,00 187,50 0,00 0,00 250,00
5 0,00 0,00 62,50 0,00 0,00 125,00 0,00 0,00 187,50 0,00 0,00 250,00
Média 62,500 Média 125,000 Média 187,500 Média 250,000
Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,000
400 r
pm
0,1
s
1 0,00 0,01 62,51 0,00 0,01 125,01 0,00 0,00 187,50 0,00 0,00 250,00
2 0,00 0,01 62,51 0,00 0,01 125,01 0,00 0,00 187,50 0,00 0,00 250,00
3 0,00 0,01 62,51 0,00 0,01 125,01 0,00 0,00 187,50 0,00 0,00 250,00
4 0,00 0,01 62,51 0,00 0,01 125,01 0,00 0,00 187,50 0,01 0,00 250,01
5 0,00 0,01 62,51 0,00 0,01 125,01 0,00 0,00 187,50 0,01 0,00 250,01
Média 62,510 Média 125,010 Média 187,500 Média 250,004
Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,005
6 As velocidades variam da menor à maior velocidade de usinagem, considerando as especificações de projeto; o teste com diferentes acelerações tem o intuito de verificar o comportamento do algoritmo desenvolvido.
73
0,5
s
1 0,00 0,01 62,51 0,00 0,01 125,01 0,00 0,00 187,50 0,01 0,00 250,01
2 0,00 0,01 62,51 0,00 0,01 125,01 0,00 0,00 187,50 0,01 0,00 250,01
3 0,00 0,01 62,51 0,00 0,01 125,01 0,00 0,00 187,50 0,01 0,00 250,01
4 0,00 0,01 62,51 0,00 0,01 125,01 0,00 0,00 187,50 0,01 0,00 250,01
5 0,00 0,01 62,51 0,00 0,01 125,01 0,00 0,00 187,50 0,01 0,00 250,01
Média 62,510 Média 125,010 Média 187,500 Média 250,010
Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,000
600 r
pm
0,1
s
1 0,00 0,01 62,51 0,00 0,01 125,01 0,00 0,00 187,50 0,01 0,00 250,01
2 0,00 0,01 62,51 0,00 0,01 125,01 0,00 0,00 187,50 0,01 0,00 250,01
3 0,00 0,01 62,51 0,00 0,01 125,01 0,00 0,00 187,50 0,01 0,00 250,01
4 0,00 0,01 62,51 0,00 0,01 125,01 0,00 0,00 187,50 0,01 0,00 250,01
5 0,00 0,01 62,51 0,00 0,01 125,01 0,00 0,00 187,50 0,01 0,00 250,01
Média 62,510 Média 125,010 Média 187,500 Média 250,010
Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,000
0,5
s
1 0,00 0,01 62,51 0,00 0,01 125,01 0,00 0,00 187,50 0,01 -0,01 250,00
2 0,00 0,01 62,51 0,00 0,01 125,01 0,00 0,00 187,50 0,01 -0,01 250,00
3 0,00 0,01 62,51 0,00 0,01 125,01 0,00 0,00 187,50 0,01 -0,01 250,00
4 0,00 0,01 62,51 0,00 0,01 125,01 0,00 0,00 187,50 0,01 -0,01 250,00
5 0,00 0,01 62,51 0,00 0,01 125,01 0,00 0,00 187,50 0,01 -0,01 250,00
Média 62,510 Média 125,010 Média 187,500 Média 250,000
Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,000
800 r
pm
0,1
s
1 -0,01 0,01 62,50 -0,01 0,01 125,00 0,00 0,00 187,50 0,01 -0,01 250,00
2 -0,01 0,01 62,50 -0,01 0,01 125,00 0,00 0,00 187,50 0,01 -0,01 250,00
3 -0,01 0,01 62,50 -0,01 0,01 125,00 0,00 0,00 187,50 0,01 -0,01 250,00
4 -0,01 0,01 62,50 -0,01 0,01 125,00 0,00 0,00 187,50 0,01 -0,01 250,00
5 -0,01 0,01 62,50 -0,01 0,01 125,00 0,00 0,00 187,50 0,01 -0,01 250,00
Média 62,500 Média 125,000 Média 187,500 Média 250,000
Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,000
0,5
s
1 -0,01 0,01 62,50 -0,01 0,01 125,00 -0,01 0,00 187,49 0,01 -0,01 250,00
2 -0,01 0,01 62,50 -0,01 0,01 125,00 0,00 0,00 187,50 0,01 -0,01 250,00
3 -0,01 0,01 62,50 -0,01 0,01 125,00 0,00 0,00 187,50 0,01 -0,01 250,00
4 -0,01 0,01 62,50 -0,01 0,01 125,00 -0,01 0,00 187,49 0,01 -0,01 250,00
5 -0,01 0,01 62,50 -0,01 0,01 125,00 0,00 0,00 187,50 0,01 -0,01 250,00
Média 62,500 Média 125,000 Média 187,496 Média 250,000
Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,005 Desvio Padrão 0,000
Anális
e d
o E
rro
Média 62,505 Média 125,005 Média 187,500 Média 250,003
Desvio Padrão 0,005 Desvio Padrão 0,005 Desvio Padrão 0,001 Desvio Padrão 0,004
Tendência 0,005 Tendência 0,005 Tendência 0,000 Tendência 0,003
Repetibilidade ±0,012 Repetibilidade ±0,012 Repetibilidade ±0,003 Repetibilidade ±0,010
Erro Positivo 0,02 Erro Positivo 0,02 Erro Positivo 0,01 Erro Positivo 0,02
Erro Negativo -0,01 Erro Negativo -0,01 Erro Negativo -0,01 Erro Negativo -0,01
Fonte: O autor (2018)
74
De acordo com a tabela 7, a variação na indicação do relógio comparador, ao
decorrer das repetições, chega a 0,01 mm. Quando este valor é positivo, indica que o
eixo deslocou a mais do ajustado inicialmente (avançou a mais que a posição de
avanço ou recuou a mais que a posição de recuo), quando o valor é negativo, indica
que o eixo deslocou a menos do ajustado inicialmente. Dessa forma, é calculada a
média e o desvio padrão para cada uma das combinações entre distância, velocidade
e aceleração. Com isso, tem-se um panorama do comportamento do sistema de
coordenadas para diferentes condições de operação.
Além disso, com base nas medições realizadas, a tabela 7 apresenta os dados
relacionados ao erro máximo de posicionamento para cada uma das distâncias
testadas. Ou seja, é possível comparar o erro de posicionamento entre as distâncias
de 62,50, 125,00, 187,50 e 250,00 mm e verificar irregularidades na construção
mecânica e motorização do sistema de coordenadas.
Na análise do erro, ainda apresentada pela tabela 7, a média da posição é
obtida considerando as médias entre todas as combinações de velocidade e
aceleração para a distância analisada; a tendência indica uma estimativa do erro
sistemático (parcela previsível do erro), ou seja, é o erro obtido da diferença entre a
média das indicações e o valor de referência (valor verdadeiro convencional); já a
repetibilidade indica uma estimativa do erro aleatório (parcela imprevisível do erro),
proporcional ao número de medições repetidas e ao grau de dispersão entre as
indicações das medições (desvio padrão); o erro positivo do posicionamento é a soma
da tendência e da repetibilidade; o erro negativo é a diferença obtida da subtração
entre a tendência e a repetibilidade; o erro máximo é o maior valor em módulo do erro
que pode ser cometido pelo sistema de coordenadas nas condições em que foi
avaliado (ALBERTAZZI; SOUZA, 2008).
O erro máximo, para o posicionamento do eixo da coordenada Z, conforme
mostrado na tabela 7, é de 0,02 mm. Esse erro é inferior a 0,03 mm, especificado
como valor máximo de tolerância para o projeto. Dessa forma, a construção mecânica
do sistema de coordenadas para o eixo Z, e seu comportamento para diferentes
condições de velocidades e acelerações, atende as especificações estabelecidas para
o projeto. A figura 26 apresenta a curva de erros no posicionamento do eixo Z, a
75
mesma, representa a distribuição dos erros sistemáticos e aleatórios ao longo da faixa
de medição.
Figura 26 – Curva de Erros da Coordenada Z
Fonte: O autor (2018)
A análise para o eixo da coordenada X é análoga à coordenada Z. Os testes
são realizados para as posições de 37,50, 75,00, 112,50 e 150,00 mm, para as
velocidades de 200, 400, 600 e 800 rpm e para as acelerações de 0,1 e 0,5 s. As
indicações dos instrumentos de medição para todas as combinações possíveis entre
as variáveis apresentadas são dispostas na tabela 8.
-0,015
-0,010
-0,005
0,000
0,005
0,010
0,015
0,020
62,50 mm 125,00 mm 187,50 mm 250,00 mm
Err
o C
oo
rdenada Z
(m
m)
76
Tabela 8 – Repetibilidade do eixo de coordenada X V
elo
cid
ade
Acele
ração
Repetição
Leitura do Relógio Comparador (resolução de 0,01 mm) - Ajuste inicial em 0,00 mm
37,50 mm 75,00 mm 112,50 mm 150,00 mm
Leitura Relógio Desl.
Total
Leitura Relógio Desl.
Total
Leitura Relógio Desl.
Total
Leitura Relógio Desl.
Total Avanço Recuo Avanço Recuo Avanço Recuo Avanço Recuo
200 r
pm
0,1
s
1 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,00 112,50 0,00 0,00 150,00
2 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,00 112,50 0,00 0,00 150,00
3 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,00 112,50 0,00 0,00 150,00
4 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,00 112,50 0,00 0,00 150,00
5 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,00 112,50 0,00 0,00 150,00
Média 37,500 Média 75,000 Média 112,500 Média 150,000
Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,000
0,5
s
1 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,00 112,50 0,00 0,00 150,00
2 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,00 112,50 0,00 0,00 150,00
3 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,00 112,50 0,00 0,00 150,00
4 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,00 112,50 0,00 0,00 150,00
5 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,00 112,50 0,00 0,00 150,00
Média 37,500 Média 75,000 Média 112,500 Média 150,000
Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,000
400 r
pm
0,1
s
1 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,00 112,50 0,00 0,00 150,00
2 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,01 112,51 0,01 0,00 150,01
3 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,01 112,51 0,00 0,00 150,00
4 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,01 112,51 0,00 -0,01 149,99
5 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,01 112,51 0,00 0,00 150,00
Média 37,500 Média 75,000 Média 112,508 Média 150,000
Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,004 Desvio Padrão 0,006
0,5
s
1 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,01 112,51 0,00 0,00 150,00
2 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,01 112,51 0,01 -0,01 150,00
3 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,01 112,51 0,00 -0,01 149,99
4 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,01 112,51 0,01 0,00 150,01
5 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,01 112,51 0,00 0,00 150,00
Média 37,500 Média 75,000 Média 112,510 Média 150,000
Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,006
600 r
pm
0,1
s
1 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,01 112,51 0,01 -0,01 150,00
2 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,01 112,51 0,01 -0,01 150,00
3 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,01 112,51 0,01 -0,01 150,00
4 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,01 112,51 0,01 -0,01 150,00
5 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,01 112,51 0,01 -0,01 150,00
Média 37,500 Média 75,000 Média 112,510 Média 150,000
Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,000
0,5
s
1 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,01 112,51 0,01 -0,01 150,00
2 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,01 112,51 0,00 -0,01 149,99
3 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,01 112,51 0,00 -0,01 149,99
77
4 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,01 112,51 0,00 -0,01 149,99
5 0,00 0,00 37,50 0,00 0,00 75,00 0,00 0,01 112,51 0,01 -0,01 150,00
Média 37,500 Média 75,000 Média 112,510 Média 149,994
Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,005
800 r
pm
0,1
s
1 0,00 0,00 37,50 0,00 -0,01 74,99 0,00 0,01 112,51 0,01 -0,01 150,00
2 0,01 0,00 37,51 0,00 -0,01 74,99 0,00 0,01 112,51 0,00 -0,01 149,99
3 0,01 0,00 37,51 0,00 -0,01 74,99 0,00 0,01 112,51 0,00 -0,01 149,99
4 0,01 0,00 37,51 0,00 -0,01 74,99 0,00 0,00 112,50 0,00 -0,01 149,99
5 0,01 0,00 37,51 0,00 -0,01 74,99 0,00 0,00 112,50 0,00 -0,01 149,99
Média 37,508 Média 74,990 Média 112,506 Média 149,992
Desvio Padrão 0,004 Desvio Padrão 0,000 Desvio Padrão 0,005 Desvio Padrão 0,004
0,5
s
1 0,00 0,00 37,50 0,00 -0,01 74,99 -0,01 0,00 112,49 0,00 -0,01 149,99
2 0,00 0,00 37,50 0,00 -0,01 74,99 -0,01 0,00 112,49 0,00 -0,01 149,99
3 0,01 0,00 37,51 0,00 -0,01 74,99 -0,01 0,00 112,49 0,00 -0,01 149,99
4 0,01 0,00 37,51 0,00 -0,01 74,99 -0,01 0,00 112,49 0,00 -0,01 149,99
5 0,00 0,00 37,50 0,00 -0,01 74,99 -0,01 0,00 112,49 0,00 -0,01 149,99
Média 37,504 Média 74,990 Média 112,490 Média 149,990
Desvio Padrão 0,005 Desvio Padrão 0,000 Desvio Padrão 0,000 Desvio Padrão 0,000
Anális
e d
o E
rro
Média 37,502 Média 74,998 Média 112,504 Média 149,997
Desvio Padrão 0,003 Desvio Padrão 0,004 Desvio Padrão 0,007 Desvio Padrão 0,004
Tendência 0,002 Tendência -0,002 Tendência 0,004 Tendência -0,003
Repetibilidade ±0,007 Repetibilidade ±0,011 Repetibilidade ±0,016 Repetibilidade ±0,010
Erro Positivo 0,01 Erro Positivo 0,01 Erro Positivo 0,02 Erro Positivo 0,01
Erro Negativo -0,01 Erro Negativo -0,02 Erro Negativo -0,01 Erro Negativo -0,02
Fonte: O autor (2018)
O erro máximo para o posicionamento do eixo da coordenada X, conforme
mostrado na tabela 8, é de 0,02 mm. Esse erro é inferior a 0,03 mm, especificado
como valor máximo de tolerância para o projeto. Dessa forma, a construção mecânica
do sistema de coordenadas para o eixo X, e seu comportamento para diferentes
condições de velocidades e acelerações, atende as especificações estabelecidas para
o projeto. A figura 27 apresenta a curva de erros no posicionamento do eixo X, a
mesma, representa a distribuição dos erros sistemáticos e aleatórios ao longo da faixa
de medição.
Com base nas indicações obtidas e, de acordo com as análises realizadas,
conclui-se que o sistema de coordenadas satisfaz as especificações estabelecidas de
precisão e repetibilidade para ambos os eixos. O sistema pode ser considerado
preciso, pois há uma boa repetição nas posições e pequena dispersão entre as
78
indicações. Além disso, o sistema apresenta excelente exatidão, sendo que sua curva
de erros apresenta valores inferiores aos estabelecidos pelas especificações de
projeto.
Figura 27 – Curva de Erros da Coordenada X
Fonte: O autor (2018)
4.3 Análise da trajetória da ferramenta
A fim de testar os cálculos de interpolação, simulados na seção 4.1, são
realizados deslocamentos que reproduzem os processos de torneamento transversal
(deslocamento em X), torneamento longitudinal (deslocamento em Z) e torneamento
bidirecional cartesiano (deslocamento de X e Z). Para tanto, é definida uma trajetória
na forma de um octógono regular (figura 28), composto por lados de 5 mm. A
sequência de operação inicia pelo lado 1 do polígono e finaliza pelo lado 8, sendo que
a posição final no ponto cartesiano é a mesma do início da trajetória. Com base na
figura, tem-se que: os lados 1 e 5 reproduzem o processo de torneamento longitudinal,
-0,025
-0,020
-0,015
-0,010
-0,005
0,000
0,005
0,010
0,015
0,020
37,50 mm 75,00 mm 112,50 mm 150,00 mm
Err
o C
oo
rde
na
da
X (
mm
)
79
os lados 3 e 7 reproduzem o processo de torneamento transversal e os lados 2, 4, 6
e 8 reproduzem o processo de torneamento bidirecional.
Figura 28 – Octógono regular com lados de 5 mm
Fonte: O autor (2018)
A tabela 9 exibe os resultados dos cálculos da trajetória para uma condição
onde a velocidade da ferramenta seja de 0,2 mm/rotação e a rotação do eixo árvore
seja de 10000 rpm. Para essa velocidade, duas situações são analisadas:
I. aceleração e desaceleração de 0,1 s: aqui, para todos os movimentos, a soma
dos passos necessários para acelerar e desacelerar é menor que a quantidade de
passos totais dados pelos motores, nesse caso, o motor leva 0,1 s para acelerar do
tamanho de passo mais lento ao tamanho de passo nominal, então, opera com
velocidade nominal (tamanho passo nominal) e, finalmente, desacelera ao tamanho
de passo mais lento, no período de 0,1 s;
II. aceleração e desaceleração de 0,5 s: aqui, para todos os movimentos, a soma
dos passos necessários para acelerar e desacelerar é maior que a quantidade de
passos totais dados pelos motores, nesse caso, o motor não chega a atingir a
velocidade nominal (definida pelo tamanho de passo nominal), mas sim, mantém uma
aceleração constante, até atingir a metade do total de passos e, então, desacelera.
12
3
4
5
6
7
8
5 mmZ
X
80
Tabela 9 – Resultados de cálculos para interpolação linear
Velo
cid
ade
Acele
ração
Torneamento
Transversal
Torneamento
Bidirecional Cartesiano
Torneamento
Longitudinal
Movimento em Z (lados 1 e 5)
Movimento em X e Z (lados 2, 4, 6 e 8)
Movimento em X (lados 3 e 7)
400 r
pm
0,1
s
Total de passos em X 0 283 400
Tamanho passo nominal X (clk) 0 26385 18657
Tamanho passo mais lento X (clk) 0 79154 55970
Passos para acelerar em X 0 95 134
Passos para desacelerar em X 0 95 134
Razão X 0 563 281
Total de passos em Z 400 283 0
Tamanho passo nominal Z (clk) 18657 26385 0
Tamanho passo mais lento Z (clk) 55970 79154 0
Passos para acelerar em Z 134 95 0
Passos para desacelerar em Z 134 95 0
Razão Z 281 563 0
Passos Ferramenta 400 400 400
Pulsos de clk p/ aceleração 5000000 5000000 5000000
Pulsos de clk p/ desaceleração 5000000 5000000 5000000
0,5
s
Total de passos em X 0 283 400
Tamanho passo nominal X (clk) 0 26385 18657
Tamanho passo mais lento X (clk) 0 79154 55970
Passos para acelerar em X 0 474 670
Passos para desacelerar em X 0 474 670
Razão X 0 112 56
Total de passos em Z 400 283 0
Tamanho passo nominal Z (clk) 18657 26385 0
Tamanho passo mais lento Z (clk) 55970 79154 0
Passos para acelerar em Z 670 474 0
Passos para desacelerar em Z 670 474 0
Razão Z 56 112 0
Passos Ferramenta 400 400 400
Pulsos de clk p/ aceleração 25000000 25000000 25000000
Pulsos de clk p/ desaceleração 25000000 25000000 25000000
Fonte: O autor (2018)
81
O dispositivo High Speed, no qual é utilizado o sistema de coordenadas ora
desenvolvido, ainda se encontra em fase de construção, portanto, o ferramental para
usinagem ainda não está disponível para o protótipo. Sendo assim, para análise da
trajetória, é utilizado um parafuso preso ao sistema de coordenadas, o qual risca uma
chapa pintada com tinta de traçagem. Para que o parafuso possa deslizar sobre a
chapa sem muita pressão, o mesmo é fixo à base com mola de um relógio
comparador. A ferramenta construída para os testes é apresentada na figura 29.
Figura 29 – Ferramenta construída para testes
Fonte: O autor (2018)
82
A figura 30 apresenta as trajetórias percorridas pela ferramenta de teste. Os
octógonos 1 a 3 são resultados da situação onde a aceleração e desaceleração são
ajustadas para 0,1 s, já os octógonos 4 a 6 são resultados da situação onde a
aceleração e desaceleração são ajustadas para 0,5 s.
A imagem apresentada na figura 30, em escala de cinza, é obtida com uma
câmera, da marca Olympus, e uma lente plana cromática que apresenta um aumento
de 10 vezes. O traço da ferramenta é comparado com um octógono padrão, na cor
vermelha. Conforme pode ser observado nas imagens, a espessura do traço da
ferramenta varia minimamente, ora mais grosso, ora mais fino. A possível fonte desse
erro é a ferramenta utilizada. Sabe-se que essa não é uma ferramenta ideal, por ora,
foi a solução encontrada para análise do deslocamento da ferramenta. De forma geral,
para as duas situações de aceleração e desaceleração, observa-se na figura 30 que
o deslocamento da ferramenta é similar para todos os movimentos apresentados na
tabela 9. Sendo assim, conclui-se que os cálculos de interpolação linear entre os eixos
das coordenadas X e Z garantem a mesma resposta, independente dos valores de
aceleração e desaceleração utilizados. Para uma análise mais precisa do
deslocamento da ferramenta é necessário a utilização de uma ferramenta de teste
mais confiável.
4.4 Leitura da corrente dos motores
Conforme especificado anteriormente, o motor utilizado no acionamento, para
ambos os eixos das coordenadas, opera com até 5 ampères por fase. Os drives de
potência dos motores são ajustados para que os mesmos trabalhem com 5,14 A
(tabela 4). A medição da corrente, em cada fase dos motores, é realizada com a
utilização de um osciloscópio, da marca Tektronix, modelo TDS 2022B. Para tanto,
são utilizadas duas ponteiras de corrente, uma para cada fase do motor, ambas da
marca Tektronix, modelo A622, ajustadas na relação 100 mV/A – para cada ampère
medido, o osciloscópio indica 100 mV.
83
Figura 30 – Trajetória percorrida pela ferramenta de teste
Fonte: O autor (2018)
84
A medição da corrente dos motores é realizada quando os mesmos operam a
vazio (sem carga) e também com a simulação de carga, utilizando um bloco padrão
de 100 kg sobre o sistema de coordenadas. A figura 31 ilustra a medição da corrente
nas fases do motor que aciona o eixo X, quando o mesmo se desloca com carga.
Figura 31 – Leitura de corrente no motor X
Fonte: O autor (2018)
A figura 32 indica a medição da corrente do motor do eixo da coordenada X
para uma velocidade de 200 rpm. Conforme visto na mesma, o comportamento da
corrente é similar quando o motor opera a vazio (a) ou com carga (b). Na leitura (a), o
canal CH1 apresenta um valor máximo de 512 mV, correspondente a 5,12 A. Na leitura
(b), o canal CH1 apresenta o mesmo valor de 512 mV, também correspondente a 5,12
A. Dessa forma, verifica-se que o ajuste de corrente em 5,14 A, realizado pelo drive
de potência, atende os requisitos de projeto para situações com e sem carga.
85
Além disso, pode-se observar na figura 32 que as ondas, as quais representam
a corrente nas fases do motor, estão defasadas, uma da outra, em 90 graus e levam
6 ms para executar um ciclo completo. E também, durante um ciclo, são observados
8 degraus de corrente para cada uma das ondas, onde, cada degrau equivale a um
passo no motor. Esse comportamento é característico de motores de passo, quando
os mesmos operam no modo meio passo com correção de corrente7. Considerando
que o motor rotaciona 8 passos em 6 ms e que são necessários 400 passos para que
o mesmo rotacione uma volta completa, a leitura da corrente confirma que o motor
está operando a 200 rpm.
Figura 32 – Corrente no motor da coordenada X
(a) – sem carga (b) – com carga
Fonte: O autor (2018)
A mesma análise pode ser feita para a figura 33. A figura ilustra o
comportamento da corrente no motor que aciona o eixo da coordenada Z. Conforme
visto na mesma, o comportamento da corrente é similar quando o motor opera a vazio
(a) ou com carga (b). Na leitura (a), o canal CH1 apresenta um valor máximo de 512
mV, correspondente a 5,12 A. Na leitura (b), o canal CH1 apresenta o mesmo valor
7 A correção de corrente consiste em elevar a corrente em 40% quando somente uma fase está energizada, dessa forma, a corrente mais alta nesse estado produz um torque aproximadamente igual ao torque produzido quando duas fases estão energizadas (PARKER, 2003).
86
de 512 mV, também correspondente a 5,12 A. Dessa forma, verifica-se que o ajuste
de corrente em 5,14 A, realizado pelo drive de potência, atende os requisitos de
projeto para situações com e sem carga.
Figura 33 – Corrente no motor da coordenada Z
(a) – sem carga (b) – com carga
Fonte: O autor (2018)
87
5 CONCLUSÃO
O emprego de FPGAs em dispositivos de controle de motores de precisão é
algo presente nas soluções apresentadas por fabricantes da área de movimentação
de eixos e, também, por pesquisadores acadêmicos. A complexidade dos circuitos
implementados em FPGAs requer a utilização de linguagens de descrição de
hardware, a fim de facilitar o entendimento dos mesmos. Nesse sentido, o estudo das
características de FPGAs e o entendimento da sintaxe da linguagem VHDL,
contribuem para o desenvolvimento de soluções tecnológicas para produtos
mecatrônicos.
Partindo dessa premissa, esse trabalho resgatou a cronologia dos dispositivos
lógicos programáveis e sintetizou a interpretação da linguagem VHDL, a fim de
embasar o uso do FPGA MAX 10 e da placa didática DE10-LITE como uma solução
lógica digital para o controle de movimentação e posicionamento de motores de
precisão.
Para tanto, a metodologia abordada baseou-se no modelo PRODIP, mais
precisamente, em sua etapa de projetação de produto. Através da segmentação do
modelo, foi possível levantar os requisitos de projeto, definir uma concepção para o
produto e fabricar o protótipo. O estudo de concepção de produto levou a análise de
duas propostas para a motorização dos eixos das coordenadas X e Z: servomotor e
motor de passo. Nessa análise, ambos apresentaram excelente resposta técnica,
garantindo a precisão exigida pelo projeto, porém, devido ao custo, o motor de passo
foi utilizado. A estruturação da metodologia utilizada foi essencial para que a ideia
proposta se tornasse factível.
Um sinal de 50 MHz, oriundo da placa DE10-LITE, foi utilizado como referência
para um perfil de velocidade e posicionamento de motores de passo. Quando em
modo manual ou na busca de zero máquina, os motores operam de forma
independente um do outro e a velocidade dos mesmos é definida nos respectivos
blocos apresentados no capítulo 3. Já em modo automático, um perfil de velocidade
é definido, a fim de estabelecer sincronismo de posicionamento entre os motores.
88
Sendo assim, as rampas de aceleração são definidas seguindo uma progressão
aritmética, calculada no bloco speed_profile, também apresentado no capítulo 3.
Os resultados do cálculo de sincronismo foram simulados no software
ModelSim e apresentam coerência com os valores de referência. Posteriormente, a
validação dos mesmos foi feita através da construção de polígonos, onde se analisa
a trajetória da ferramenta para diferentes situações de aceleração e desaceleração.
O ensaio apresentou um resultado positivo e indica que o algoritmo de interpolação
linear atende as especificações de projeto, uma vez que se obtem a mesma resposta
no deslocamento da ferramenta, independente dos valores de aceleração e
desaceleração utilizados.
Os ensaios de precisão e repetibilidade indicaram que o erro máximo no
posicionamento do sistema de coordenadas é de 0,02 mm. Esse valor é inferior a 0,03
mm, estabelecido pelo projeto. Dessa forma, conclui-se que o sistema mecânico e o
controle de movimentação dos motores satisfazem as especificações estabelecidas
de precisão e repetibilidade para ambos os eixos. O sistema pode ser considerado
preciso, pois há uma boa repetição nas posições e pequena dispersão entre as
indicações. Além disso, o sistema apresenta excelente exatidão, sendo que sua curva
de erros (seção 4.2) apresenta valores inferiores aos estabelecidos pelas
especificações de projeto.
As trajetórias executadas pela ferramenta durante os ensaios foram salvas em
memória RAM. O bloco de memória RAM foi desenvolvido em VHDL e possibilita a
criação de trajetórias com até 32 posições de deslocamento da ferramenta.
O código responsável pelo controle de movimentação dos motores foi
segmentado em blocos e apresentado no capítulo 3. O mesmo está disponível a
usuários que, por ventura, venham utiliza-lo para atividades de ensino e projetos de
pesquisa. Para o projeto ora desenvolvido, sugere-se como implementação futura o
desenvolvimento de um sistema de supervisão e interface com o usuário, para que
haja maior interatividade e operacionalidade. Além disso, propõe-se que a análise da
trajetória da ferramenta, apresentada na seção 4.3, seja refeita com o ferramental
específico da máquina, logo que o mesmo esteja disponível.
89
Com base nos estudos realizados e, de acordo com os resultados obtidos,
conclui-se que o controlador desenvolvido atende a especificações de máquinas de
usinagem que utilizam motores de passo na motorização de seus eixos. Além disso,
pretende-se aprofundar os estudos iniciados com essa dissertação de mestrado. O
conhecimento produzido até aqui, na área de dispositivos lógicos programáveis e suas
aplicabilidades, enriquece as atividades de ensino no IFSC – Chapecó e tende a gerar
novos projetos de pesquisa.
90
REFERÊNCIAS
ALBERTAZZI G. Jr, A.; SOUZA, A. R. de; Fundamentos de Metrologia Científica e
Industrial. Florianópolis: Manole, 2008. 407 p.
ARTSOFT. Mach3 CNC Controller Software Installation and Configuration. Disponível em: <http://www.machsupport.com/help-learning/product-manuals/>
Acesso em: 12 de março de 2018.
BARBOSA, P. A..; Estudo Do Comportamento Mecânico Na Usinagem De Aços
Inoxidaveis. 2014. Tese De Doutorado. Escola Politecnica Da Universidade De São
Paulo, 2014.
BECKHOFF. Ultra compacto: O versátil sistema de servo multi-eixos. Beckhoff,
catálogo de produtos, 2018. Disponível em: <
https://download.beckhoff.com/download/document/Catalog/Beckhoff_AX8000_br.pd
f>. Acesso em: 20 de novembro de 2018.
BHATT, D. B.; MORE, H. R. CNC Machine Controller Using FPGA. International
Journal of Review in Electronics & Communication Engineering, VOL. 2, n. 1, p. 48-
51, fev. 2014.
CARRICA, D.; FUNES, M. A.; GONZÁLEZ, S. A. Novel Stepper Motor Controller Based on FPGA Hardware Implementation. IEEE/ASME TRANSACTIONS ON
MECHATRONICS, V. 8, n. 1, p. 120-124, mar. 2003.
COMPOSUL. Datasheet de produto – AKDMP16-7.2A. Composul, 2018. Disponível em: <http://composul.com.br/produtos/drive-motor-de-passo/>. Acesso
em: 09 de novembro de 2018.
CHO, J. U.; LE, Q. N.; JEON, J. W. An FPGA-Based Multiple-Axis Motion Control Chip. IEEE TRANSACTIONS ON INDUSTRIAL ELECTRONICS, V. 56, n. 3, p. 856-
870, mar. 2009.
D’AMORE, R.; VHDL: descrição e síntese de circuitos digitais. 2ª edição. Rio de
Janeiro: LTC, 2012. 292 p.
91
FANUC. CNC: Functions, Communication and Software. Disponível em:
<https://www.fanucamerica.com/home/products-services/cnc> Acesso em: 12 de
março de 2018.
FLOYD, T. L.; Sistemas Digitais: Fundamentos e Aplicações. Trad. Sob a direção
de José Lucimar do Nascimento. 9ª edição. Porto Alegre: Bookman, 2007. 888 p.
INTEL. ADC Controller for DE-series Board. Intel Corporation - FPGA University
Program, 2018. Disponível em: < ftp://ftp.intel.com/Pub/fpgaup/pub/Intel_Material/17.0/University_Program_IP_Cores/I
nput_Output/>. Acesso em: 09 de agosto de 2018.
______. Intel FPGA Integer Arithmetic IP Cores User Guide. Intel Corporation - FPGA University Program, 2017a. Disponível em: <https://www.intel.com/content/dam/altera-
www/global/en_US/pdfs/literature/ug/ug_lpm_alt_mfug.pdf>. Acesso em: 09 de
agosto de 2018.
______. INTEL MAX 10 FPGA Device Overview. Intel FPGA, 2017b. Disponível em: <https://www.intel.com/content/dam/altera-
www/global/en_US/pdfs/literature/hb/max-10/m10_overview.pdf>. Acesso em: 28 de
julho de 2018.
______. MAX 10 FPGA Device Architecture. Intel FPGA, 2017c. Disponível em: < https://www.intel.com/content/dam/altera-www/global/en_US/pdfs/literature/hb/max-
10/m10_architecture.pdf>. Acesso em: 28 de julho de 2018.
______. Quartus Prime Introduction Using Schematic Designs. Intel Corporation - FPGA University Program, 2016a. Disponível em: <ftp://ftp.intel.com/Pub/fpgaup/pub/Intel_Material/17.0/Tutorials/Schematic/>. Acesso
em: 30 de julho de 2018.
______. Using ModelSim to Simulate Logic Circuits in VHDL Designs. Intel, 2017d. Disponível em: <
ftp://ftp.intel.com/Pub/fpgaup/pub/Intel_Material/17.0/Tutorials/VHDL/>. Acesso em:
27 de novembro de 2018.
92
______. Using TimeQuest Timing Analyzer. Intel Corporation - FPGA University
Program, 2016b. Disponível em: < ftp://ftp.intel.com/Pub/fpgaup/pub/Intel_Material/16.1/Tutorials/VHDL/>. Acesso em:
08 de agosto de 2018.
KALATEC. Dicas para aplicação de motor de passo. Kalatec, 2018. Disponível
em: <http://www.kalatec.com.br/dicas-para-aplicacao-de-motor-de-passo/>. Acesso
em: 09 de novembro de 2018.
KING, R. I.; Handbook of High Speed Machining Technology. Nova York:
Chapman and Hall, 1985. 468 p.
KUNG, Y. S.; LIN, J. M.; CHEN, Y. J.; CHOU, H. H. ModelSim/Simulink Cosimulation and FPGA Realization of a Multiaxis Motion Controller. Hindawi Publishing Corporation Mathematical Problems in Engineering, VOL. 2015, p. 1-17,
2015.
LE, Y.; CHU, W.; A New Non-Restoring Square Root Algorithm and Its VLSI Implementations. International Conference on Computer Design, p. 538-544, out.
1996.
MORELO, F.; Análise da influência do mandrilhamento na integridade
superficial do aço inoxidável Super Duplex. 2016. Dissertação de mestrado. Programa De Pós-Graduação Em Engenharia Mecânica e de Materiais,
Universidade Tecnológica Federal Do Paraná, 2016.
OGLIARI, A.; Modelo PRODIP. Disponível em: <
http://emc5302.ogliari.prof.ufsc.br/artigo/modelo-prodip>. Acesso em 15 de agosto
de 2018.
PARKER. Tecnologia Eletromecânica. Parker, 2003. Disponível em:
<https://www.parker.com/literature/Brazil/eletromecanica.pdf>. Acesso em: 09 de
novembro de 2018.
PEDRONI, V. A.; Eletrônica Digital Moderna e VHDL. Trad. Sob a direção de
Arlete Simille Marques. Rio de Janeiro: Elsevier, 2010. 619 p.
93
PRADO, M. A. M.; RESÉNDIZ, J. R.; PÉREZ, D. C. T.; HERNÁNDEZ, C. M. T.;
RUIZ, G. H. Motion Control with FPGA. Intech Open Science, VOL. 2017, n. 3, p.
57-82, mai. 2017.
SEW. Instruções de operação: Servoconversor de múltiplos eixos MOVIAXIS.
SEW, manual de operações, 2011. Disponível em: < https://download.sew-
eurodrive.com/download/pdf/19305397.pdf>. Acesso em: 20 de novembro de 2018.
TERASIC. DE10-Lite User Manual. Terasic, 2018. Disponível em: < http://www.terasic.com.tw/cgi-bin/page/archive.pl?Language=English&CategoryNo=218&No=1021&PartNo=4>.
Acesso em: 28 de julho de 2018.
TOCCI, R. J.; WIDMER, N. S.; MOSS, G. L.; Sistemas Digitais: Princípios e Aplicações. Trad. Sob a direção de Jorge Ritter. 11ª edição. São Paulo: Pearson
Prentice Hall, 2011. 817 p.
WEG. Servoconversor SCA06: Manual de operação. WEG, manual de operação,
2015. Disponível em: < https://static.weg.net/medias/downloadcenter/hda/h65/WEG-
sca06-manual-de-programacao-10000662686-1.4x-manual-portugues-br.pdf >.
Acesso em: 20 de novembro de 2018.
YU, Z.; GUO, G. Stepping Motor Subdividing Drive System Design Based on FPGA. Telecommunication Computing Electronics and Control, VOL. 11, n. 8, p.
4447-4452, ago. 2013.
94
APÊNDICE A
Dimensionamento do torque dos motores utilizados
Dados: comprimento da peça usinada: 150,00 mm 5,91”
diâmetro inicial da peça usinada: 50,00 mm 1,97”
diâmetro final da peça usinada: 16,00 mm 0,63”
1) Rotação no eixo árvore (rpm) (varia entre 2000 e 6000 sfm):
A conversão de sfm para rpm segue a equação 1:
𝑛 =𝑠𝑓𝑚 ∗ 12
𝑑𝑖 ∗ 𝜋 (1)
onde: 𝑛 = velocidade do eixo árvore (rpm);
𝑠𝑓𝑚 = surface feet per minute;
𝑑𝑖 = diâmetro inicial (polegadas).
Considerando que o diâmetro inicial é de 1,97” e que o deslocamento varia
entre 2000 e 6000 sfm, tem-se que a velocidade do eixo árvore varia entre 3877,89 e
11633,66 rpm.
2) Velocidade de corte (m/min):
A velocidade máxima de corte (equação 2), dada em m/min, é atingida quando
o eixo árvore está com a maior velocidade (11633,66 rpm) e a peça apresenta seu
diâmetro inicial (50,00 mm). Dessa forma, a velocidade máxima de corte é de 1827,41
m/min.
𝑉𝑐 =𝑛 ∗ 𝑑𝑖 ∗ 𝜋
1000 (2)
95
3) Largura de corte e espessura de corte (mm):
Considerando o avanço máximo de 0,4 mm/rotação do eixo árvore e uma
profundidade de corte de 0,5 mm, e o ângulo de corte de 90º, calcula-se a largura (b)
e espessura de corte (h). Sendo assim, a espessura de corte é de 0,4 mm e a largura
de corte é de 0,5 mm.
ℎ = 𝑓𝑛 ∗ 𝑠𝑒𝑛 𝜃 (3)
𝑏 = 𝐴𝑝/𝑠𝑒𝑛 𝜃 (4)
onde: ℎ = espessura de corte (mm);
𝑏 = largura de corte (mm);
𝑓𝑛 = avanço máximo por rotação (mm/rotação);
𝐴𝑝 = profundidade de corte (mm);
𝜃 = ângulo da ferramenta (graus).
4) Pressão específica de corte (kgf/mm²):
A pressão específica de corte é obtida através da equação 5. Considerando
que o material utilizado é o Aço Inoxidável Austenítico Melhorado (SANMAC) Forjado
Recozido, e as propriedades do mesmo são: perda (z) = 0,29 e pressão específica de
corte (Ks¹) = 2772 MPa. Ainda, considerando o avanço máximo de 0,4 mm/rotação do
eixo árvore e uma profundidade de corte de 0,5 mm, o valor obtido como pressão
específica de corte é 368,58 kgf/mm².
𝐾𝑠 = 𝐾𝑠1 ∗ ℎ𝑍 (5)
onde: 𝐾𝑠 = pressão específica de corte (kgf/mm²);
𝐾𝑠1 = pressão específica de corte (MPa);
ℎ = espessura de corte (mm/mm);
𝑧 = perdas.
96
5) Força de corte, força de avanço e força passiva (kgf):
A força de corte é a força tangencial ao ponto de corte, onde a ferramenta está
em contato com a peça; as forças contrárias à remoção do material são denominadas
como força de avanço e força passiva, estabelecidas, respectivamente, sobre os eixos
longitudinal e transversal. De acordo com as equações 6 a 8, para este caso, a força
de corte é de 73,72 kgf, a força de avanço é de 16,38 kgf e a força passiva é de 18,43
kgf.
𝐹𝐶 = 𝐾𝑠 ∗ 𝐴 (6)
𝐹𝑓 = 𝐹𝐶/4,5 (7)
𝐹𝑝 = 𝐹𝐶/4 (8)
onde: 𝐹𝐶 = força de corte (kgf);
𝐹𝑓 = força de avanço (kgf);
𝐹𝑝 = força passiva (kgf);
𝐴 = área (h*b) (mm²).
6) Potência de corte (cv):
A potência de corte é calculada através das equações 9 e 10 e considera um
rendimento (𝑛𝑠) de no mínimo 80%. De acordo com as equações, a potência de corte
é de 0,49 cv.
𝑃𝐶 (𝑘𝑊) =𝐹𝐶 ∗ 𝑉𝐶
4500 ∗ 𝑛𝑠 (9)
𝑃𝐶(𝑐𝑣) = 𝑃𝐶(𝑘𝑊) ∗ 0,01334 (10)
onde: 𝑃𝐶 = potência de corte (kW ou cv);
𝐹𝐶 = força de corte (kgf);
𝑉𝐶 = velocidade de corte (m/min);
𝑛𝑠 = rendimento do motor.
97
7) Torque nos motores (kgf.cm):
O torque nos motores para os eixos das coordenadas X e Z é estabelecido
através da equação 11. Para o eixo da coordenada X, a força do meio envolvida é a
força passiva 𝐹𝑝; para o eixo da coordenada Z, a força do meio é a soma da força de
avanço 𝐹𝑓 e da força de corte 𝐹𝑐. Dessa forma, os valores obtidos como torque dos
motores são de 17,92 kgf.cm (1,8 N.m) para o eixo da coordenada Z e 3,67 kgf.cm
(0,4 N.m) para o eixo da coordenada X.
𝑇 =𝑓𝑛 ∗ 𝑛1 ∗ 𝐹 ∗ 1000
2𝜋 ∗ 𝑛2
(11)
onde: 𝑇 = torque no motor (kgf.cm);
𝑓𝑛 = avanço máximo por rotação (mm/rotação);
𝑛1 = coeficiente de atrito do rolamento (0,3%);
𝑛2 = rendimento do fuso de esfera (96%);
𝐹 = força do meio (kgf).
98
APÊNDICE B
I. Entidades de projeto representadas pelos símbolos descritos na seção 3.3.2:
a) home:
1 LIBRARY ieee;
2 USE ieee.std_logic_1164.all;
3
4 ENTITY home IS
5 GENERIC (vel_home1x: IN NATURAL :=100000;
6 vel_home2x: IN NATURAL :=100000;
7 vel_home1z: IN NATURAL :=25000;
8 vel_home2z: IN NATURAL :=25000);
9
10 PORT (rst_n, start_home, sensor_home_x, sensor_home_z, clk: IN STD_LOGIC;
11 homeOK_x, homeOK_z, dir_x, dir_z, movingX, movingZ, step_x, step_z: OUT STD_LOGIC :='0';
12 step_counter_x, step_counter_z: OUT NATURAL := 0);
13 END home;
14
15 ARCHITECTURE home OF home IS
16 COMPONENT a_home_control
17 PORT ( a_rst_n, a_start_home, a_sensor_home: IN STD_LOGIC;
18 a_vel_home1, a_vel_home2: IN NATURAL;
19 a_homing: BUFFER STD_LOGIC;
20 a_step_size: OUT NATURAL;
21 a_homeOK, a_dir: OUT STD_LOGIC);
22 END COMPONENT;
23 COMPONENT b_step_generator
24 PORT ( b_rst_n, b_clk, b_move: IN STD_LOGIC;
25 b_step_size: IN NATURAL;
26 b_in_position: BUFFER STD_LOGIC;
27 b_step_counter: BUFFER NATURAL;
28 b_step: OUT STD_LOGIC);
29 END COMPONENT;
30
31 SIGNAL step_size_x, step_size_z: NATURAL :=0;
32 SIGNAL homing_x, homing_z: STD_LOGIC :='0';
33 BEGIN
34 A: a_home_control PORT MAP (a_rst_n => rst_n, a_start_home => start_home,
35 a_sensor_home => sensor_home_x, a_vel_home1 => vel_home1x,
36 a_vel_home2 => vel_home2x, a_homing => homing_x,
37 a_step_size => step_size_x, a_homeOK => homeOK_x,
38 a_dir => dir_x);
39 B: a_home_control PORT MAP (a_rst_n => rst_n, a_start_home => start_home,
40 a_sensor_home => sensor_home_z, a_vel_home1 => vel_home1z,
41 a_vel_home2 => vel_home2z, a_homing => homing_z,
42 a_step_size => step_size_z, a_homeOK => homeOK_z,
99
43 a_dir => dir_z);
44 C: b_step_generator PORT MAP( b_rst_n => rst_n, b_clk => clk,
45 b_move => homing_x, b_step_size => step_size_x,
46 b_in_position => movingX, b_step_counter => step_counter_x,
47 b_step => step_x);
48 D: b_step_generator PORT MAP (b_rst_n => rst_n, b_clk => clk,
49 b_move => homing_z, b_step_size => step_size_z,
50 b_in_position => movingZ, b_step_counter => step_counter_z,
51 b_step => step_z);
52 END ARCHITECTURE;
b) move_manual:
1 LIBRARY ieee;
2 USE ieee.std_logic_1164.all;
3
4 ENTITY move_manual IS
5 PORT ( adc_x, adc_z: IN STD_LOGIC_VECTOR (11 DOWNTO 0);
6 rst_n, clk, move: IN STD_LOGIC;
7 dir_x, dir_z, movingX, movingZ, step_x, step_z: OUT STD_LOGIC :='0';
8 step_counter_x, step_counter_z: OUT NATURAL);
9 END move_manual;
10
11 ARCHITECTURE move_manual OF move_manual IS
12 COMPONENT c_speed_scale
13 PORT ( c_clk: IN STD_LOGIC;
14 c_adc: IN STD_LOGIC_VECTOR (11 DOWNTO 0);
15 c_step_size: BUFFER NATURAL;
16 c_direction: OUT STD_LOGIC);
17 END COMPONENT;
18 COMPONENT b_step_generator
19 PORT ( b_rst_n, b_clk, b_move: IN STD_LOGIC;
20 b_step_size: IN NATURAL;
21 b_in_position: BUFFER STD_LOGIC;
22 b_step_counter: BUFFER NATURAL;
23 b_step: OUT STD_LOGIC);
24 END COMPONENT;
25
26 SIGNAL step_size_x, step_size_z: NATURAL;
27 BEGIN
28 E: c_speed_scale PORT MAP (c_clk => clk, c_adc => adc_x, c_step_size => step_size_x,
c_direction => dir_x);
29 F: c_speed_scale PORT MAP (c_clk => clk, c_adc => adc_z, c_step_size => step_size_z,
c_direction => dir_z);
30 G: b_step_generator PORT MAP (b_rst_n => rst_n, b_clk => clk, b_move => move, b_step_size =>
step_size_x, b_in_position => movingX, b_step_counter => step_counter_x, b_step => step_x);
31 H: b_step_generator PORT MAP (b_rst_n => rst_n, b_clk => clk, b_move => move, b_step_size =>
step_size_z, b_in_position => movingZ, b_step_counter => step_counter_z, b_step => step_z);
32
100
33 END ARCHITECTURE;
c) speed_profile:
1 LIBRARY ieee;
2 USE ieee.std_logic_1164.all;
3
4 ENTITY speed_profile IS
5 GENERIC (resolution: IN NATURAL :=400;
6 Clock_rate: IN NATURAL :=50000000);
7 PORT ( pos_real_x, pos_real_z, pos_desired_z, pos_desired_x, time_acc_tool,
8 tool_speed: IN NATURAL RANGE 0 TO 65535;
9 move, rst_n, clk: IN STD_LOGIC;
10 step_sizeX,step_sizeZ: BUFFER NATURAL;
11 movingX, movingZ: BUFFER STD_LOGIC;
12 dirX, dirZ, stepX, stepZ: OUT STD_LOGIC);
13 END speed_profile;
14
15 ARCHITECTURE speed_profile OF speed_profile IS
16 COMPONENT d_calc
17 PORT ( d_tool_speed, d_time_acc_tool, d_pos_real_x, d_pos_real_z, d_pos_desired_x,
18 d_pos_desired_z, d_resolution, d_clock_rate: IN NATURAL;
19 d_movingX, d_movingZ, d_clk: IN STD_LOGIC;
20 d_dirX, d_dirZ: OUT STD_LOGIC;
21 d_num_steps_pos_x, d_num_steps_pos_z, d_step_accel_x, d_step_accel_z,
22 d_pulse_clk_one_step_x, d_pulse_clk_one_step_z: BUFFER NATURAL;
23 d_ratio_accel_x, d_ratio_accel_z: OUT NATURAL);
24 END COMPONENT;
25 COMPONENT e_step_controller
26 PORT (e_rst_n, e_clk, e_move: IN STD_LOGIC;
27 e_step_size, e_step_num: IN NATURAL;
28 e_moving: BUFFER STD_LOGIC;
29 e_step_counter: BUFFER NATURAL;
30 e_step: OUT STD_LOGIC);
31 END COMPONENT;
32 COMPONENT f_pos_profile
33 PORT (f_clk: IN STD_LOGIC;
34 f_step_counter, f_step_accel, f_num_steps_pos, f_pulse_clk_one_step,
35 f_ratio_accel: IN NATURAL;
36 f_step_size: OUT NATURAL);
37 END COMPONENT;
38
39 SIGNAL step_counter_x, step_counter_z, num_steps_pos_x, num_steps_pos_z, step_accel_x,
40 step_accel_z, pulse_clk_one_step_x, pulse_clk_one_step_z, ratio_accel_x,
41 ratio_accel_z, tool_speed, time_acc_tool: NATURAL;
42
43 BEGIN
44
45 I: d_calc PORT MAP (d_tool_speed => tool_speed, d_time_acc_tool => time_acc_tool,
101
46 d_pos_real_x => pos_real_x, d_pos_real_z => pos_real_z,
47 d_pos_desired_x => pos_desired_x, d_pos_desired_z => pos_desired_z,
48 d_resolution => resolution, d_clock_rate => clock_rate,
49 d_movingX => movingX, d_movingZ => movingZ,
50 d_clk => clk, d_dirX => dirX,
51 d_dirZ => dirZ, d_num_steps_pos_x => num_steps_pos_x,
52 d_num_steps_pos_z => num_steps_pos_z,
53 d_step_accel_x => step_accel_x, d_step_accel_z => step_accel_z,
54 d_pulse_clk_one_step_x => pulse_clk_one_step_x,
55 d_pulse_clk_one_step_z => pulse_clk_one_step_z,
56 d_ratio_accel_x => ratio_accel_x, d_ratio_accel_z => ratio_accel_z);
57 J: e_step_controller PORT MAP (e_rst_n => rst_n, e_clk => clk,
58 e_move => move, e_step_size => step_sizeX,
59 e_step_num => num_steps_pos_x, e_moving => movingX,
60 e_step_counter => step_counter_x, e_step => stepX);
61 K: e_step_controller PORT MAP (e_rst_n => rst_n, e_clk => clk,
62 e_move => move, e_step_size => step_sizeZ,
63 e_step_num => num_steps_pos_z, e_moving => movingZ,
64 e_step_counter => step_counter_z, e_step => stepZ);
65 L: f_pos_profile PORT MAP (f_clk => clk, f_step_counter => step_counter_x,
66 f_step_accel => step_accel_x, f_num_steps_pos => num_steps_pos_x,
67 f_pulse_clk_one_step => pulse_clk_one_step_x,
68 f_ratio_accel => ratio_accel_x, f_step_size => step_sizeX);
69 M: f_pos_profile PORT MAP ( f_clk => clk, f_step_counter => step_counter_z,
70 f_step_accel => step_accel_z, f_num_steps_pos => num_steps_pos_z,
71 f_pulse_clk_one_step => pulse_clk_one_step_z,
72 f_ratio_accel => ratio_accel_z, f_step_size => step_sizeZ);
73 END ARCHITECTURE;
d) ram:
1 LIBRARY ieee;
2 USE ieee.std_logic_1164.all;
3 USE ieee.numeric_std.all;
4
5 ENTITY ram is
6 PORT (data_in: IN UNSIGNED (15 DOWNTO 0);
7 address: IN UNSIGNED ( 4 DOWNTO 0);
8 writing, save: IN STD_LOGIC;
9 data_out: OUT UNSIGNED (15 DOWNTO 0));
10 END ram;
11
12 ARCHITECTURE ram OF ram IS
13 TYPE memory_area IS ARRAY (0 TO 31) OF UNSIGNED (15 DOWNTO 0);
14 SIGNAL memory: memory_area;
15 BEGIN
16 PROCESS(save, address)
17 BEGIN
102
18 IF RISING_EDGE (save) THEN
19 IF writing = '1' THEN memory(TO_INTEGER(address)) <= data_in;
20 END IF;
21 END IF;
22 END PROCESS;
23
24 data_out <= memory(TO_INTEGER(address));
25 END ARCHITECTURE;
e) controller:
1 LIBRARY ieee;
2 USE ieee.std_logic_1164.all;
3
4 ENTITY controller IS
5 PORT (emergency_button, dirX, dirZ, sen_minX, sen_minZ, sen_maxX, sen_maxZ, home_okX,
6 home_okZ, start_home, selec_button, start_in, start_move_man, aut_movingX,
7 aut_movingZ, clk: IN STD_LOGIC;
8 pos_desired_z, pos_desired_x: IN NATURAL RANGE 0 TO 65535;
9 ena_drv_x, ena_drv_z, ena_components: BUFFER STD_LOGIC;
10 homing, clearX, clearZ, writing, save, moving_man, move_aut: OUT STD_LOGIC;
11 display0, display1: OUT STD_LOGIC_VECTOR (7 DOWNTO 0);
12 address: BUFFER NATURAL RANGE 0 TO 31);
13 END controller;
14
15 ARCHITECTURE controller OF controller IS
16 SIGNAL aut_moving, moving_aut, selec_aut: STD_LOGIC :='0';
17 SIGNAL count_aut: NATURAL RANGE 0 TO 31;
18 BEGIN
19 aut_moving <= aut_movingX OR aut_movingZ;
20 selec_aut <= selec_button OR moving_aut;
21
22 clear_counters: BLOCK
23 BEGIN
24 clearX <= not home_okX;
25 clearZ <= not home_okZ;
26 END BLOCK clear_counters;
27
28 enable: PROCESS (dirX, dirZ, sen_minX, sen_minZ, sen_maxX, sen_maxZ, emergency_button)
29 BEGIN
30 IF emergency_button = '1'
31 THEN IF (dirX = '1' AND sen_maxX = '0') OR (dirX = '0' AND sen_minX = '0')
32 THEN ena_drv_x <= '0';
33 ELSE ena_drv_X <= '1';
34 END IF;
35 IF (dirZ = '1' AND sen_maxZ = '0') OR (dirZ = '0' AND sen_minZ = '0')
36 THEN ena_drv_z <= '0';
37 ELSE ena_drv_z <= '1';
38 END IF;
103
39 ELSE ena_drv_x <= '0';
40 ena_drv_z <= '0';
41 END IF;
42 ena_components <= ena_drv_x AND ena_drv_z;
43 END PROCESS enable;
44
45 home: BLOCK
46 BEGIN
47 homing <= '1' WHEN start_home = '1' AND ena_components = '1'
48 AND (home_okX OR home_okZ) = '0' ELSE
49 '0';
50 END BLOCK home;
51
52 manual: BLOCK
53 BEGIN
54 moving_man <= '1' WHEN selec_aut = '0' AND ena_components = '1' AND home_okX = '1'
55 AND home_okZ = '1' AND start_move_man = '1' ELSE
56 '0';
57 END BLOCK manual;
58
59 aut: PROCESS (selec_button, ena_components, start_in, aut_moving, moving_aut, clk, home_okX,
home_okZ)
60 VARIABLE adder_clk_aut: NATURAL:=0;
61 BEGIN
62 IF selec_button = '1' AND ena_components = '1' AND start_in = '1' AND home_o kX = '1' AND
home_okZ = '1'
63 THEN moving_aut <= '1';
64 ELSIF (ena_components = '0') OR (pos_desired_z = 0 AND pos_desired_x = 0)
65 THEN moving_aut <= '0';
66 END IF;
67
68 IF moving_aut ='1' AND aut_moving ='0'
69 THEN IF RISING_EDGE (clk)
70 THEN adder_clk_aut := adder_clk_aut + 1;
71 IF adder_clk_aut >= 500000
72 THEN move_aut <= '1';
73 END IF;
74 END IF;
75 ELSE move_aut <= '0';
76 adder_clk_aut := 0;
77 END IF;
78
79 IF moving_aut = '1'
80 THEN IF FALLING_EDGE (aut_moving)
81 THEN count_aut <= count_aut + 1;
82 END IF;
83 ELSE count_aut <= 0;
84 END IF;
104
85 END PROCESS aut;
86
87 ram: PROCESS (selec_aut, ena_components)
88 BEGIN
89 IF selec_aut = '0' AND ena_components = '1'
90 THEN writing <= '1';
91 ELSE writing <= '0';
92 save <= '0';
93 address <= count_aut;
94 END IF;
95 END PROCESS ram;
96
97 displays: BLOCK
98 BEGIN
99 WITH address SELECT
100 display0 <= "11000000" WHEN 0 | 10 | 20 | 30,
101 "11111001" WHEN 1 | 11 | 21 | 31,
102 "10100100" WHEN 2 | 12 | 22,
103 "10110000" WHEN 3 | 13 | 23,
104 "10011001" WHEN 4 | 14 | 24,
105 "10010010" WHEN 5 | 15 | 25,
106 "10000011" WHEN 6 | 16 | 26,
107 "11111000" WHEN 7 | 17 | 27,
108 "10000000" WHEN 8 | 18 | 28,
109 "10011000" WHEN 9 | 19 | 29;
110
111 WITH address SELECT
112 display1 <= "11000000" WHEN 0 TO 9,
113 "11111001" WHEN 10 TO 19,
114 "10100100" WHEN 20 TO 29,
115 "10110000" WHEN OTHERS;
116 END BLOCK displays;
117 END ARCHITECTURE;
II. Entidades de projeto solicitadas como componentes por outras entidades:
a) a_home_control (componente solicitado pela entidade home):
1 LIBRARY ieee;
2 USE ieee.std_logic_1164.all;
3
4 ENTITY a_home_control IS
5 PORT (a_rst_n, a_start_home, a_sensor_home: IN STD_LOGIC;
6 a_vel_home1, a_vel_home2: IN NATURAL;
7 a_homing: BUFFER STD_LOGIC :='0';
8 a_step_size: OUT NATURAL :=0;
9 a_homeOK, a_dir: OUT STD_LOGIC :='0');
10 END a_home_control;
105
11
12 ARCHITECTURE home_control OF a_home_control IS
13 BEGIN
14 move_control: PROCESS (a_rst_n, a_start_home, a_sensor_home)
15 BEGIN
16 IF a_rst_n = '1' THEN
17 IF RISING_EDGE (a_sensor_home) THEN a_homing <= '0'; a_homeOK <= '1';
18 END IF;
19 IF a_start_home = '1' THEN a_homing <= '1'; a_homeOK <= '0';
20 END IF;
21 ELSE a_homing <= '0';
22 END IF;
23
24 IF a_homing = '1' THEN
25 IF a_sensor_home = '1' THEN a_dir <= '0'; a_step_size <= a_vel_home1;
26 ELSE a_dir <= '1'; a_step_size <= a_vel_home2;
27 END IF;
28 END IF;
29 END PROCESS move_control;
30 END ARCHITECTURE;
b) b_step_generator (componente solicitado pelas entidades home e move_manual):
1 LIBRARY ieee;
2 USE ieee.std_logic_1164.all;
3
4 ENTITY b_step_generator IS
5 PORT (b_rst_n, b_clk, b_move: IN STD_LOGIC;
6 b_step_size: IN NATURAL;
7 b_in_position: BUFFER STD_LOGIC :='0';
8 b_step_counter: BUFFER NATURAL :=0;
9 b_step: OUT STD_LOGIC :='0');
10 END b_step_generator;
11
12 ARCHITECTURE steps OF b_step_generator IS
13 BEGIN
14 step_generator: PROCESS (b_clk)
15 VARIABLE count_clk: INTEGER :=0;
16 BEGIN
17 IF (b_move = '1' AND b_step_size /= 0 AND b_rst_n = '1') THEN b_in_position <= '1'
18 END IF;
19
20 IF b_in_position = '1' THEN
21 IF RISING_EDGE (b_clk) THEN count_clk := count_clk + 1;
22 END IF;
23 IF count_clk >= b_step_size THEN b_step_counter <= b_step_counter + 1; count_clk := 0;
24 END IF;
25 IF count_clk >= (b_step_size / 2) THEN b_step <= '0';
106
26 ELSE b_step <= '1';
27 END IF;
28 END IF;
29
30 IF (b_rst_n = '0' OR b_move = '0') THEN b_in_position <= '0'; b_step_counter <= 0;
31 count_clk := 0; b_step <= '0';
32 END IF;
33 END PROCESS step_generator;
34 END ARCHITECTURE;
c) c_speed_scale (componente solicitado pela entidade move_manual):
1 LIBRARY ieee;
2 USE ieee.std_logic_1164.all;
3 USE ieee.numeric_std.all;
4
5 ENTITY c_speed_scale IS
6 GENERIC ( speed_max: IN NATURAL :=50000;
7 speed_min: IN NATURAL :=100000);
8 PORT ( c_clk: IN STD_LOGIC;
9 c_adc: IN UNSIGNED (11 DOWNTO 0);
10 c_step_size: BUFFER NATURAL :=0;
11 c_direction: OUT STD_LOGIC :='0');
12 END c_speed_scale;
13
14 ARCHITECTURE speed_scale OF c_speed_scale IS
15 SIGNAL calc1, calc2, adc_int: NATURAL;
16 BEGIN
17 adc_int <= to_integer (c_adc);
18 calc1 <= (((speed_min - speed_max) * adc_int)/1791) + speed_max;
19 calc2 <= (((speed_min - speed_max)*(4095 - adc_int))/(4095-2304)) + speed_max;
20
21 WITH c_adc(11 DOWNTO 8) SELECT
22 c_step_size <= calc1 WHEN "0000" TO "0110",
23 calc2 WHEN "1001" TO "1111",
24 0 WHEN OTHERS;
25
26 WITH c_adc(11) SELECT
27 c_direction <= '0' WHEN "0",
28 '1' WHEN "1";
29 END ARCHITECTURE;
d) d_calc (componente solicitado pela entidade speed_profile):
1 LIBRARY ieee;
2 USE ieee.std_logic_1164.all;
3 USE ieee.numeric_std.all;
4
107
5 ENTITY d_calc IS
6 PORT (d_tool_speed, d_time_acc_tool, d_pos_real_x, d_pos_real_z, d_pos_desired_x,
7 d_pos_desired_z, d_resolution, d_clock_rate: IN NATURAL;
8 d_movingX, d_movingZ, d_clk: IN STD_LOGIC;
9 d_dirX, d_dirZ: OUT STD_LOGIC :='0';
10 d_num_steps_pos_x, d_num_steps_pos_z, d_step_accel_x, d_step_accel_z,
11 d_pulse_clk_one_step_x, d_pulse_clk_one_step_z: BUFFER NATURAL :=0;
12 d_ratio_accel_x, d_ratio_accel_z: OUT NATURAL :=0);
13 END d_calc;
14
15 ARCHITECTURE calcs OF d_calc IS
16
17 FUNCTION sqrt ( d : UNSIGNED ) RETURN UNSIGNED IS
18 VARIABLE a : UNSIGNED (31 DOWNTO 0):=d;
19 VARIABLE q : UNSIGNED (15 DOWNTO 0):=(OTHERS => '0');
20 VARIABLE left,right,r : UNSIGNED (17 DOWNTO 0):=(OTHERS => '0');
21 VARIABLE i : INTEGER:=0;
22 BEGIN
23 FOR i IN 0 TO 15 LOOP
24 right(0):='1';
25 right(1):=r(17);
26 right(17 DOWNTO 2):=q;
27 left(1 DOWNTO 0):=a(31 DOWNTO 30);
28 left(17 DOWNTO 2):=r(15 DOWNTO 0);
29 a(31 DOWNTO 2):=a(29 DOWNTO 0);
30
31 IF ( r(17) = '1') THEN r := left + right;
32 ELSE r := left - right;
33 END IF;
34
35 q(15 downto 1) := q(14 downto 0);
36 q(0) := not r(17);
37 END LOOP;
38 RETURN q;
39 END sqrt;
40
41 SIGNAL speed_x_rps, speed_z_rps, pulse_clk_accel, num_steps_tool, aux_sqr,
42 slower_step_x, slower_step_z, steps_x, steps_z : NATURAL;
43 SIGNAL sqr_root_in: UNSIGNED(31 downto 0);
44 SIGNAL sqr_root_out: UNSIGNED(15 downto 0);
45
46 BEGIN
47
48 sel_dir: PROCESS (d_clk)
49 BEGIN
50 IF (d_movingX = '0') THEN
51 IF (d_pos_real_x < d_pos_desired_x) THEN
52 d_num_steps_pos_x <= d_pos_desired_x - d_pos_real_x;
108
53 d_dirX <= '1';
54 ELSE d_num_steps_pos_x <= d_pos_real_x - d_pos_desired_x;
55 d_dirX <= '0';
56 END IF;
57 END IF;
58
59 IF (d_movingZ = '0') THEN
60 IF (d_pos_real_z < d_pos_desired_z) THEN
61 d_num_steps_pos_z <= d_pos_desired_z - d_pos_real_z;
62 d_dirZ <= '1';
63 ELSE d_num_steps_pos_z <= d_pos_real_z - d_pos_desired_z;
64 d_dirZ <= '0';
65 END IF;
66 END IF;
67 END PROCESS sel_dir;
68
69 Calc: BLOCK
70 BEGIN
71 aux_sqr <= (d_num_steps_pos_x**2) + (d_num_steps_pos_z**2);
72 sqr_root_in <=to_unsigned (aux_sqr, 32);
73 sqr_root_out <= sqrt ( sqr_root_in );
74 num_steps_tool <= to_integer (sqr_root_out);
75
76 d_pulse_clk_one_step_x <= (d_clock_rate * 10)/((d_resolution * d_num_steps_pos_x *
d_tool_speed)/num_steps_tool);
77 d_pulse_clk_one_step_z <= (d_clock_rate * 10)/((d_resolution * d_num_steps_pos_z *
d_tool_speed)/num_steps_tool);
78
79 d_step_accel_x <= (d_resolution * d_num_steps_pos_x * d_tool_speed * d_time_acc_tool) /
(num_steps_tool*200);
80 d_step_accel_z <= (d_resolution * d_num_steps_pos_z * d_tool_speed * d_time_acc_tool) /
(num_steps_tool*200);
81
82 pulse_clk_accel <= (d_clock_rate * d_time_acc_tool)/10;
83
84 slower_step_x <= ((pulse_clk_accel * 2) / d_step_accel_x) - d_pulse_clk_one_step_x;
85 slower_step_z <= ((pulse_clk_accel * 2) / d_step_accel_z) - d_pulse_clk_one_step_z;
86
87 d_ratio_accel_x <= (slower_step_x - d_pulse_clk_one_step_x) / (d_step_accel_x - 1);
88 d_ratio_accel_z <= (slower_step_z - d_pulse_clk_one_step_z) / (d_step_accel_z - 1);
89 END BLOCK Calc;
90 END ARCHITECTURE;
e) e_step_controller (componente solicitado pela entidade speed_profile):
1 LIBRARY ieee;
2 USE ieee.std_logic_1164.all;
3
109
4 ENTITY e_step_controller IS
5 PORT ( e_rst_n, e_clk, e_move: IN STD_LOGIC;
6 e_step_size, e_step_num: IN NATURAL;
7 e_moving: BUFFER STD_LOGIC :='0';
8 e_step_counter: BUFFER NATURAL :=0;
9 e_step: OUT STD_LOGIC :='0');
10 END e_step_controller;
11
12 ARCHITECTURE step_control OF e_step_controller IS
13 BEGIN
14 step_controller: PROCESS (e_clk)
15 VARIABLE adder_clk: INTEGER :=0;
16 BEGIN
17 IF (e_move = '1' AND e_step_size /= 0 AND e_step_num /=0 AND e_rst_n = '1')
18 THEN e_moving <= '1';
19 END IF;
20
21 IF e_moving = '1' THEN
22 IF RISING_EDGE (e_clk) THEN adder_clk := adder_clk + 1;
23 IF adder_clk >= e_step_size THEN e_step_counter <= e_step_counter + 1;adder_clk := 0;
24 END IF;
25 IF adder_clk >= (e_step_size / 2) THEN e_step <= '0';
26 ELSE e_step <= '1';
27 END IF;
28 END IF;
29 END IF;
30
31 IF (e_step_size = 0 OR e_rst_n = '0')
32 THEN e_step_counter <= 0; adder_clk := 0; e_step <= '0'; e_moving <= '0';
33 END IF;
34 END PROCESS step_controller;
35 END ARCHITECTURE;
f) f_pos_profile (componente solicitado pela entidade speed_profile):
1 LIBRARY ieee;
2 USE ieee.std_logic_1164.all;
3
4 ENTITY f_pos_profile IS
5 PORT (f_clk: IN STD_LOGIC;
6 f_step_counter, f_step_accel, f_num_steps_pos,
7 f_pulse_clk_one_step, f_ratio_accel: IN NATURAL;
8 f_step_size: OUT NATURAL :=0);
9 END f_pos_profile;
10
11 ARCHITECTURE pos_profile OF f_pos_profile IS
12 SIGNAL pulse_accel, pulse_decel: NATURAL :=0;
13 BEGIN
110
14 pulse_accel <= f_pulse_clk_one_step + ((f_step_accel - f_step_counter - 1) * f_ratio_accel);
15 pulse_decel <= f_pulse_clk_one_step + ((f_step_accel - (f_num_steps_pos - f_step_counter)) *
f_ratio_accel);
16
17 posic_controller: PROCESS (f_clk)
18 BEGIN
19 IF (f_step_accel + f_step_accel) < f_num_steps_pos THEN
20 IF f_step_counter < f_step_accel THEN f_step_size <= pulse_accel;
21 ELSIF (f_num_steps_pos - f_step_counter) <= f_step_accel AND (f_step_counter <
f_num_steps_pos) THEN f_step_size <= pulse_decel;
22 ELSIF f_step_counter >= (f_num_steps_pos - 1) THEN f_step_size <= 0;
23 ELSE f_step_size <= f_pulse_clk_one_step;
24 END IF;
25 ELSE IF f_step_counter < (f_num_steps_pos / 2) THEN f_step_size <= pulse_accel;
26 ELSIF f_step_counter >= (f_num_steps_pos - 1) THEN f_step_size <= 0;
27 ELSE f_step_size <= pulse_decel;
28 END IF;
29 END IF;
30 END PROCESS posic_controller;
31 END ARCHITECTURE;