UNIVERSIDADE POSITIVO
SISTEMA PARA DESENHO EM PLACA DE CIRCUITO
IMPRESSO
CURITIBA
2008
HANDY BORGES
PAULO HENRIQUE VITORINO
SISTEMA PARA DESENHO EM PLACA DE CIRCUITO
IMPRESSO
TCC apresentado à banca Examinadora do
Curso de Engenharia Elétrica da Universidade
Positivo, disciplina de Trabalho de Conclusão
de Curso, como requisito à obtenção do grau de
Engenheiro(a) Eletricista.
Orientador: Prof. André Macário Barros
CURITIBA
2008
"É melhor tentar e falhar,
que preocupar-se e ver a vida passar;
é melhor tentar, ainda que em vão,
que sentar-se fazendo nada até o final.
Eu prefiro na chuva caminhar,
que em dias tristes em casa me esconder.
Prefiro ser feliz, embora louco,
que em conformidade viver ..."
Martin Luther King
Agradeço a meus pais Marco Tulio Borges e Marlene Palaoro Borges,
pelos princípios e ensinamentos que guiaram minha educação.
À minhas queridas irmãs Hallema e Hesly e meu namorado Ennio Guido
Schiavon Jr. pelo carinho, compreensão, apoio e paciência durante minhas
ausências.
Handy Borges
Quero primeiramente agradecer a Deus, por sua infinita e misericórdia
bondade, por me conceder saúde e força para conclusão de mais uma etapa na
minha vida.
Aos meus pais, que me deram a vida e me ensinaram a viver com
dignidade, sempre confiaram em mim e que muitas vezes renunciaram aos seus
próprios sonhos para que eu pudesse realizar o meu!
Paulo HenriqueVitorino
Queremos agradecer também aos Mestres e Professores que fizeram
parte de nosso aprendizado, sempre com muita dedicação e amor. Pelas grandes
amizades e amigos conquistados nestes últimos anos, amigos estes que sempre
lembraremos com muito carinho.
SUMÁRIO
LISTA DE FIGURAS ............................................................................iv
LISTA DE TABELAS............................................................................iv
LISTA DE ABREVIATURAS ...............................................................v
1. INTRODUÇÃO..................................................................................1
1.1. Problema.............................................................................................1
1.2. Justificativa.........................................................................................1
1.3. Objetivos específicos..........................................................................2
2. FUNDAMENTAÇÃO TEÓRICA ....................................................3
2.1. Plotter.................................................................................................3
2.2. TraxMaker ..........................................................................................3
2.3. Motor de Passo ...................................................................................3
3. ESPECIFICAÇÕES TÉCNICAS PRELIMINARES.....................6
3.1. Visão geral do projeto ........................................................................6
3.2. Descrição funcional dos blocos..........................................................6
3.2.1. Circuit Maker e TraxMaker............................................................7
3.2.2. O software do PC............................................................................8
3.2.3. Microcontrolador ............................................................................8
3.2.4. Comunicação Serial ........................................................................9
3.3. Dimensionamento e memorial de cálculo ........................................10
3.3.1. Tratamento dos parâmetros de referência.....................................10
3.3.2. Fonte de alimentação ....................................................................11
3.3.3. Driver’s para acionamentos Motores de Passo.............................12
3.4. Programação.....................................................................................12
3.4.1. Programa do PC ............................................................................12
3.4.2. Programa do PIC...........................................................................13
3.5. Planejamento ....................................................................................14
3.5.1. Cronograma ..................................................................................14
3.5.2. Custos............................................................................................14
4. IMPLEMENTAÇÃO.......................................................................16
4.1. Descrição da montagem ...................................................................16
4.2. Testes, medições e configurações ....................................................20
4.3. Código Fonte ....................................................................................24
4.3.1. Firmware ......................................................................................24
4.3.2. Software ........................................................................................24
4.4. Placas de circuito impresso ..............................................................25
4.5. Custo do projeto ...............................................................................25
4.5.1. Componentes e materiais ..............................................................25
4.5.2. Serviços contratados .....................................................................25
5. RESULTADOS.................................................................................26
6. CONCLUSÕES ................................................................................28
Apêndice A .............................................................................................29
Apêndice B .............................................................................................30
Apêndice C .............................................................................................31
ii
Apêndice D .............................................................................................32
D.1 Linhas de código do Form principal: ...............................................32
D.2 Linhas de código do Form Valores: .................................................46
D.3 Linhas de código do Form Setup:.....................................................47
D.4 Linas de código do Form Comandos: ..............................................51
D.5 Linhas de comando do Form AnalisarDados:..................................54
D.6 Linhas de código do Form Serial: ....................................................56
Apêndice E .............................................................................................58
D.1 Linhas de código para PIC ...............................................................58
Apêndice F..............................................................................................71
REFERÊNCIA.......................................................................................72
iii
LISTA DE FIGURAS
FIGURA 1 - Diagrama de blocos do projeto.............................................2
FIGURA 2 - Relação deslocamento x pulso..............................................4
FIGURA 3 - Diagrama de blocos do sistema ............................................6
FIGURA 4 - Tela do programa TraxMaker...............................................7
FIGURA 5 - Tela do arquivo .pcb gerado pelo TraxMaker ......................8
FIGURA 6 - Identificação dos parâmetros de referência ........................10
FIGURA 7 - Diagrama de blocos do circuito de corrente. ......................11
FIGURA 8 - Fluxograma de funcionamento do programa do PC...........13
FIGURA 9 - Fluxograma de funcionamento do programa do PIC .........14
FIGURA 10 - Fotografia lateral do plotter ..............................................17
FIGURA 11 - Fotografia da plotter – visão do carro...............................17
FIGURA 12 - Fotografia da plotter – vista traseira.................................18
FIGURA 13 - Detalhes do mecanismo da pena.......................................19
FIGURA 14 - Interface manual de controle ............................................21
FIGURA 15 - Acesso da tela de configuração da plotter ........................21
FIGURA 16 - Tela de configuração da plotter ........................................22
FIGURA 17 - Visualização dos ângulos pré-definidos ...........................23
FIGURA 18 - Interface final do programa ..............................................24
FIGURA 19 - Gráfico de tempo de execução das linhas horizontais ......27
FIGURA 20 - Gráfico de tempo de execução das linhas verticais ..........27
FIGURA 21 - Circuito eletrônico ............................................................29
FIGURA 22 - Cronograma ......................................................................30
FIGURA 23 - Placa de potência do eixo Y..............................................71
FIGURA 24 - Desenho placa principal....................................................71
FIGURA 25 - Desenho do sensor óptico .................................................71
LISTA DE TABELAS
TABELA 1 - Energização para movimentação do motor de passo...........4
TABELA 2 - Sentido horário do motor de passo ......................................5
TABELA 3 - Informações dos microcontroladores...................................9
TABELA 4 - Comparação das comunicações .........................................10
TABELA 5 - Tempo de execução de linhas horizontais .........................26
TABELA 6 - Tempo de execução de linhas verticais .............................26
TABELA 7 - Custos de componentes .....................................................31
iv
LISTA DE ABREVIATURAS
PCI - Placas de Circuito Impresso
PC - Computador Pessoal
I/O - Entrada e/ou Saída
dpi - Dots per inch
USART - Universal Synchronous Asynchronous Receiver Transmitte
USB - Universal Serial Bus
v
1
1.
INTRODUÇÃO
Existem várias maneiras de confeccionar uma placa de circuito impresso.
Todas, porém requerem a passagem do desenho das trilhas para a placa de cobre.
O método manual, por exemplo, requer que o desenho seja feito direto na placa,
isso pode ser feito imprimindo o arquivo em papel especial e depois passado para
a placa, fazendo o desenho diretamente na placa, entre outros.
1.1.
PROBLEMA
Atualmente placas de circuito impresso podem ser confeccionadas
manualmente ou por empresas especializadas que, dependendo da quantidade
desejada e do tempo desejado, pode apresentar alto custo de produção, onerando
desta forma o projeto. Sendo assim, para alguns projetos, para viabilizar o
mesmo com pequenas quantidades, o processo indicado é o manual.
1.2.
JUSTIFICATIVA
Métodos manuais de confecção de placas de circuito impresso são
trabalhosos e demandam em torno de três horas, exigindo total atenção para a
criação do mesmo. Por este motivo, faz-se necessário uma alternativa para
produção de placas de circuito impresso.
Como exemplo, pode-se citar a sala de prototipagem da Universidade
Positivo, que consiste no método semi-manual de transferência térmica. Porém
este processo exige a aquisição de uma impressora a laser ou a realização de
fotocópias escurecidas, porém exige um cuidado extremo para que o desenho não
saia borrado. Outro processo disponível, ainda na Universidade, é a utilização da
fresa, o que exige conhecimentos de hardware e software específicos, para a
transferência do desenho do circuito para o hardware e a aquisição de fresas, que
apresentam alto custo, inviabilizando alguns projetos.
2
1.3.
OBJETIVOS ESPECÍFICOS
Pretende-se implementar e desenvolver um plotter para desenho de
circuito impresso de baixo custo, para facilitar o desenvolvimento de protótipos
de circuito impresso.
O sistema será composto por um programa, desenvolvido em linguagem
C++, e uma interface eletrônica que receberá os dados via comunicação serial. O
desenho da placa será originado no programa TraxMaker (módulo do Circuit
Maker) e o programa, desenvolvido em Borland Builder C++, irá decodificar o
desenho gerado e enviará os dados pela interface serial do computador à um
hardware constituído de um microcontrolador e motores de passo, que farão o
desenho na placa de circuito impresso.
Para a montagem da base do plotter, pretende-se fazer uso das peças de
scanners e impressoras descontinuadas. O sistema está representado na Figura 1 .
FIGURA 1 - Diagrama de blocos do projeto
Fonte: Própria
O sistema deverá apresentar:
a) Motores de passo que permitam uma rotação máxima, definida pelo
tipo de motor usado, que será o limitante para o hardware permitir uma
velocidade maior ou menor de impressão;
b) Hardware que permita desenho das trilhas, com distância entre estas
de no mínimo 2,54 mm, e desenho de placas de até 20cm x 15cm.
3
2.
FUNDAMENTAÇÃO TEÓRICA
Neste item será contextualizado o funcionamento básico de um plotter,
porém existem outros tipos de plotter e outras aplicações para a mesma. Serão
abrangidos também alguns contextos interessantes para o entendimento do
processo.
2.1.
PLOTTER
Plotter é uma impressora com especial aplicação na elaboração de
plantas arquitetônicas, mapas cartográficos, projetos de engenharia e grafismo
(WIKIPEDIA, 2008). Sua principal característica é a impressão de desenhos de
grandes dimensões, que necessitam alta qualidade sem perda de detalhe. Pode ser
encontrado hoje com qualidade de impressão de alta resolução, chegando a 2400
dpi de resolução.
2.2.
TRAXMAKER
Segundo LACERDA (2007), o TraxMaker é um módulo do software
Circuit Maker, que se destina a criação de layout de placas de circuito impresso
no computador, apresentando o recurso de autoroteamento, isto permite que, após
o usuário selecionar alguns parâmetros básicos, o próprio TraxMaker faz
algumas decisões sobre as melhores condições de colocação das trilhas.
2.3.
MOTOR DE PASSO
Um motor de passo é um componente eletromecânico que converte
energia elétrica em movimento, controlado através de pulsos em suas bobinas.
Isto possibilita que o deslocamento se dê por passos, onde passo é o menor
deslocamento angular do mesmo, apresentam uma gama de rotação muito ampla,
4
podendo variar de zero até 7200 rpm. Uma de suas particularidades é a
possibilidade da inversão de rotação em pleno funcionamento.
O número de pólos determina o deslocamento angular por pulsos de
entrada. A Figura 2 mostra a relação de deslocamento pelo pulso que, como dito
acima, deve ser de forma seqüencial e determina assim o deslocamento angular.
FIGURA 2 - Relação deslocamento x pulso
Fonte: MEZENGA (2001)
Para que um motor de passo desloque é necessário que suas bobinas
sejam energizadas uma de cada vez. A Tabela1 exibe a seqüência de pulsos num
motor de passo.
TABELA 1 - Energização para movimentação do motor de passo
Seqüência
S1
S2
S3
S4
B1
0
0
0
1
B2
0
0
1
0
B3
0
1
0
0
B4
1
0
0
0
t
t
t
Fonte: própria
Para traçar uma reta em um plotter, seja ela em ângulo ou não, deve-se
dar comando aos motores de passo na forma de pulsos. Como exemplo, para
traçar uma reta em diagonal com ângulo de 45°, os dois motores de passos
deverão ter o mesmo deslocamento e velocidade.
A velocidade é dada pelo tempo em que cada seqüência é acionada, isto
é, se for necessária uma velocidade alta, a seqüência de passos deve ser em
menor tempo, lembrando que o quanto maior o ciclo de permutações, menor o
torque do motor.
O sentido de rotação é dado pelo sentido da seqüência da tabela. Para o
sentido horário, por exemplo, deve-se seguir a seqüência mostrada na Tabela 2.
5
TABELA 2 - Sentido horário do motor de passo
Seqüência
S1
S2
S3
S4
Fonte: própria
B1
1
0
0
0
B2
0
1
0
0
B3
0
0
1
0
B4
0
0
0
1
t
t
t
6
3.
ESPECIFICAÇÕES TÉCNICAS PRELIMINARES
Neste item são abordadas as principais partes do projeto, detalhando-os
tecnicamente, além de definir cronograma e estudo de custos.
3.1.
VISÃO GERAL DO PROJETO
Deseja-se automatizar a realização de desenhos de placa de circuito
impresso. Para tal pretende-se controlar uma caneta fixada em um mecanismo
com motores de passo comandado por um microcontrolador. Este por sua vez
recebe os dados do computador através de uma interface desenvolvida em
linguagem C++, traduzindo os dados do programa TraxMaker, conforme a
Figura 3 .
FIGURA 3 - Diagrama de blocos do sistema
Fonte: Própria
3.2.
DESCRIÇÃO FUNCIONAL DOS BLOCOS
Na seqüência são apresentadas descrições funcionais de cada bloco visto
acima, assim como alguma parte integrante do projeto.
7
3.2.1. Circuit Maker e TraxMaker
O software TraxMaker (PROTEL,2000) é um software que cria a
informação das coordenadas das trilhas e pads 1 para o desenho da PCI e as salva
em um arquivo de extensão ".pcb". Este arquivo pode ser aberto no aplicativo
bloco de notas do Microsoft Windows, sendo de fácil identificação dos dados
referentes ao desenho da placa.
Outros programas foram analisados, como o Orcad (CADENCE, 2008) e
o Cad, porém os arquivos gerados por estes são binários e apresentavam códigos
mais complexos. Por este motivo se optou por utilizar o TraxMaker neste projeto.
Na Figura 4 é possível ver a tela de criação, ou alteração dos desenhos da
placa desejada.
FIGURA 4 - Tela do programa TraxMaker
Fonte: TraxMaker
Na Figura 5 é possível ver como são os dados gerados pelo TraxMaker,
estão identificadas as linhas, onde: a linha 1 indica o início do arquivo, as linhas
2 e 4 declaram o tipo de desenho que será feito na seqüência e as linhas 3 e 5
1 Segundo Protel International Limited PAD é um elemento para localizar e conectar o pinos dos
componentes sobre uma PCI, também chamado de ilhas.
8
informam as coordenadas num plano cartesiano que serão explicadas com mais
detalhes na seção 3.3.1. A linha 6 indica final de arquivo (ponteiro importante
para o software identificar e finalizar a execução).
FIGURA 5 - Tela do arquivo .pcb gerado pelo
TraxMaker
Fonte: Própria
Nas linhas de parâmetro de referência do desenho são apresentadas as
informações de espessura da linha e cor, juntamente com o início e fim do traço e
localização no plano a partir da referência 0 para x e 0 para y.
3.2.2. O software do PC
O software do PC será desenvolvido em linguagem C++, através do
compilador Borland Builder C++ (ALVES, 2002). Este software fará a interface
de interpretação dos dados gerados pelo TraxMaker e enviará para a porta serial
do PC para o microcontrolador PIC. O fluxograma de funcionamento do software
está apresentado no item 3.4.1.
3.2.3. Microcontrolador
O microcontrolador deve atentar os seguintes critérios:
a. Possuir fácil circuito embarcado para gravação (download);
b. Pinagem disponível para interligar os I/O’s (Necessidade mínima
de 12 pinos para conexão com os motores, 5 pinos para chaves fim
9
de curso e 2 pinos comunicação serial, totalizando um número
mínimo de 19 I/O’s);
c. Baixo custo devido a necessidade de pouca memória de
programação, uma vez que o projeto não necessita de
processamento no circuito embarcado.
d. Protocolo para comunicação serial (USART)
Na Tabela 3 é apresentada a comparação entre os possíveis
microcontroladores.
TABELA 3 - Informações dos microcontroladores
Pinagem
I/O
Conhecimento
Tipo de memória
Quant. memória
Preço
PIC12F629 PIC16F628
8
18
6
16
OK
OK
FLASH
FLASH
1.7kbytes
3.5kbytes
R$ 4,00
R$ 6,50
PIC16F873A
28
22
OK
FLASH
7kbytes
R$ 13,30
PIC16F877A
40
33
OK
FLASH
14kbytes
R$ 16,00
8051
40
32
NÃO
FLASH
64kbytes
R$ 5,50
Fonte: própria
O microcontrolador que melhor se adequou aos requisitos acima
mencionados foi o PIC16F873A, por este motivo foi o usado neste projeto.
A programação do microcontrolador deve ser desenvolvida de forma à
atender o fluxograma de funcionamento, com descrito no item 3.4.2.
Para verificar como o microcontrolador foi implementado no projeto veja
o bloco microcontrolador do Apêndice A.
3.2.4. Comunicação Serial
A comunicação serial foi escolhida porque apresenta características
importantes para cumprir o proposto pelo projeto. Em comparação com a porta
paralela, a porta serial permite desenvolver um protocolo de comunicação que
apresenta velocidade adequada ao projeto. Pode-se verificar a Tabela 4 para
diferenças entre estas duas comunicações.
10
TABELA 4 - Comparação das comunicações
Caraterística
Velocidade
Custo
Imunidade a ruído
Distância
Fonte: DUARTE (2008)
Serial
Paralela
↓
↓
↑
↑
↑
↑
↓
↓
A implementação da comunicação USB apresentaria um aumento de
custo. A comunicação USB permite também uma maior transferência de dados
do que a interface serial, o que não se faz necessária neste projeto. Em projetos
futuros, em que o custo não seja importante é possível implementar a
comunicação USB.
3.3.
DIMENSIONAMENTO E MEMORIAL DE CÁLCULO
A seguir serão demonstrados os cálculos pertinentes ao projeto.
3.3.1. Tratamento dos parâmetros de referência
Os parâmetros para as referências, da linha são apresentados como
mostra a Figura 6 .
FIGURA 6 - Identificação dos parâmetros de referência
Fonte: Própria
Com estas informações é possível saber onde começa e termina a linha,
se possui ou não inclinação, se este for o caso, fazer os cálculos para saber a
inclinação da mesma. Para isso utiliza-se a equação do feixe da reta:
11
y 2  y1  m x 2  x1 
(1)
A aprtir da equação (1) é posivel determinar a inclinação da reta (m):
m
y 2  y1
x 2  x1
(2)
Em que x1 e y1 são as coordenadas iniciais de x e y, respectivamente, e x2
e y2 são as coordenadas finais da reta.
3.3.2. Fonte de alimentação
A fonte de alimentação, mostrada na Figura 3 , foi dimensionada com
base nos cálculos de consumo, devendo fornecer uma corrente de 2A para o
circuito, conforme determinado pela corrente total do circuito mostrado na figura
abaixo no diagrama de blocos da corrente.
Através da Figura 7 é possível verificar os valores de consumo de cada
macro-componentes do hardware.
FIGURA 7 - Diagrama de blocos do circuito de corrente.
Fonte: Própria
No Apêndice A, pode ser vista a implementação da fonte de alimentação.
12
3.3.3. Driver’s para acionamentos Motores de Passo
Para o driver de acionamento dos motores de passo, serão utilizados os
seguintes transistores:
a) BD135 para chavear as bobinas dos motores dos eixos “x” e “y”
devido o consumo das bobinas serem em torno de 700mA (corrente
máxima de coletor do transistor de 1,5A);
b) BC548 para chavear as bobinas do motor da pena, consumo das
bobinas serem em torno de 300mA (corrente máxima de coletor do
transistor de 500mA).
Para ver como os drivers estão posicionados no projeto veja o bloco
drivers A e B do Apêndice A.
3.4.
PROGRAMAÇÃO
Na seqüência serão exibidos os fluxogramas das programações
necessárias para a realização do projeto.
3.4.1. Programa do PC
Conforme explicado no item 3.2.2, na Figura 8 é apresentado o
fluxograma funcional do programa que será desenvolvido.
13
FIGURA 8 - Fluxograma de funcionamento do programa do PC
Fonte: Própria
O programa desenvolvido possui uma interface em que é possível o
usuário selecionar o tipo de desenho que será feito, para este processo seguem os
quadros 2, 3 e 5 do fluxograma. Depois desta etapa o programa faz a busca do
item selecionado e então se dá inicio ao processo do desenho em conjunto com o
hardware.
3.4.2. Programa do PIC
No item 3.2.3 é comentada a programação que será realizada no
microcontrolador. Na Figura 9 é apresentado o fluxograma para melhor
entendimento.
14
FIGURA 9 - Fluxograma de funcionamento do programa do PIC
Fonte: Própria
3.5.
PLANEJAMENTO
A seguir serão apresentados os itens referentes ao planejamento do
projeto, tais como cronograma e expectativas de custos do mesmo.
3.5.1. Cronograma
O projeto teve um prazo de aproximadamente 10 meses, abrangendo
desde a parte de pesquisa até o desenvolvimento e implementação do sistema.
Para o planejamento desejado veja o Apêndice B
3.5.2. Custos
Os custos envolvidos neste projeto englobam os componentes
eletrônicos, os componentes mecânicos e os custos do trabalho escrito. Para os
detalhamentos dos custos estimados dos componentes eletrônicos e mecânicos,
15
com base em levantamentos feitos em lojas de eletrônica disponíveis em
Curitiba, veja o Apêndice C.
Para os custos estimados do trabalho escrito, levou-se em conta o custo
de impressão, fotocópia, encadernação e encadernação em capa-dura. Fazendo
levantamento de preço no mercado é possível estimar um gasto de R$ 350,00.
Os custos somados chegam a um valor de aproximadamente R$ 505,00.
16
4.
IMPLEMENTAÇÃO
Neste capitulo serão apresentados os procedimentos para a execução do
projeto, descrevendo problemas e dificuldades encontradas durante a montagem
como um todo.
4.1.
DESCRIÇÃO DA MONTAGEM
A montagem consistiu em três partes, a mecânica, a eletrônica e a
relacionada à programação.
A parte mecânica consiste na montagem física do plotter. Na mecânica
principal do projeto utilizou-se um scanner, da HP, descontinuado comprado em
uma loja de equipamentos usados. Algumas outras partes do mesmo foram
reaproveitadas no projeto. A mecânica do carro do eixo Y foi reaproveitado de
uma impressora usada, também da HP modelo deskjet, também adquirida na
mesma loja do scanner. Dois dos motores de passo comprados avulsos, também
materiais reaproveitados, são os motores do eixo x e do eixo y. Já o motor de
passo utilizado para o controle da pena, foi retirado de uma mini impressora. Para
etapa de montagem foi necessário um estudo das partes mecânicas envolvidas.
A parte eletrônica ocorreu de forma planejada, não sendo encontranda
nenhuma dificuldade. Inicialmente os componentes do circuito foram montados e
testados no protoboard, em seguida foram elaboradas as placas de circuito
impresso e montados os componentes.
A Figura 10 exibe a imagem do plotter, onde é possível observar:
a) Fonte de alimentação;
b) Motor de passo do eixo y;
c) Motor de passo da pena;
d) Placa de circuito impresso de potência do eixo Y;
e) Placa de circuito impresso principal;
f) Sensor óptico do eixo x;
g) Motor de passo do eixo x;
h) Área de plottagem
17
FIGURA 10 - Fotografia lateral do plotter
Fonte: Própria
Na Figura 11 é mostrada a localização dos seguinte itens:
a) Placa de circuito impresso principal;
b) Motor de passo do eixo y
c) Base de rolagem do eixo y
d) Detalhes do suporte da pena.
FIGURA 11 - Fotografia da plotter – visão do carro
Fonte: Própria
18
A Figura 12 apresenta outro ângulo da plotter, possibilitando ver os
seguintes itens:
a) Um dos sensores ópticos de fim de curso do eixo x;
b) Motor de passo do eixo y;
c) Um dos sensores ópticos de fim de curso do eixo y;
d) Fita do Encoder do eixo y;
e) Carro para facilitar a movimentação do eixo x;
f) Placa de circuito principal;
g) Placa de circuito de potência do eixo y.
FIGURA 12 - Fotografia da plotter – vista traseira
Fonte: Própria
Para a fixação da pena foi utilizado um parafuso, e o mecanismo de
altura da mesma é feito por um motor de passo, com ajuste fino de uma mola,
estes detalhes podem ser vistos na Figura 13 .
19
FIGURA 13 - Detalhes do mecanismo da pena
Fonte: Própria
O desenvolvimento que apresentou maior dificuldade foi a programação.
Inicialmente desenvolveu-se uma interface para comandos manuais, para facilitar
a calibração e ajuste da parte mecânica. Na seqüência foi desenvolvida a
interface que automatiza a plotagem da placa. A programação do PIC ficou
responsável pela interpretação dos dados recebidos do PC para controlar a
plotter.
Para o desenvolvimento da parte de programação, foi utilizada
linguagem C++ para a interface do PC e C para a programação do PIC.
O primeiro problema enfrentado na parte da programação se deu com
relação à transmissão serial de dados. As informações são enviadas byte a byte,
sendo assim, o maior valor inteiro escrito em um byte é 256, porém existe a
necessidade de enviar dados maiores que este. Sendo assim decidiu-se por dividir
o dado desejado em três, sendo que, um dos dados seria o divisor, o segundo
dado seria o dividendo e o último seria o resto da divisão. O divisor escolhido é
180 e os valores do dividendo podem variar de valores acima de 256, podendo
chegar à 23.000. Desta forma este problema foi solucionado.
A dificuldade seguinte diz respeito aos dados de retorno do PIC para o
PC. Sabe-se que sempre que o PC envia um comando para o PIC, este aguarda
confirmação do PIC de que o comando foi executado, para na seqüência poder
enviar o próximo comando. Inicialmente as duas primeiras mensagens que o PIC
20
retornava ao PC eram os retornos de fim de curso do eixo X e Y, ao receber estes
dados o PC enviava a próxima execução, porém, com isso faltavam dados para o
PC fazer a interpretação dos dados, assim este perdia a referência e não
conseguia dar continuidade. Para resolver esta situação, a seqüência dos dados de
retorno do PIC para o PC foi alterada, colocando os dados de fim de curso de
execução dos eixos como sendo as ultimas informações do pacote, para tal, foi
alterada também a forma de recebimento dos dados pelo PC.
Ao encontrar o problema de resolução do plotter, que apresentava alguns
desvios das linhas, foi verificado que os motores não podem apresentar
velocidade abaixo de dois e intervalo maior que 140, caso contrário perde a
confiabilidade. Estes valores são ajustados na tela de configuração mencionada
na seção 4.2.
4.2.
TESTES, MEDIÇÕES E CONFIGURAÇÕES
Os primeiros testes que puderam ser executados foram após a montagem
da parte eletrônica. Antes de serem montados o MAX232 e o microprocessador,
verificou-se a alimentação dos pinos. Em seguida foi feito um teste de pulsos,
excitando os transistores de potência e verificando a alimentação dos motores de
passo. Depois que os CIs, MAX232 e microprocessador foram montados, testouse a comunicação serial.
Na seqüência foi feito teste para verificar a relação entre o deslocamento
da pena em relação os valores inseridos no programa.
Como parte seguinte de teste, foi feita uma interface de controle manual
dos dispositivos sendo controlados pelo PC. A Figura 14 mostra a interface
desenvolvida. Neste teste verificou-se a funcionalidade de comunicação do PC
com a plotter.
21
FIGURA 14 - Interface manual de controle
Fonte: Própria
Através da tela apresentada na Figura 14 , digitava-se os valores de
deslocamento desejado e verificava-se o deslocamento real, utilizando uma
régua. Desenvolveu-se também uma interface de configuração dos parâmetros do
plotter, apresentada na Figura 15 e na Figura 16 .
FIGURA 15 - Acesso da tela de configuração da
plotter
Fonte: Própria
Alguns parâmetros são necessários para ajustar o plotter , por exemplo, a
constante de deslocamento dos motores X e Y, a distância entre cada pad para
cada seqüência do componente plotado. Uma vez confirmados estes ajustes, o
programa salva em arquivo os valores de cada parâmetro.
22
FIGURA 16 - Tela de configuração da plotter
Fonte: Própria
Para determinar como seriam feitos os ângulos das trilhas, foi necessário
testar-se as possibilidades dos ângulos verificando um a um, para determinar a
velocidade adequada dos motores, para as linhas não saírem serrilhadas. Para o
ajuste adequado foram testados as variações de cada velocidade, para verificar o
melhor resultado, para cada ângulo possível. Os testes resultaram em 90 ajustes
possíveis.
Uma vez determinados os valores, estes foram salvos em arquivo para
futura busca, quando o programa estiver sendo executado em modo automático.
Estes dados de configuração podem ser vistos através do programa desenvolvido,
na parte de configurações, como mostrado na Figura 17 .
23
FIGURA 17 - Visualização dos ângulos pré-definidos
Fonte: Própria
Da Figura 17 é possível verificar os seguintes itens:
a) Ângulo 0
b) Informações de velocidade e intervalo
Do item b citado acima, temos respectivamente para 2 10 180 100 1
velocidade do motor x, velocidade do motor y, intervalo para o motor x e
intervalo para o motor y.
Em seguida foi desenvolvida uma interface que automatiza o desenho
feito no TraxMaker e realiza o desenho. O código fonte é explorado no item 4.3.
A interface do programa é mostrada na Figura 18 .
24
FIGURA 18 - Interface final do programa
Fonte: Própria
4.3.
CÓDIGO FONTE
Na seqüência são apresentadas as linhas de códigos desenvolvidas.
4.3.1. Firmware
O firmware destinado ao PIC, desenvolvido em C, segue o fluxograma
apresentado no item 3.4.2. As linhas de código são apresentadas no Apêndice E.
4.3.2. Software
Para o software do PC, desenvolvida em linguagem C++, foi seguido o
raciocínio de desenvolvimento apresentado no item 3.4.1.
O código fonte esta disponível no Apêndice D.
O código utilizado para comunicação serial foi desenvolvido pelo
Professor Leonardo Gomes Tavare, o arquivo de cabeçalho é mostrado no
Apêndice D.6 Linhas de código do Form Serial:.
25
4.4.
PLACAS DE CIRCUITO IMPRESSO
As placas de circuito impresso deste projeto foram desenhadas pelo
próprio plotter. Os desenhos são apresentados no Apêndice F, devidamente
identificadas as suas partes.
4.5.
CUSTO DO PROJETO
O custo do projeto não excedeu o planejado, apresentado no item 3.5.2.
Na seqüência é apresentado o detalhamento.
4.5.1. Componentes e materiais
Conforme comentado anteriormente, o custo de componentes e materiais
segue o que foi apresentado no item 3.5.2, detalhado no Apêndice B.
4.5.2. Serviços contratados
Não foi contratado nenhum serviço.
26
5.
RESULTADOS
O presente projeto foi desenvolvido com meta principal de implementar
um sistema para fazer desenhos de placas de circuito impresso, de forma a
possibilitar projetos de baixo custo e a realização de protótipos em pequena
escala.
A área para a realização do desenho é limitada pela mecânica, que neste
projeto se limita a placas de no máximo 25x14 cm.
A espessura das linhas é definida de acordo com a caneta utilizada. No
mercado foram encontradas apenas canetas de 1,0mm e 2,0mm, porém a caneta
de 2,0mm utilizada apresentou melhor resultado nos desenhos executados.
Fazendo testes, partindo de zero e indo até nove repetições, para
quantidades variadas de linhas, partindo de 10 até 100, com intervalo de 10. Para
linhas horizontais foram levantados os dados da Tabela 5 e para as linhas
verticais os dados da Tabela 6 .
TABELA 5 - Tempo de execução de linhas horizontais
Horizontais
Linhas
Quantidade
10
20
30
40
50
60
70
80
90
100
Repetição
44
79
136
172
225
264
296
340
375
444
0
31
67
106
125
159
181
203
235
259
304
1
25
54
89
105
137
156
177
206
225
260
2
24
56
88
106
130
146
164
184
199
231
3
Tempo
23
21
55
48
85
76
101
91
125
106
141
122
158
138
177
154
192
169
219
191
4
5
21
52
79
94
108
129
145
162
177
197
6
21
52
74
90
111
128
142
158
172
202
7
20
47
75
88
101
117
131
147
161
181
8
20
50
79
93
114
130
145
162
175
199
9
22
46
70
94
121
146
171
197
226
253
7
21
46
70
94
119
144
170
196
222
250
8
21
45
69
93
118
143
168
194
220
247
9
Fonte: própria
TABELA 6 - Tempo de execução de linhas verticais
Verticais
Linhas
Qntade
10
20
30
40
50
60
70
80
90
100
Repetição
Fonte: Própria
25
56
91
129
171
216
266
318
375
435
0
23
50
79
110
142
176
212
250
289
330
1
23
49
77
105
135
165
197
231
263
299
2
23
47
73
99
128
156
186
215
248
278
3
Tempo
22
22
46
47
71
71
97
97
124
124
151
149
179
177
207
206
237
232
267
262
4
5
23
46
71
96
121
148
173
202
229
259
6
27
Para as tabelas acima foram gerados os gráficos da Figura 19 e da Figura
20 , para mostrar graficamente o comportamente dos motores.
FIGURA 19 - Gráfico de tempo de execução das linhas horizontais
Tempo de execução das lnhas horizontais
Tempo (seg)
450
400
10 linhas
20 linhas
350
30 linhas
40 linhas
300
50 linhas
250
60 linhas
70 linhas
200
80 linhas
90 linhas
150
100 linhas
Repetições
100
50
0
0
1
2
3
4
5
6
7
8
9
Fonte: Própria
FIGURA 20 - Gráfico de tempo de execução das linhas verticais
Tempo de execução das linhas verticais
Tempo (seg)
450
400
10 linhas
20 linhas
350
30 linhas
300
40 linhas
50 linhas
250
60 linhas
70 linhas
200
80 linhas
150
90 linhas
100 linhas
50
0
0
1
2
3
4
5
6
7
8
9
Repetições
100
Fonte: Própria
A partir dos gráficos é possível verificar que o plotter atende os
propósitos acadêmicos para que foi desenvolvida.
28
6.
CONCLUSÕES
O sistema proposto foi desenvolvido de forma a apresentar os resultados
desejados. O software que foi criado apresenta todos os controles necessários
para controle manual e automático, para a realização de desenhos de placas de
circuito impresso.
Foi desenvolvido um programa em linguagem C para o PIC e outro
programa em linguagem C++, que roda no PC, para a interpretação dos dados. O
programa que roda no PC possibilita a interpretação direta dos dados, para
realização do desenho, e também apresenta uma interface de controle manual.
Este mesmo programa possui as telas de setup para as configurações necessárias
para o funcionamento previsto do plotter.
Como é possível verificar, pelos objetivos específicos e a seção 5, todos
os itens propostos foram alcançados.
Durante o desenvolvimento do projeto, a pedido da banca, foi verificada
a possibilidade de implementar um controle de realimentação de dados com um
encoder, para controle de posicionamento, o que não foi possível por limitações
do microcontrolador. Esta implementação não foi possível se fosse utilizado mais
um microcontrolador para poder fazer o controle destes dados. Com esta
implementação seria possível criar rotinas a mais no programa para tratamento de
erros.
Ao finalizar este projeto verificou-se a possibilidade de utilizar
basicamente a mesma mecânica, fazendo pequenos ajustes mecânicos e de
programação, para poder mudar a caneta por uma fresa.
29
APÊNDICE A
FIGURA 21 - Circuito eletrônico
Fonte: própria
30
APÊNDICE B
FIGURA 22 - Cronograma
Fonte: Própria
31
APÊNDICE C
TABELA 7 - Custos de componentes
Descrição
Cap. Elet. Radial 470uF/25V Hitano
Cap. Cerâmico 100pF (pacote com 10)
Cap. Elet. Radial 1uF/50V Hitano
Cap. Cerâmico 27pF (pacote com 10)
1N 4007 - 1 AMP
LED Vermelho 5mm - TIL 228
LED Verde 5mm - TIL 234
RS 232 09 pinos femea 90G. - DBPN1F-09
PIC 16 F 873 A-I/SP
BC 547 85412190
BD 135
Resistores diversos 1/4 W
UA 7805
UA 7812
Cristal 4.000000 MHZ
MAX 232
Placa fenolite FN 1 - 20 X 20 CM
JACK - J-4
Soq.CI.16 pinos torneados celis SPT0.CB08
Soq.CI.16 pinos estampados SEE 16 - METALTEX
Soq.CI.24 pinos torneados CELIS SPT0.CB12
Soq.CI.28 pinos estampado SEL 28 - METALTEX
B.de pinos BPSC-40 1X40 180º METALTEX
MODU MCS -40 1X40 180º - METALTEX
Terminal modu MLTF - 2,54 MM - METALTEX
PCST 1103 = PHCT 103 Chave ótica
PCST 2103 = PHCT 203
Motor de passo (4 passos - 12V)
Transformador
Scaner sucateada
Impressora sucateada
Fonte: Própria
Qtd
2
1
1
1
10
10
10
1
1
10
8
40
1
2
1
1
2
1
1
1
1
1
2
2
40
6
6
2
1
1
1
Und
PC
P10
PC
P10
PC
PC
PC
PC
UND
PC
PC
PC
PC
PC
UND
PC
UND
PC
PC
PC
PC
PC
PC
PC
PC
PC
PC
PC
UND
PC
PC
Unitário
R$
0,20
R$
1,00
R$
0,10
R$
1,00
R$
0,06
R$
0,10
R$
0,12
R$
1,10
R$
13,30
R$
0,10
R$
0,50
R$
0,03
R$
0,65
R$
0,70
R$
0,80
R$
1,95
R$
4,60
R$
0,80
R$
0,80
R$
0,20
R$
1,20
R$
0,35
R$
0,45
R$
1,10
R$
0,10
R$
3,30
R$
3,30
R$
5,00
R$
16,00
R$
20,00
R$
20,00
TOTAL
Total
R$
R$
R$
R$
R$
R$
R$
R$
R$
R$
R$
R$
R$
R$
R$
R$
R$
R$
R$
R$
R$
R$
R$
R$
R$
R$
R$
R$
R$
R$
R$
R$
0,40
1,00
0,10
1,00
0,60
1,00
1,20
1,10
13,30
1,00
4,00
1,20
0,65
1,40
0,80
1,95
9,20
0,80
0,80
0,20
1,20
0,35
0,90
2,20
4,00
19,80
19,80
10,00
16,00
20,00
20,00
155,95
32
APÊNDICE D
D.1 LINHAS DE CÓDIGO DO FORM PRINCIPAL:
1: //-----------------------------------------------------------------------2: #include <vcl.h>
3:
4: #include "Serial.h"
5: #include "FrmSetup.h"
6: #pragma hdrstop
7:
8: #include "Prog_Plotter.h"
9: //-----------------------------------------------------------------------10: #pragma package(smart_init)
11: #pragma link "CSPIN"
12: #pragma link "CGAUGES"
13: #pragma resource "*.dfm"
14: TFrmPlotter *FrmPlotter;
15: Serial serial;
16:
17: void AtualizaDados(void);
18: void AtualizaLinha(void);
19: void EnviaDados(int Dados);
20: void IncrementaLinha(void);
21: void IncrementaIlha(void);
22: void CalculeCompr(void);
23: void CalcularDados(void);
24: void PosicaoInicial(void);
25: void PosicaoPena(void);
26: void CalcDist(void);//unit Comando.cpp
27:
28: extern int Linha, Analisar, CorLinha, Passo, X, X0, Y, Y0;
29:
30: extern bool FT1, grau;
31: int Retorno=0, ProximoReg;
32:
33: bool teste;
34: //-----------------------------------------------------------------------35: void ReiniciaGauge(void)
36: {
37: FrmPlotter->CGauge1->ForeColor=clNavy;
38: FrmPlotter->CGauge2->ForeColor=clNavy;
39: FrmPlotter->CGauge3->ForeColor=clNavy;
40: FrmPlotter->CGauge1->Progress=0;
41: FrmPlotter->CGauge2->Progress=0;
42: FrmPlotter->CGauge3->Progress=0;
43: FrmPlotter->GaugeTotal=0;
44: FrmPlotter->GaugeLinhas=0;
45: }
46: void AtualizaLinha(void)
47: {
48: int i, menorLinha;
49: bool PrimFT=false;
50: AnsiString Letra;
51:
52: FrmPlotter->TamLinhas=0;
53: FrmPlotter->TamIlhas=0;
54: FrmPlotter->TamTotal=0;
55:
56: for(i=0;i<FrmPlotter->Memo->Lines->Count;i++)
57: {
58: Letra=FrmPlotter->Memo->Lines->Strings[i];
59: if(Letra == "FT")
60: {
61: if(!PrimFT)
62: {
33
63: menorLinha=Y0;
64: PrimFT=true;
65: }
66: else
67: {
68: if(Y0<menorLinha)
69: menorLinha=Y0;
70: }
71: Linha=i;
72: CalcDist();
73: if (CorLinha == FrmPlotter->CorLinhaEscolhida)
74: {
75: FrmPlotter->TamLinhas++;
76: FrmPlotter->TamTotal++;
77: }
78: }
79: if((Letra =="FP") || (Letra =="CP"))
80: {
81: FrmPlotter->TamIlhas++;
82: FrmPlotter->TamTotal++;
83: }
84: }
85: FrmPlotter->LbIlha->Caption="Pad 0 de "+ IntToStr(FrmPlotter->TamIlhas);
86: FrmPlotter->LbLinha->Caption="Linha 1 de "+IntToStr(FrmPlotter>TamLinhas);
87: FrmPlotter->LbTotal->Caption="Total 1 de "+IntToStr(FrmPlotter->TamTotal);
88: FrmPlotter->CGauge1->ForeColor= clNavy;
89: FrmPlotter->CGauge2->ForeColor= clNavy;
90: FrmPlotter->CGauge3->ForeColor= clNavy;
91: FrmPlotter->CGauge1->Progress=0;
92: FrmPlotter->CGauge2->Progress=0;
93: FrmPlotter->CGauge3->Progress=0;
94: }
95: void IncrementaLinha(void)
96: {
97: FrmPlotter->GaugeLinhas++;
98: FrmPlotter->LbLinha->Caption="Executando linha "+IntToStr(FrmPlotter>GaugeLinhas)+" de 99:
100: if(FrmPlotter->TamLinhas!= 0)
101: FrmPlotter->CGauge2->Progress=(100*FrmPlotter->GaugeLinhas)/FrmPlotter>TamLinhas
102:
103: FrmPlotter->GaugeTotal++;
104: FrmPlotter->LbTotal->Caption="Executando total "+IntToStr(FrmPlotter>GaugeTotal)+" de 105:
106: if(FrmPlotter->TamTotal!=0)
107: FrmPlotter->CGauge3->Progress=(100* FrmPlotter->GaugeTotal)/FrmPlotter>TamTotal
108: }
109: void IncrementaIlha(void)
110: {
111: FrmPlotter->GaugeIlhas++;
112: FrmPlotter->LbIlha->Caption="Executando illha "+IntToStr(FrmPlotter>GaugeIlhas)+" de "
113:
114: if(FrmPlotter->TamIlhas!=0)
115: FrmPlotter->CGauge1->Progress=(100*FrmPlotter->GaugeIlhas)/FrmPlotter>TamIlhas
116:
117: FrmPlotter->GaugeTotal++;
118: FrmPlotter->LbTotal->Caption="Executando total "+IntToStr(FrmPlotter>GaugeTotal)+" de 119:
120: if(FrmPlotter->TamTotal!=0)
121: FrmPlotter->CGauge3->Progress=(100* FrmPlotter->GaugeTotal)/FrmPlotter>TamTotal
122: }
123: void EnviaDados(int Dados)
124: {
34
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
BYTE x;
x=Dados;
serial.Send(&x,1);
serial.ResetBuffer();
}
void AtualizaDados(void)
{
int i;
//na sequencia abaixo, envia à porta serial todas as informações neces//sárias para o PIC
CalculeCompr();//Segmente o comprimento X e Y para enviar à porta serial
if((FrmPlotter->RBCom1->Checked)||(FrmPlotter->RBCom2->Checked))
{
EnviaDados(200); //Ind = 200
Sleep(1);
EnviaDados(FrmPlotter->VelX);
Sleep(1);
EnviaDados(FrmPlotter->VelY);
Sleep(1);
EnviaDados(FrmPlotter->RetX);
Sleep(1);
EnviaDados(FrmPlotter->RetY);
Sleep(1);
EnviaDados(FrmPlotter->Var1X);
Sleep(1);
EnviaDados(FrmPlotter->Var2X);
Sleep(1);
EnviaDados(FrmPlotter->RestoX);
Sleep(1);
EnviaDados(FrmPlotter->Var1Y);
Sleep(1);
EnviaDados(FrmPlotter->Var2Y);
Sleep(1);
EnviaDados(FrmPlotter->RestoY);
Sleep(1);
EnviaDados(FrmPlotter->IntervX);
Sleep(1);
EnviaDados(FrmPlotter->IntervY);
Sleep(1);
EnviaDados(FrmPlotter->VlAtraso);
Sleep(1);
EnviaDados(FrmPlotter->TamPadX);
Sleep(1);
EnviaDados(FrmPlotter->TamPadY);
Sleep(1);
EnviaDados(FrmPlotter->OffSetPenaX);
Sleep(1);
EnviaDados(FrmPlotter->OffSetPenaY);
Sleep(1);
35
193:
194: EnviaDados(FrmPlotter->ComprPn);
195: Sleep(1);
196:
197: EnviaDados(FrmPlotter->CMD);
198: }
199: else
200: Application->MessageBoxA("Porta Serial não conectada!","Erro", 48);
201: }
202: void CalculeCompr(void)
203: {
204: float DeslocamentoX, DeslocamentoY;
205: int DeslX_aux, DeslY_aux;
206:
207: DeslocamentoX = FrmPlotter->DeslX * StrToFloat(FormSetup->EditFatorX>Text);
208: DeslX_aux= StrToInt(FormatFloat('0',DeslocamentoX));
209:
210: DeslocamentoY = FrmPlotter->DeslY * StrToFloat(FormSetup->EditFatorY>Text);
211: DeslY_aux= StrToInt(FormatFloat('0',DeslocamentoY));
212:
213: if(DeslX_aux >150)
214: {
215: FrmPlotter->Var2X=150;
216: FrmPlotter->Var1X=DeslX_aux/FrmPlotter->Var2X;
217: FrmPlotter->RestoX=DeslX_aux % FrmPlotter->Var2X;
218: }
219: else
220: {
221: FrmPlotter->Var1X=DeslX_aux;
222: FrmPlotter->Var2X= 1;
223: FrmPlotter->RestoX= 0;
224: }
225: if(DeslY_aux>150)
226: {
227: FrmPlotter->Var2Y=150;
228: FrmPlotter->Var1Y=DeslY_aux / FrmPlotter->Var2Y;
229: FrmPlotter->RestoY=DeslY_aux % FrmPlotter->Var2Y;
230: }
231: else
232: {
233: FrmPlotter->Var1Y=DeslY_aux;
234: FrmPlotter->Var2Y=1;
235: FrmPlotter->RestoY=0;
236: }
237: }
238: //----------------------------------------------------------------------239: __fastcall TFrmPlotter::TFrmPlotter(TComponent* Owner)
240: : TForm(Owner)
241: {
242: }
243: //----------------------------------------------------------------------244: void __fastcall TFrmPlotter::TrackBar1Change(TObject *Sender)
245: {
246: Label14->Caption="Motor X = " + IntToStr(TrackBar1->Position);
247: VelX= 102 - TrackBar1->Position;
248: }
249: //----------------------------------------------------------------------250: void __fastcall TFrmPlotter::TrackBar2Change(TObject *Sender)
251: {
252: Label15->Caption="Motor Y = " + IntToStr(TrackBar2->Position);
253: VelY= 152 - TrackBar2->Position;
254: }
255: //----------------------------------------------------------------------256: void __fastcall TFrmPlotter::RBCom2Click(TObject *Sender)
257: {
258: bool Abrir;
36
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321:
322:
323:
324:
325:
326:
serial.Close();
Abrir=serial.Open("COM2",CBR_9600);
if(!Abrir)
{
Application->MessageBoxA("Erro ao Abrir a Porta","Porta Serial", 48);
RBCom2->Checked=false;
LbCom->Caption="COM2 Ocupado!";
}
else
{
serial.ResetBuffer();
LbCom->Caption="COM2 Ativo!";
}
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::RBCom1Click(TObject *Sender)
{
bool Abrir;
serial.Close();
Abrir=serial.Open("COM1",CBR_9600);
if(!Abrir)
{
Application->MessageBoxA("Erro ao Abrir a Porta","Porta Serial", 48);
RBCom1->Checked=false;
LbCom->Caption="COM1 Ocupado!";
}
else
{
serial.ResetBuffer();
LbCom->Caption="COM1 Ativo!";
}
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::BtbSairClick(TObject *Sender)
{
if ((RBCom1->Checked) || (RBCom2->Checked))
serial.Close();
Close();
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::BitBtn2Click(TObject *Sender)
{
CMD= 114;
RetY=0;
AtualizaDados();
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::BitBtn5Click(TObject *Sender)
{
CMD= 110;
RetX=0;
AtualizaDados();
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::BitBtn8Click(TObject *Sender)
{
CMD= 116;
RetY=0;
AtualizaDados();
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::BitBtn7Click(TObject *Sender)
{
CMD= 112;
RetX=0;
AtualizaDados();
37
327:
328:
329:
330:
331:
332:
333:
334:
335:
336:
337:
338:
339:
340:
341:
342:
343:
344:
345:
346:
347:
348:
349:
350:
351:
352:
353:
354:
355:
356:
357:
358:
359:
360:
361:
362:
363:
364:
365:
366:
367:
368:
369:
370:
371:
372:
373:
374:
375:
376:
377:
378:
379:
380:
381:
382:
383:
384:
385:
386:
387:
388:
389:
390:
391:
392:
393:
394:
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::EditDeslcXChange(TObject *Sender)
{
if(EditDeslcX->Text!=" ")DeslX=(StrToInt(EditDeslcX->Text)/0.2538);
// 2.38 *
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::EditDeslcYChange(TObject *Sender)
{
if(EditDeslcY->Text!=" ")DeslY= (StrToInt(EditDeslcY->Text)/0.2538);
//0.943 *
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::FormCreate(TObject *Sender)
{
VelX= 2;
VelY= 3;
DeslX= 200;
DeslY= 200;
IntervX= 150; //Interrupção de X
IntervY= 100; //Interrupção de Y
RetX=0; //RetX
RetY=0;
ComprPn=60;
Calcular=false;
Analisar=false;
Memo->Clear();
Memo->Color=clScrollBar;
CMD=0;
RetX=0;
RetY=0;
IntervX=StrToInt(EditT_InterX->Text);
IntervY=StrToInt(EditT_InterY->Text);
CorLinhaEscolhida=1;
TabbedNotebook1->ActivePage="Automático";
VelX=3;
VelY=3;
LabelStatusComp->Caption=" ";
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::EditT_InterXChange(TObject *Sender)
{
if(EditT_InterX->Text!=" ")IntervX=StrToInt(EditT_InterX->Text);
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::EditT_InterYChange(TObject *Sender)
{
if(EditT_InterY->Text!=" ")IntervY=StrToInt(EditT_InterY->Text);
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::BitBtn6Click(TObject *Sender)
{
CMD= 122; //x e y positivo
RetX=0;
RetY=0;
AtualizaDados();
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::BitBtn3Click(TObject *Sender)
{
CMD= 124; //x positivo y negativo
RetX=0;
RetY=0;
AtualizaDados();
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::BitBtn1Click(TObject *Sender)
38
395: {
396: CMD= 118; //x e y negativo
397: RetX=0;
398: RetY=0;
399: AtualizaDados();
400: }
401: //----------------------------------------------------------------------402: void __fastcall TFrmPlotter::BitBtn4Click(TObject *Sender)
403: {
404: CMD= 120; //x negativo e y positivo
405: RetX=0;
406: RetY=0;
407: AtualizaDados();
408: }
409: //----------------------------------------------------------------------410: void __fastcall TFrmPlotter::BtbZeraPosicClick(TObject *Sender)
411: {
412: PosicaoInicial();
413: }
414: //----------------------------------------------------------------------415: void __fastcall TFrmPlotter::Configurar1Click(TObject *Sender)
416: {
417: FormSetup->ShowModal();
418: }
419: //----------------------------------------------------------------------420: void __fastcall TFrmPlotter::BtbSobePenaClick(TObject *Sender)
421: {
422: CMD= 126; //comando sobe pena
423: AtualizaDados();
424: }
425: //----------------------------------------------------------------------426: void __fastcall TFrmPlotter::BtbDescePenaClick(TObject *Sender)
427: {
428: CMD= 128; //comando desce pena
429: AtualizaDados();
430: }
431: //----------------------------------------------------------------------432: void __fastcall TFrmPlotter::EditDeslcYExit(TObject *Sender)
433: {
434:
435: }
436: //----------------------------------------------------------------------437: void __fastcall TFrmPlotter::Edit_AltPenaChange(TObject *Sender)
438: {
439: if(Edit_AltPena->Text!=" ")ComprPn=StrToInt(Edit_AltPena->Text);
440: }
441: //----------------------------------------------------------------------442: void __fastcall TFrmPlotter::SBAbrirClick(TObject *Sender)
443: {
444: AnsiString nome;
445: if (OpenDialog1->Execute())
446: {
447: Memo->Lines->LoadFromFile(OpenDialog1->FileName);
448: nome=OpenDialog1->FileName;
449: Caption="Plotter - "+nome; //insere o nome do arquivo no cabeçalho do
programa
450: Memo->Color=clWhite;
451: BtBInicia->Enabled=true;
452: AtualizaLinha();
453: }
454: }
455: //----------------------------------------------------------------------456: void __fastcall TFrmPlotter::BtBIniciaClick(TObject *Sender)
457: {
458: AnsiString hora;
459: hora=FormatDateTime("hh:mm:ss",Now());
460:
461: if((FrmPlotter->RBCom1->Checked)||(FrmPlotter->RBCom2->Checked))
39
462:
463:
464:
465:
466:
467:
468:
469:
470:
471:
472:
473:
474:
475:
476:
477:
478:
479:
480:
481:
482:
483:
484:
485:
486:
487:
488:
489:
490:
491:
492:
493:
494:
495:
496:
497:
498:
499:
500:
501:
502:
503:
504:
505:
506:
507:
508:
509:
510:
511:
512:
513:
514:
515:
516:
517:
518:
519:
520:
521:
522:
523:
524:
525:
526:
527:
528:
529:
{
TimerMain->Enabled=true;
BtbPausa->Enabled=true; //habilita botão Pausar
BtBAvanca->Enabled=true; //habilita botão Anvaçar
ReiniciaGauge();
ProximoReg=10;
LinhasExecutadas=0;
SBAbrir->Enabled=false; //desabilita botão de abrir arquivo
Passo = 1;
TimerMain->Enabled = true;
Analisar=false;//iniciar a compilaçao
Calcular = true;
Linha = StrToInt(EditLinhaExec->Text);
GaugeLinhas=0;
GaugeIlhas=0;
GaugeTotal=0;
FT1 = false;
}
else Application->MessageBoxA("Porta Serial não conectada!","Erro", 48);
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::BtbPausaClick(TObject *Sender)
{
if (BtbPausa->Caption=="Pausar")
{
BtbPausa->Caption="Continuar";
BtBReinicia->Enabled=true; //habilita botão Reiniciar
}
else
{
BtbPausa->Caption="Pausar";
BtBReinicia->Enabled=false; //desabilita botão Reiniciar
}
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::RBTopLayerClick(TObject *Sender)
{
CorLinhaEscolhida = 1;
AtualizaLinha();
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::RBBottomLayerClick(TObject *Sender)
{
CorLinhaEscolhida = 6;
AtualizaLinha();
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::RBTopOverlayClick(TObject *Sender)
{
CorLinhaEscolhida = 7;
AtualizaLinha();
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::RBBottomOverlayClick(TObject *Sender)
{
CorLinhaEscolhida = 8;
AtualizaLinha();
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::RBKeepOutLayerClick(TObject *Sender)
{
CorLinhaEscolhida = 12;
AtualizaLinha();
}
40
530:
531:
532:
533:
534:
535:
536:
537:
538:
539:
540:
541:
542:
543:
544:
545:
546:
547:
548:
549:
550:
551:
552:
553:
554:
555:
556:
557:
558:
559:
560:
561:
562:
563:
564:
565:
566:
567:
568:
569:
570:
571:
572:
573:
574:
575:
576:
577:
578:
579:
580:
581:
582:
583:
584:
585:
586:
587:
588:
589:
590:
591:
592:
593:
594:
595:
596:
597:
//----------------------------------------------------------------------void __fastcall TFrmPlotter::CBIlhasClick(TObject *Sender)
{
TamTotal= TamIlhas + TamLinhas;
if (!CBIlhas->Checked)
TamTotal=TamLinhas;
LbTotal->Caption="Total 1 de "+IntToStr(TamTotal);
CGauge3->ForeColor=clNavy;
CGauge3->Progress=0;
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::CBLinhasClick(TObject *Sender)
{
TamTotal= TamIlhas + TamLinhas;
if (!CBLinhas->Checked)
TamTotal=TamIlhas;
LbTotal->Caption="Total 1 de "+IntToStr(TamTotal);
CGauge3->ForeColor=clNavy;
CGauge3->Progress=0;
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::TimerMainTimer(TObject *Sender)
{
int X01, Y01, X1, Y1;
if(BtbPausa->Caption=="Pausar")
{
if (Passo==1)
{
if (Calcular)
{
RepeteLinha=false;
Analisar=true;
CalcularDados();
Calcular=false;
RepLinha=0;
}
EdtCmdPlotter->Text="Passo 1: Zerando Posição.";
PosicaoInicial();
Passo++;
}
if (Passo==2) //leve a pena no inicio do traço
{
if(Retorno==1)
{
Retorno=0;
EdtCmdPlotter->Text="Passo 2: Posicionando pena no inicio do traço."
Passo++;
PosicaoPena();
if(Calcular)
{
RepeteLinha=false;
Analisar=true;
CalcularDados();
Calcular=false;
}
}
}
if(Passo==3) //leve a pena no inicio do traço
{
if(Retorno==1)
{
Retorno=0;
Passo++;
PosicaoPena();
41
598:
599:
600:
601:
602:
603:
604:
605:
606:
607:
608:
609:
610:
611:
612:
613:
614:
615:
616:
617:
618:
619:
620:
621:
622:
623:
624:
625:
626:
627:
628:
629:
630:
631:
632:
633:
634:
635:
636:
637:
638:
639:
640:
641:
642:
643:
644:
645:
646:
647:
648:
649:
650:
651:
652:
653:
654:
655:
656:
657:
658:
659:
660:
661:
662:
663:
664:
665:
}
}
if(Passo==4) //Abaixar a pena
{
Passo++; //passo = 5 executa traço
PosicaoPena();
}
if(Passo==5) //Executa o traço
{
Passo++;
}
if(Passo==6) //Fim do traço
{
if(Retorno==1)
{
Retorno=0;
EdtCmdPlotter->Text="Traço finalizado.";
//ROTINA REPETE LINHAS
if((RepLinha<NumRepeticao->Value)&&(CBRepeticao->Checked))
{
CMD= 126; //comando sobe pena
AtualizaDados();
Sleep(250);
RepeteLinha=false;
Linha++;
EdtCoord->Text=Memo->Lines->Strings[Linha];
if((CBLinhas->Checked)&&(EdtCoord->Text=="FT"))
{
X1=X;
Y1=Y;
CalcDist();
if(CorLinhaEscolhida==CorLinha)
{
RepLinha++;
EdtCoord->Text=Memo->Lines->Strings[Linha
DeslX=X0-X1;
DeslY=Y0-Y1;
}
RepeteLinha=true;
Analisar=true;
Calcular=true;
Linha--;
Passo=2;
// IncrementaLinha();
Retorno=1;
}
else
{
RepLinha=0;
FT1=false;
RepeteLinha=false;
Calcular=true;
Passo=1;
}
}
else
{
RepLinha=0;
FT1=false;
RepeteLinha=false;
Calcular=true;
Passo=1;
}
}
}
42
666:
667:
668:
669:
670:
671:
672:
673:
674:
675:
676:
677:
678:
679:
680:
681:
682:
683:
684:
685:
686:
687:
688:
689:
690:
691:
692:
693:
694:
695:
696:
697:
698:
699:
700:
701:
702:
703:
704:
705:
706:
707:
708:
709:
710:
711:
712:
713:
714:
715:
716:
717:
718:
719:
720:
721:
722:
723:
724:
725:
726:
727:
728:
729:
730:
731:
732:
733:
}
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::CBRetXClick(TObject *Sender)
{
RetX=1;
CBRetX->Checked=false;
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::CBRetYClick(TObject *Sender)
{
RetY=1;
CBRetY->Checked=false;
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::BtBReiniciaClick(TObject *Sender)
{
Analisar=false;
Calcular=false;
Linha=0;
FT1=false;
Passo=0;
PosicaoInicial();
ReiniciaGauge();
SBAbrir->Enabled=true;
BtBInicia->Enabled=true;
BtbPausa->Enabled=false;
BtBReinicia->Enabled=false;
BtbPausa->Caption="Pausar";
BtBAvanca->Enabled=false;
TimerMain->Enabled=false;
EditLinhaExec->Text=0;
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::TimerIlha1Timer(TObject *Sender)
{
float CalErro;
static int RegPos, PosPadX, PosPadY, PadX, PadY, VelPadX, VelPadY;
bool CompHoriz;
if((CBIlhas->Checked)&&(BtbPausa->Caption=="Pausar"))
{
if(PassoIlha==1)
{
PassoIlha++;
Componente=0;
RegPos=0;
}
if((PassoIlha==2)&&(Retorno==1))
{
Retorno=0;
VelX=StrToInt(FormSetup->EditVelocX->Text);
VelY=StrToInt(FormSetup->EditVelocY->Text);
IntervX=StrToInt(FormSetup->EditTIntX->Text);
IntervY=StrToInt(FormSetup->EditTIntY->Text);
//vá para o centro do pad
DeslX = X0 - 25;
DeslY = Y0 - 20;
PosPadX=X0;
PosPadY=Y0;
PassoIlha++;
CMD = 122;//vá para o inicio do pad
RetX=0;
RetY=0;
AtualizaDados();
TamPadX = StrToInt(FormSetup->EditTamIlhaX->Text);
TamPadY = StrToInt(FormSetup->EditTamIlhaY->Text);
43
734: //velocidade de ir de um pad ao outro(velocidade menor para dar precisão)
735: VelPadX = 3;
736: VelPadY = 8;
737: PadX=TamPadX;
738: PadY=TamPadY;
739: }
740: //vá para o inicio do pad
741: if((PassoIlha==3)&&(Retorno==1))
742: {
743: Retorno=0;
744: VelX=StrToInt(FormSetup->EditVelocX->Text);
745: VelY=StrToInt(FormSetup->EditVelocY->Text)+5;
746: IntervX=StrToInt(FormSetup->EditTIntX->Text);
747: IntervY=StrToInt(FormSetup->EditTIntY->Text);
748: CMD= 128; //comando desce pena
749: AtualizaDados();
750: Sleep(300); //tempo obrigatorio para esperar o proximo comando
751: PassoIlha++;
752: RetX=0;
753: RetY=0;
754: VelX = VelPadX;
755: VelY = VelPadY;
756: CMD = 132;//comando para fazer o PAD
757: AtualizaDados();
758: }
759: if((PassoIlha == 4)&&(Retorno==1))
760: {
761: Retorno=0;
762: PassoIlha++;
763: CMD=126; //Comando sobe pena
764: AtualizaDados();
765: Linha++;
766: Linha++;
767: }
768: if(PassoIlha == 5)
769: {
770: EdtCoord->Text=Memo->Lines->Strings[Linha];
771: if((EdtCoord->Text =="CP")||(EdtCoord->Text == "FP")) //repete comando
772: {
773: CalcDist();
774: CompHoriz=false;
775: if(X0 == PosPadX)
776: {
777: CompHoriz=true;
778: if(PosPadY > Y0)
779: {
780: RegPos++;
781: Componente=1;
782: LabelStatusComp->Caption="Componente 1/Pos = "
783: if(RegPos ==4)
784: {
785: RegPos=0;
786: DeslY=(PosPadY - Y0)- StrToInt(FormSetup
787: }
788: else
789: DeslY=(PosPadY - Y0)- StrToInt(FormSetup
790:
791: OffSetPenaX=0;//Ainda não usado, a plotter não 792: OffSetPenaY=0;//Ainda
não usado, a plotter não 793: CMD=114; //segue o carro através deslocamento X
794: TamPadX =StrToInt(FormSetup->EditTamX1->Text);
795: TamPadY =StrToInt(FormSetup->EditTamY1->Text);
796: }
797: else
798: {
799: RegPos++;
800: Componente=2;
801: LabelStatusComp->Caption="Componente 2/Pos = "
802: if(RegPos ==4)
44
803: {
804: RegPos=0;
805: DeslY=(Y0 - PosPadY)+ StrToInt(FormSetup
806: }
807: else
808: DeslY=(Y0 - PosPadY)+ StrToInt(FormSetup
809:
810: OffSetPenaX=0;//Ainda não usado, a plotter não 811: OffSetPenaY=0;//Ainda
não usado, a plotter não 812: CMD= 116;//segue o carro através deslocamento X
813: TamPadX =StrToInt(FormSetup->EditTamX2->Text);
814: TamPadY =StrToInt(FormSetup->EditTamY2->Text);
815: }
816: IncrementaIlha();//atualiza o bargraf do pad
817: PosPadY=Y0;
818: VelX=StrToInt(FormSetup->EditVelocX->Text);
819: VelY=StrToInt(FormSetup->EditVelocY->Text)+5;
820:
821: RetX = 1;
822: RetY = 0;
823: AtualizaDados();
824: RetX=0;
825: RetY=0;
826: PassoIlha=3;
827: }
828: //faça o pad no sentido vertical
829: if ((Y0 == PosPadY)&&(!CompHoriz))
830: {
831: if(PosPadX > X0)
832: {
833: RegPos++;
834: Componente = 3;
835: LabelStatusComp->Caption="Componente 3/Pos = "
836: if(RegPos == 4)
837: {
838: RegPos=0;
839: DeslX = (PosPadX - X0) + StrToInt(FormSetup
840: }
841: else
842: DeslX = (PosPadX - X0) + StrToInt(FormSetup
843:
844: OffSetPenaX=0;//Ainda não usado, a plotter não 845: OffSetPenaY=0;//Ainda
não usado, a plotter não 846: CMD= 110;//retorna o carro para a origem X
847: TamPadX =StrToInt(FormSetup->EditTamX3->Text);
848: TamPadY =StrToInt(FormSetup->EditTamY3->Text);
849: VelX=StrToInt(FormSetup->EditVelocX->Text);
850: VelY=StrToInt(FormSetup->EditVelocY->Text)+5;
851: }
852: else
853: {
854: RegPos++;
855: Componente=4;
856: LabelStatusComp->Caption="Componente 4/Pos = "
857: if(RegPos==4)
858: {
859: RegPos=0;
860: DeslX = (X0 - PosPadX) + StrToInt(FormSetup
861: }
862: else
863: DeslX = (X0 - PosPadX) + StrToInt(FormSetup
864:
865: OffSetPenaX=0;//Ainda não usado, a plotter não necessitou
866: OffSetPenaY=0;//Ainda não usado, a plotter não necessitou
867: CMD= 112;//leva o carro da origem X
868: TamPadX =StrToInt(FormSetup->EditTamX4->Text);
869: TamPadY =StrToInt(FormSetup->EditTamY4->Text);
870: VelX=StrToInt(FormSetup->EditVelocX->Text);
871: VelY=StrToInt(FormSetup->EditVelocY->Text)+5;
872: }
45
873: IncrementaIlha();
874: PosPadX = X0;
875: RetX = 0;
876: RetY = 1;
877: AtualizaDados();
878: PassoIlha=3;
879: RetX=0;
880: RetY=0;
881: }
882: if((X0 != PosPadX)&&(Y0!=PosPadY))
883: {
884: PosicaoInicial();
885: RetX=0;
886: RetY=0;
887: RegPos=0;
888: Linha--;
889: Linha--;
890: Calcular=true;
891: FT1=true;
892: TimerIlha1->Enabled=false;
893: TimerMain->Enabled=true;
894: }
895: }
896: else
897: {
898: PosicaoInicial();
899: RetX=0;
900: RetY=0;
901: RegPos=0;
902: Calcular=true;
903: FT1=true;
904: TimerIlha1->Enabled=false;
905: TimerMain->Enabled=true;
906: }
907: }
908: }
909: }
910: //----------------------------------------------------------------------911: void __fastcall TFrmPlotter::TimerSerialTimer(TObject *Sender)
912: {
913: static int PosRec1, DadoRec,CalcX1, CalcX2, CalcX3, CalcY1,CalcY2,CalcY3,
DeslocamX, DeslocamY
914: static boolean recebe;
915:
916: AnsiString hora;
917: hora=FormatDateTime("hh:mm:ss",Now());
918:
919: if((FrmPlotter->RBCom1->Checked)||(FrmPlotter->RBCom2->Checked))
920: {
921: if(serial.BytesInQueue()!= 0)
922: {
923: BYTE x;
924: serial.Receive(&x, 1, 1000);
925: DadoRec=x;
926: if((DadoRec==201)&&(!recebe))
927: {
928: recebe=true;
929: PosRec1=0;
930: }
931: if(recebe)
932: {
933: PosRec1++;
934: switch(PosRec1)
935: {
936: case 2:CalcX1=DadoRec;break;
937: case 3:CalcX2=DadoRec;break;
938: case 4:CalcX3=DadoRec;break;
939: case 5:CalcY1=DadoRec;break;
46
940:
941:
942:
943:
944:
945:
946:
947:
948:
949:
950:
951:
952:
953:
954:
955:
956:
957:
958:
959:
960:
961:
962:
963:
964:
965:
966:
967:
968:
969:
970:
971:
972:
973:
974:
975:
976:
977:
978:
979:
980:
981:
982:
983:
984:
985:
986:
987:
988:
989:
990:
991:
992:
993:
994:
case 6:CalcY2=DadoRec;break;
case 7:CalcY3=DadoRec;break;
case 8:FrmPlotter->RetX=DadoRec;break;
case 9:FrmPlotter->RetY=DadoRec;break;
case 10:Retorno=DadoRec;
recebe=false;
if(LinhasExecutadas==ProximoReg)
{
ProximoReg+=10;
}
break;
}
}
}
}
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::BtbExecPadClick(TObject *Sender)
{
CMD= 132;//comando para executar pad
TamPadX=StrToInt(EditTestePadX->Text);
TamPadY=StrToInt(EditTestePadY->Text);
AtualizaDados();
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::BtbExecLinhaClick(TObject *Sender)
{
Linha=StrToInt(EditLinhaExec->Text);
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::BtBAvancaClick(TObject *Sender)
{
FT1=false;
Analisar=true;
CalcularDados();
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::T_AtualizaShapeTimer(TObject *Sender)
{
if (RetX) Shape6->Brush->Color=clGreen;
else Shape6->Brush->Color=clRed;
if (RetY) Shape7->Brush->Color=clGreen;
else Shape7->Brush->Color=clRed;
if (Retorno==1) Shape8->Brush->Color=clGreen;
else Shape8->Brush->Color=clRed;
}
//----------------------------------------------------------------------void __fastcall TFrmPlotter::CBRetornoClick(TObject *Sender)
{
Retorno=1;
CBRetorno->Checked=false;
}
//-----------------------------------------------------------------------
D.2 LINHAS DE CÓDIGO DO FORM VALORES:
1:
2:
3:
4:
5:
6:
7:
8:
9:
//----------------------------------------------------------------------#include <vcl.h>
#include <stdio.h>
#pragma hdrstop
#include "Prog_Plotter.h"
int X, X0, Y, Y0, CorLinha, EspLinha;
47
10:
11: extern int Linha, ComprX, ComprY;
12: //----------------------------------------------------------------------13:
14: #pragma package(smart_init)
15:
16: void CalcDist(void)
17: {
18: AnsiString Valor;
19: Linha++;
20: Valor=FrmPlotter->Memo->Lines->Strings[Linha];
21: sscanf(Valor.c_str(), "%d%d%d%d%d%d", &X0, &Y0, &X, &Y, &EspLinha,
&CorLinha);
22: ComprX=(X-X0);
23: ComprY=(Y-Y0);
24: }
25: //-----------------------------------------------------------------------
D.3 LINHAS DE CÓDIGO DO FORM SETUP:
1: //----------------------------------------------------------------------2: #include <vcl.h>
3: #include<stdio.h>
4: #pragma hdrstop
5:
6: #include "FrmSetup.h"
7: //----------------------------------------------------------------------8: #pragma package(smart_init)
9: #pragma resource "*.dfm"
10: TFormSetup *FormSetup;
11:
12: struct ArquivoDados{
13: char TamanhoX1[5];
14: char TamanhoY1[5];
15: char TamanhoX2[5];
16: char TamanhoY2[5];
17: char TamanhoX3[5];
18: char TamanhoY3[5];
19: char TamanhoX4[5];
20: char TamanhoY4[5];
21: char OffsetX1[5];
22: char OffsetY1[5];
23: char OffsetX2[5];
24: char OffsetY2[5];
25: char OffsetX3[5];
26: char OffsetY3[5];
27: char OffsetX4[5];
28: char OffsetY4[5];
29: char FatorX[10];
30: char FatorY[10];
31: char TamPadX[5];
32: char TamPadY[5];
33: char VelocX[5];
34: char VelocY[5];
35: char TIntX[5];
36: char TIntY[5];
37: char Reserva1[5];
38: char Reserva2[5];
39: char Reserva3[5];
40: char Reserva4[5];
41: };
42:
43: void CalculeAngulo(int angulo1);
44:
45: struct ArquivoDados DadosSetup;
46: char chrDados[1000];
47:
48
48: FILE *fpDados;
49: //----------------------------------------------------------------------50: __fastcall TFormSetup::TFormSetup(TComponent* Owner)
51: : TForm(Owner)
52: {
53: }
54: //----------------------------------------------------------------------55: void GravaRegistros()
56: {
57: String strDados;
58:
59: strDados = Format("%-3s",ARRAYOFCONST((FormSetup->EditTamX1->Text)))+
60: Format("%-3s",ARRAYOFCONST((FormSetup->EditTamY1->Text)))+
61: Format("%-3s",ARRAYOFCONST((FormSetup->EditTamX2->Text)))+
62: Format("%-3s",ARRAYOFCONST((FormSetup->EditTamY2->Text)))+
63: Format("%-3s",ARRAYOFCONST((FormSetup->EditTamX3->Text)))+
64: Format("%-3s",ARRAYOFCONST((FormSetup->EditTamY3->Text)))+
65: Format("%-3s",ARRAYOFCONST((FormSetup->EditTamX4->Text)))+
66: Format("%-3s",ARRAYOFCONST((FormSetup->EditTamY4->Text)))+
67: Format("%-3s",ARRAYOFCONST((FormSetup->EditOffset1_1->Text)))+
68: Format("%-3s",ARRAYOFCONST((FormSetup->EditOffset1_2->Text)))+
69: Format("%-3s",ARRAYOFCONST((FormSetup->EditOffset2_1->Text)))+
70: Format("%-3s",ARRAYOFCONST((FormSetup->EditOffset2_2->Text)))+
71: Format("%-3s",ARRAYOFCONST((FormSetup->EditOffset3_1->Text)))+
72: Format("%-3s",ARRAYOFCONST((FormSetup->EditOffset3_2->Text)))+
73: Format("%-3s",ARRAYOFCONST((FormSetup->EditOffset4_1->Text)))+
74: Format("%-3s",ARRAYOFCONST((FormSetup->EditOffset4_2->Text)))+
75: Format("%-9s",ARRAYOFCONST((FormSetup->EditFatorX->Text)))+
76: Format("%-9s",ARRAYOFCONST((FormSetup->EditFatorY->Text)))+
77: Format("%-3s",ARRAYOFCONST((FormSetup->EditTamIlhaX->Text)))+
78: Format("%-3s",ARRAYOFCONST((FormSetup->EditTamIlhaY->Text)))+
79: Format("%-3s",ARRAYOFCONST((FormSetup->EditVelocX->Text)))+
80: Format("%-3s",ARRAYOFCONST((FormSetup->EditVelocY->Text)))+
81: Format("%-3s",ARRAYOFCONST((FormSetup->EditTIntX->Text)))+
82: Format("%-3s",ARRAYOFCONST((FormSetup->EditTIntY->Text)));
83: sprintf(chrDados,"%s",strDados);
84:
85: fpDados = fopen("Setup.dat","w+");
86: fputs(chrDados, fpDados); //grava o arquivo em disco
87: fflush(fpDados);
88: fclose(fpDados);
89: }
90: void LeRegistro()
91: {
92: if(FileExists("Setup.dat"))
93: {
94: fpDados = fopen("Setup.dat","r+");
95: fgets(chrDados,100, fpDados);
96:
97: strncpy(DadosSetup.TamanhoX1,chrDados,3);
98: DadosSetup.TamanhoX1[5]='\0';
99: FormSetup->EditTamX1->Text=DadosSetup.TamanhoX1;
100:
101: strncpy(DadosSetup.TamanhoY1,&chrDados[3],3);
102: DadosSetup.TamanhoY1[5]='\0';
103: FormSetup->EditTamY1->Text=DadosSetup.TamanhoY1;
104:
105: strncpy(DadosSetup.TamanhoX2,&chrDados[6],3);
106: DadosSetup.TamanhoX2[5]='\0';
107: FormSetup->EditTamX2->Text=DadosSetup.TamanhoX2;
108:
109: strncpy(DadosSetup.TamanhoY2,&chrDados[9],3);
110: DadosSetup.TamanhoY2[5]='\0';
111: FormSetup->EditTamY2->Text=DadosSetup.TamanhoY2;
112:
113: strncpy(DadosSetup.TamanhoX3,&chrDados[12],3);
114: DadosSetup.TamanhoX3[5]='\0';
115: FormSetup->EditTamX3->Text=DadosSetup.TamanhoX3;
49
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
strncpy(DadosSetup.TamanhoY3,&chrDados[15],3);
DadosSetup.TamanhoY3[5]='\0';
FormSetup->EditTamY3->Text=DadosSetup.TamanhoY3;
strncpy(DadosSetup.TamanhoX4,&chrDados[18],3);
DadosSetup.TamanhoX4[5]='\0';
FormSetup->EditTamX4->Text=DadosSetup.TamanhoX4;
strncpy(DadosSetup.TamanhoY4,&chrDados[21],3);
DadosSetup.TamanhoY4[5]='\0';
FormSetup->EditTamY4->Text=DadosSetup.TamanhoY4;
strncpy(DadosSetup.OffsetX1,&chrDados[24],3);
DadosSetup.OffsetX1[5]='\0';
FormSetup->EditOffset1_1->Text=DadosSetup.OffsetX1;
strncpy(DadosSetup.OffsetY1,&chrDados[27],3);
DadosSetup.OffsetY1[5]='\0';
FormSetup->EditOffset1_2->Text=DadosSetup.OffsetY1;
strncpy(DadosSetup.OffsetX2,&chrDados[30],3);
DadosSetup.OffsetX2[5]='\0';
FormSetup->EditOffset2_1->Text=DadosSetup.OffsetX2;
strncpy(DadosSetup.OffsetY2,&chrDados[33],3);
DadosSetup.OffsetY2[5]='\0';
FormSetup->EditOffset2_2->Text=DadosSetup.OffsetY2;
strncpy(DadosSetup.OffsetX3,&chrDados[36],3);
DadosSetup.OffsetX3[5]='\0';
FormSetup->EditOffset3_1->Text=DadosSetup.OffsetX3;
strncpy(DadosSetup.OffsetY3,&chrDados[39],3);
DadosSetup.OffsetY3[5]='\0';
FormSetup->EditOffset3_2->Text=DadosSetup.OffsetY3;
strncpy(DadosSetup.OffsetX4,&chrDados[42],3);
DadosSetup.OffsetX4[5]='\0';
FormSetup->EditOffset4_1->Text=DadosSetup.OffsetX4;
strncpy(DadosSetup.OffsetY4,&chrDados[45],3);
DadosSetup.OffsetY4[5]='\0';
FormSetup->EditOffset4_2->Text=DadosSetup.OffsetY4;
strncpy(DadosSetup.FatorX,&chrDados[48],9);
DadosSetup.FatorX[10]='\0';
FormSetup->EditFatorX->Text=DadosSetup.FatorX;
strncpy(DadosSetup.FatorY,&chrDados[57],9);
DadosSetup.FatorY[10]='\0';
FormSetup->EditFatorY->Text=DadosSetup.FatorY;
strncpy(DadosSetup.TamPadX,&chrDados[66],3);
DadosSetup.TamPadX[5]='\0';
FormSetup->EditTamIlhaX->Text=DadosSetup.TamPadX;
strncpy(DadosSetup.TamPadY,&chrDados[69],3);
DadosSetup.TamPadY[5]='\0';
FormSetup->EditTamIlhaY->Text=DadosSetup.TamPadY;
strncpy(DadosSetup.VelocX,&chrDados[72],3);
DadosSetup.VelocX[5]='\0';
FormSetup->EditVelocX->Text=DadosSetup.VelocX;
strncpy(DadosSetup.VelocY,&chrDados[75],3);
DadosSetup.VelocY[5]='\0';
FormSetup->EditVelocY->Text=DadosSetup.VelocY;
50
184:
185: strncpy(DadosSetup.TIntX,&chrDados[78],3);
186: DadosSetup.TIntX[5]='\0';
187: FormSetup->EditTIntX->Text=DadosSetup.TIntX;
188:
189: strncpy(DadosSetup.TIntY,&chrDados[81],3);
190: DadosSetup.TIntY[5]='\0';
191: FormSetup->EditTIntY->Text=DadosSetup.TIntY;
192:
193: fclose(fpDados);
194: }
195: else Application->MessageBoxA("erro!","Erro ao abrir arquivo de Setup",
MB_OK);
196: }
197: void CalculeAngulo(int angulo1)
198: {
199: bool Verifica;
200: int Linha1;
201: AnsiString Texto, Numero, ValorAngulo;
202:
203: FormSetup->VelocX=2;
204: FormSetup->VelocY=10;
205: FormSetup->InterX=100;
206: FormSetup->InterY=100;
207:
208: Verifica=false;
209:
210: Linha1 = 0;
211: ValorAngulo="<"+ IntToStr(angulo1)+">";
212:
213: while (!Verifica)
214: {
215:
216: Texto=FormSetup->Memo1->Lines->Strings[Linha1];
217: if (Texto==ValorAngulo)
218: {
219: Linha1++;
220: Texto=FormSetup->Memo1->Lines->Strings[Linha1];
221: sscanf(Texto.c_str(), "%d%d%d%d", &FormSetup->VelocX, &FormSetup->VelocY
222: Verifica=true;
223: }
224: Linha1++;
225: }
226: }
227: //----------------------------------------------------------------------228: void __fastcall TFormSetup::EditTamX1Change(TObject *Sender)
229: {
230: BtbAceita->Enabled=true;
231: BtbCancela->Enabled=true;
232: }
233: //----------------------------------------------------------------------234: void __fastcall TFormSetup::BtbAceitaClick(TObject *Sender)
235: {
236: GravaRegistros();
237: BtbAceita->Enabled=false;
238: BtbCancela->Enabled=false;
239: }
240: //----------------------------------------------------------------------241: void __fastcall TFormSetup::BtbCancelaClick(TObject *Sender)
242: {
243: LeRegistro();
244: BtbAceita->Enabled=false;
245: BtbCancela->Enabled=false;
246: }
247: //----------------------------------------------------------------------248: void __fastcall TFormSetup::BtbOkClick(TObject *Sender)
249: {
250: if(BtbAceita->Enabled)
51
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
{
BtbAceita->Enabled=false;
BtbCancela->Enabled=false;
GravaRegistros();
}
Close();
}
//----------------------------------------------------------------------void __fastcall TFormSetup::FormCreate(TObject *Sender)
{
LeRegistro();
Memo1->Lines->LoadFromFile("Angulo.txt");
BtbCancelaAngulos->Enabled = false;
BtbAceitaAngulos->Enabled=false;
}
//----------------------------------------------------------------------void __fastcall TFormSetup::BtbAceitaAngulosClick(TObject *Sender)
{
Memo1->Lines->SaveToFile("Angulo.txt");
BtbCancelaAngulos->Enabled = false;
BtbAceitaAngulos->Enabled=false;
}
//----------------------------------------------------------------------void __fastcall TFormSetup::BtbCancelaAngulosClick(TObject *Sender)
{
Memo1->Lines->LoadFromFile("Angulo.txt");
BtbCancelaAngulos->Enabled = false;
BtbAceitaAngulos->Enabled=false;
}
//----------------------------------------------------------------------void __fastcall TFormSetup::Memo1Change(TObject *Sender)
{
BtbAceitaAngulos->Enabled=true;
BtbCancelaAngulos->Enabled=true;
}
//----------------------------------------------------------------------void __fastcall TFormSetup::BtbOKAngulosClick(TObject *Sender)
{
if(BtbAceitaAngulos->Enabled)
{
BtbCancelaAngulos->Enabled = false;
BtbAceitaAngulos->Enabled=false;
Memo1->Lines->SaveToFile("Angulo.txt");
}
Close();
}
//-----------------------------------------------------------------------
D.4 LINAS DE CÓDIGO DO FORM COMANDOS:
1: //----------------------------------------------------------------------2: #include <vcl.h>
3: #include <math.h>
4: //#include "Calcular.h"
5: #pragma hdrstop
6:
7: #include "Prog_Plotter.h"
8: #include "FrmSetup.h"
9:
10: void AtualizaDados(void);
11:
12: int Passo;
13:
14: extern int ComprX, ComprY, X, X0, Y, Y0, CorLinha, ResulVelX,
15: ResulVelY, ResulInterX, ResulInterY;
16:
17: extern bool grau;
52
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
//----------------------------------------------------------------------#pragma package(smart_init)
void PosicaoPena(void)
{
if (Passo==3) //leve a caneta no inicio do traço
{
if(FrmPlotter->RepeteLinha==false)
{
FrmPlotter->VelX=StrToInt(FormSetup->EditVelocX->Text);
FrmPlotter->VelY=StrToInt(FormSetup->EditVelocY->Text);
FrmPlotter->IntervX= StrToInt(FormSetup->EditTIntX->Text);
FrmPlotter->IntervY= StrToInt(FormSetup->EditTIntY->Text);
if((ComprX<0)&&(grau==false))
FrmPlotter->DeslX=X;
else
FrmPlotter->DeslX=X0;
if((ComprY<0)&&(grau==false))
FrmPlotter->DeslY=Y;
else
FrmPlotter->DeslY=Y0;
FrmPlotter->CMD= 122; //x e y positivo
FrmPlotter->RetX=0;
FrmPlotter->RetY=0;
AtualizaDados();
}
//Fazer o traço com repetição
if(FrmPlotter->RepeteLinha==true)
{
if((FrmPlotter->DeslX==0)&&(FrmPlotter->DeslY==0))
{
FrmPlotter->RetX=1;
FrmPlotter->RetY=1;
FrmPlotter->CMD = 0;
}
else
{
FrmPlotter->RetX=0;
FrmPlotter->RetY=0;
}
if ((FrmPlotter->DeslX==0)&&(FrmPlotter->DeslY<0))
{
FrmPlotter->CMD= 114;
FrmPlotter->RetX=1;
FrmPlotter->RetY=0;
}
if ((FrmPlotter->DeslX==0)&&(FrmPlotter->DeslY>0))
{
FrmPlotter->CMD= 116;
FrmPlotter->RetX=1;
FrmPlotter->RetY=0;
}
if((FrmPlotter->DeslX<0)&&(FrmPlotter->DeslY==0))
{
FrmPlotter->CMD= 110;
FrmPlotter->RetX=0;
FrmPlotter->RetY=1;
}
if((FrmPlotter->DeslX>0)&&(FrmPlotter->DeslY==0))
{
FrmPlotter->CMD= 112;
FrmPlotter->RetX=0;
FrmPlotter->RetY=1;
53
86: }
87: if((FrmPlotter->DeslX<0)&&(FrmPlotter->DeslY<0))
88: FrmPlotter->CMD= 118; //x e y negativo
89:
90: if((FrmPlotter->DeslX>0)&&(FrmPlotter->DeslY<0))
91: FrmPlotter->CMD= 124; //x positivo e y negativo
92:
93: if((FrmPlotter->DeslX>0)&&(FrmPlotter->DeslY>0))
94: FrmPlotter->CMD= 122; //x e y positivo
95:
96: if((FrmPlotter->DeslX<0)&&(FrmPlotter->DeslY>0))
97: FrmPlotter->CMD= 120; //x positivo y negativo
98:
99: if (FrmPlotter->DeslX<0)
100: FrmPlotter->DeslX*=-1;
101:
102: if (FrmPlotter->DeslY<0)
103: FrmPlotter->DeslY*=-1;
104:
105: FrmPlotter->VelX=StrToInt(FormSetup->EditVelocX->Text);
106: FrmPlotter->VelY=StrToInt(FormSetup->EditVelocY->Text)+ 3;
107: AtualizaDados();
108: }
109: }
110: if (Passo==4) //abaixar a pena
111: {
112: FrmPlotter->CMD=128;
113: AtualizaDados();
114: FrmPlotter->EdtCmdPlotter->Text="Passo 4: Fazendo o traço.";
115: Sleep(200);
116: }
117:
118: if (Passo==5) //inicio do traço
119: {
120: FrmPlotter->VelX=ResulVelX;
121: FrmPlotter->VelY=ResulVelY;
122: FrmPlotter->IntervX=ResulInterX;
123: FrmPlotter->IntervY=ResulInterY;
124:
125: if(!grau)//nao executa angulo
126: {
127: if(ComprX<0)
128: {
129: FrmPlotter->DeslX=ComprX*(-1);
130: FrmPlotter->CMD=110;//
131: FrmPlotter->RetX=0;
132: FrmPlotter->RetY=1;
133: }
134: if(ComprY<0)
135: {
136: FrmPlotter->DeslY=ComprY*(-1);
137: FrmPlotter->CMD=114;//
138: FrmPlotter->RetX=1;
139: FrmPlotter->RetY=0;
140: }
141: if(ComprX>0)//|.
142: {
143: FrmPlotter->DeslX=ComprX;
144: FrmPlotter->CMD=112; //
145: FrmPlotter->RetX=0;
146: FrmPlotter->RetY=1;
147: }
148: if(ComprY>0)//->
149: {
150: FrmPlotter->DeslY=ComprY;
151: FrmPlotter->CMD=116;//
152: FrmPlotter->RetX=1;
153: FrmPlotter->RetY=0;
54
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
}
AtualizaDados();
FrmPlotter->EdtCmdPlotter->Text="Passo 5: Executa traço.";
}
else //executa angulo
{
if((ComprX>0)&&(ComprY>0))
{
FrmPlotter->DeslX=ComprX;
FrmPlotter->DeslY=ComprY;
FrmPlotter->CMD=122;//
FrmPlotter->RetX=0;
FrmPlotter->RetY=0;
}
if((ComprX>0)&&(ComprY<0))
{
FrmPlotter->DeslX=ComprX;
FrmPlotter->DeslY=ComprY*(-1);
FrmPlotter->CMD=124;//
FrmPlotter->RetX=0;
FrmPlotter->RetY=0;
}
if((ComprX<0)&&(ComprY<0))
{
FrmPlotter->DeslX=ComprX*(-1);
FrmPlotter->DeslY=ComprY*(-1);
FrmPlotter->CMD=118;//
FrmPlotter->RetX=0;
FrmPlotter->RetY=0;
}
if((ComprX<0)&&(ComprY>0))
{
FrmPlotter->DeslX=ComprX*(-1);
FrmPlotter->DeslY=ComprY;
if(FrmPlotter->DeslY<13)
FrmPlotter->DeslY=13;
FrmPlotter->CMD=120; //
FrmPlotter->RetX=0;
FrmPlotter->RetY=0;
}
FrmPlotter->EdtCmdPlotter->Text="Passo 5: Executando traço.";
AtualizaDados();
}
}
}
void PosicaoInicial(void)
{
FrmPlotter->CMD= 126; //comando sobe pena
AtualizaDados();
Sleep(250);
FrmPlotter->CMD= 130;//Retornar posição inicial
FrmPlotter->VelX=StrToInt(FormSetup->EditVelocX->Text);
FrmPlotter->VelY= StrToInt(FormSetup->EditVelocY->Text);
FrmPlotter->IntervX= StrToInt(FormSetup->EditTIntX->Text);
FrmPlotter->IntervY= StrToInt(FormSetup->EditTIntY->Text);
FrmPlotter->RetX=0;
FrmPlotter->RetY=0;
AtualizaDados();
}
//-----------------------------------------------------------------------
D.5 LINHAS DE COMANDO DO FORM ANALISARDADOS:
1: //----------------------------------------------------------------------2: //#include <vcl.h>
55
3: #include <math.h>
4: #pragma hdrstop
5: #include "Prog_Plotter.h"
6: #include "FrmSetup.h"
7:
8: void CalcDist(void);
9: void IncrementaLinha(void);
10: void IncrementaIlha(void);
11: void CalculeAngulo(int angulo1);
12: void PosicaoInicial(void);
13:
14: int Linha, ComprX, ComprY,ResulVelX, ResulVelY, ResulInterX,ResulInterY;
15: bool Analisar, FT1, grau;
16:
17: extern int CorLinha, Passo;
18: //----------------------------------------------------------------------19: #pragma package(smart_init)
20: void CalcularDados(void)
21: {
22: int AngInt;
23: float ang, Vl1, Vl2;
24: double R;
25:
26: if(Analisar)
27: {
28: FT1=false;
29: while(!FT1)
30: {
31: FrmPlotter->EdtCoord->Text=FrmPlotter->Memo->Lines->Strings[Linha];
32: if(FrmPlotter->CBIlhas->Checked)
33: {
34: if((FrmPlotter->EdtCoord->Text=="FP")||(FrmPlotter->EdtCoord->T
35: {
36: CalcDist();//chama unit de calculo das distancias
37: FT1=true;
38: FrmPlotter->TimerMain->Enabled=false;
39: FrmPlotter->TimerIlha1->Enabled=true;
40: FrmPlotter->PassoIlha=1;
41: Passo=0;
42: IncrementaIlha();
43: }
44: if((FrmPlotter->EdtCoord->Text=="CT")||(FrmPlotter->EdtCoord->T
45: FT1=false;
46: }
47: if(FrmPlotter->CBLinhas->Checked)
48: {
49: if(FrmPlotter->EdtCoord->Text=="FT") //LInhas
50: {
51: FT1=false;
52: CalcDist();
53: if(FrmPlotter->CorLinhaEscolhida==CorLinha)//verificar
54: {
55: FrmPlotter->LinhasExecutadas++;
56: FT1=true;
57: FrmPlotter->EdtCoord->Text=FrmPlotter->Memo->Lines
58: if(FrmPlotter->RepeteLinha)
59: {
60: Passo=1;
61: }
62: Analisar=false;
63: IncrementaLinha();
64: }
65: if ((ComprX!=0)&&(ComprY!=0))
66: {
67: grau=true;
68: Vl1=ComprX;
69: Vl2=ComprY;
70: R=atan(Vl1 / Vl2); //em radianos
56
71: //conversão rad para graus
72: ang=(R/0.01745); //pi/180=0.01745
73:
74: if(ang<0) ang*=(-1);
75: AngInt= StrToInt(FormatFloat("000",ang
76:
77: CalculeAngulo(AngInt);
78: ResulVelX=FormSetup->VelocX;
79: ResulVelY=FormSetup->VelocY;
80: ResulInterX=FormSetup->InterX;
81: ResulInterY=FormSetup->InterY;
82: }
83: else
84: {
85: grau=false;
86: ResulVelX=StrToInt(FormSetup->EditVelocX->Text
87: ResulVelY=StrToInt(FormSetup->EditVelocY->Text
88: ResulInterX=StrToInt(FormSetup->EditTIntX->Text
89: ResulInterY=StrToInt(FormSetup->EditTIntY->Text
90: }
91: }
92: if((FrmPlotter->EdtCoord->Text=="FS")||(FrmPlotter->EdtCoord->T
93: FT1=false;
94: }
95: if (FrmPlotter->EdtCoord->Text=="ENDPCB")
96: {
97: FrmPlotter->Calcular=false;
98: Passo=0;
99: Linha=0;
100: FrmPlotter->CGauge1->ForeColor=clRed;
101: FrmPlotter->CGauge2->ForeColor=clRed;
102: FrmPlotter->CGauge3->ForeColor=clRed;
103:
104: FrmPlotter->BtBInicia->Enabled=true;
105: FrmPlotter->SBAbrir->Enabled=true;
106:
107: PosicaoInicial();
108: FrmPlotter->TimerMain->Enabled=false;
109: FrmPlotter->BtbPausa->Enabled=false;
110: FrmPlotter->BtBAvanca->Enabled=false;
111: FrmPlotter->BtBReinicia->Enabled=false;
112: FT1=true;
113: }
114: if (!FT1)
115: Linha++;
116: }
117: FrmPlotter->EdtNLinha->Text= IntToStr(Linha);
118: FrmPlotter->EditLinhaExec->Text= IntToStr(Linha);
119: }
120: }
212: //-----------------------------------------------------------------------
D.6 LINHAS DE CÓDIGO DO FORM SERIAL:
1: //----------------------------------------------------------------------2: // Projeto:
3: // Empresa:
4: //----------------------------------------------------------------------5: //
6: // Módulo:
7: // Arquivo:
8: // Autor:
9: // Descrição:
10: // Criado em:
11: // Histórico:
12: //
13: //----------------------------------------------------------------------14:
57
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
#ifndef _SERIAL_H_
#define _SERIAL_H_
//----------------------------------------------------------------------//
// Inclusão de Arquivos
//
//----------------------------------------------------------------------#include <vcl.h>
//----------------------------------------------------------------------//
// Definições e Macros
//
//----------------------------------------------------------------------//----------------------------------------------------------------------//
// Classes e Tipos
//
//----------------------------------------------------------------------class Serial
{
COMMTIMEOUTS m_OriginalTimeOuts;
char m_szCom[256];
DCB m_dcb;
HANDLE m_hSerial;
public:
Serial (void);
~Serial (void);
BOOL Open (char * szCom, int nBaudRate);
void Close (void);
BOOL Send (BYTE * lpbyBuffer, int nBufferLength, int nTimeout = 1000);
BOOL Receive (BYTE * lpbyBuffer, int nBufferLength, int nTimeout = 1000);
BOOL ResetBuffer (void);
DWORD BytesInQueue (void);
};
#endif //_SERIAL_H_
58
APÊNDICE E
D.1 LINHAS DE CÓDIGO PARA PIC
1: // PLOTER PARA CIRCUITO IMPRESSO TCC
2: //
3: //Projeto Ploter para circuito impresso com comunicação Serial
4: //
5: //
6: //Programa desenvolvido por: PAULO HENRIQUE VITORINO &
7: // HANDY BORGES
8: //
9: // Revisão: 1.02 -- 03/10/2008 -10: //
11: // ATUALIZAÇOES: ACERTADO POSIÇÕES DOS MOTORES PARA A PLACA NOVA PCI
12: //
13: //
14: //--------------------------------------------------------------15: #include <16f873A.h>
16: #use delay(clock=4000000)
17: #fuses XT,NOPROTECT,NOLVP,NOBROWNOUT, PUT
18: #use rs232(BAUD=9600, XMIT=PIN_C6,RCV=PIN_C7,BITS=8) // obrigatorio para
usar o serial
19:
20: // Definições I/O
21:
22: #define FimCursoYE PIN_A2//FIM DE CURSO Y MINIMO
23: #define FimCursoYD PIN_A1//FIM DE CURSO Y MAXIMO
24: #define FimCursoXE PIN_A0//FIM DE CURSO X MINIMO
25: #define FimCursoXD PIN_C5//FIM DE CURSO X MAXIMO
26: #define FimCursoPN Pin_A4//FIM DE CURSO ALTO DA PENA
27: #define PulsoX PIN_A3//ENCODER X
28: #define PulsoY Pin_A5//ENCODER Y
29: #define run PIN_C4//LED PISCA 'RUN'
30:
31: void Calcula_Desl(void);
32: void Calcula_Desl(void);
33: void tempoAtraz(void);
34:
35: //--------------------------------------------------------------36:
37: //declara as variaveis globais
38: int VelX, VelY, CalcX[4], CalcY[4];
39: // Velx e y é velocidade dos dois motores, CalX são os pacotes de dados do
comprimento de X, e
o mesmo para CalcY
40: int valorRX, TamPadX, TamPadY;
41: // valorRX armazenamento dos dados da serial, TapPadX é comprimento do pad
e TamPadY é a
largura do pad
42:
43: //ponteiros ou flags do programa T para tempo, rx recebimento de dados,
Eixo é moviemntação
dos eixos, ExecPad faz o pad, Pad é flag de rotida de execução do flag
44: boolean T_FimX, T_FimY, T_FimPN, rxDados, EixoX1, EixoX2, EixoY1, EixoY2,
SobePena, ExecPad,
Pad, PenaUp ;
45: //Stop é para parar o motor, CmdZera manda os motores para a referencia,
Flag atraso de um
eixo para inicio junto quando comando de angulo,
46: boolean StopX, StopY, StopPN, CmdZeraX, CmdZeraY, Flag1, Flag2, Flag4,
Flag5, led,
47: PenaDescanso, PenaAlta, Pulso1, Pulso2, Flag10, Flag11;
48:
49: int saida, saidaPn, RetX, RetY, Ret, RestoX, RestoY , AtrasoY1, AtrasoY2,
ValorAtraso;
59
50: int i, d, m, n, p, PassoPad, TDescPena, OffSetPenaX, OffSetPenaY, DeslPn,
ComprPn;
51:
52: unsigned int IntervX, IntervY;
53: // 16 bits = 32767 dec
54: int16 DeslX, DeslY, ComprX, ComprY, DeslPenaX, DeslPenaY, Var1X, Var2X,
Var1Y, Var2Y;
55:
56: // XXXX
57: byte const tabela1[]={0b00010000,//0
58: 0b00110000,//1
59: 0b00100000,//2
60: 0b01100000,//3
61: 0b01000000,//4
62: 0b11000000,//5
63: 0b10000000,//6
64: 0b10010000,//7
65: 0b00010000,//8
66: 0b00110000,//9
67: 0b00100000,//10
68: 0b01100000,//11
69: 0b01000000,//12
70: 0b11000000,//13
71: 0b10000000,//14
72: 0b10010000,//15
73: };
74: // YYYY
75: byte const tabela2[]={0b00000001,//0
76: 0b00000011,//1
77: 0b00000010,//2
78: 0b00000110,//3
79: 0b00000100,//4
80: 0b00001100,//5
81: 0b00001000,//6
82: 0b00001001,//7
83: 0b00000001,//8
84: 0b00000011,//9
85: 0b00000010,//10
86: 0b00000110,//11
87: 0b00000100,//12
88: 0b00001100,//13
89: 0b00001000,//14
90: 0b00001001,//15
91: };
92:
93: //---------- S U B R O T I N A S -------------------------94:
95: void enviadadosPC()
96: {
97: putchar(201);//valor 201 é um código o programa do PC
98: //se preparar para receber os pacotes
99: delay_ms(4);
100: //envia dados das Posições
101: putchar(CalcX[1]);
102: delay_ms(2);
103: putchar(CalcX[2]);
104: delay_ms(2);
105: putchar(CalcX[3]);
106: delay_ms(2);
107: putchar(CalcY[1]);
108: delay_ms(2);
109: putchar(CalcY[2]);
110: delay_ms(2);
111: putchar(CalcY[3]);
112: delay_ms(2);
113: putchar(RetX);
114: delay_ms(2);
115: putchar(RetY);
60
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
delay_ms(2);
putchar(Ret);
delay_ms(2);
}
#INT_RDA
void recebeRS232()
{
int i;
boolean Calcule;
ValorRx = getchar();
if (ValorRx == 200)
{
rxDados=true;
i=0;
Calcule=false;
}
if (rxDados)//recebe pacote de informações
{
i++;
switch(i)
{
case 2: VelX=ValorRx;break;
case 3: VelY=ValorRx;break;
case 4: RetX=ValorRX;break;
case 5: RetY=ValorRx;break;
case 6: Var1X =ValorRx;break;
case 7: Var2X =ValorRx;break;
case 8: RestoX=ValorRx;break;
case 9: Var1Y =ValorRx;break;
case 10:Var2Y =ValorRx;break;
case 11:RestoY=ValorRx;
Calcule=true;break;
case 12: IntervX= ValorRx;break;
case 13: IntervY= ValorRx;break;
case 14: ValorAtraso=ValorRX;break;
case 15: TamPadX = ValorRx;break;
case 16: TamPadY = ValorRx;break;
case 17: OffSetPenaX=ValorRx;break;
case 18: OffSetPenaY=ValorRx;break;
case 19: ComprPn=ValorRX;break;
case 20: T_FimX=false;
T_FimY=false;
if (ValorRx==110)
{
EixoX1=true;
DeslX=0;
}
if (ValorRx==112)
{
EixoX2=true;
DeslX=0;
}
if (ValorRx==114) //x positivo
{
EixoY1=true;
flag1=false;
atrasoY1=0;
DeslY=0;
}
if (ValorRx==116) //y negativo
{
EixoY2=true;
flag2=false;
atrasoY2=0;
DeslY=0;
};
if (ValorRX==118)//para a referencia
61
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
{
EixoX1=true;
EixoY1=true;
flag1=false;
atrasoY1=0;
DeslX=0;
DeslY=0;
}
if (ValorRX==120)
{
EixoX1=true;
EixoY2=true;
flag2=false;
atrasoY2=0;
DeslX=0;
DeslY=0;
}
if (ValorRX==122)
{
EixoX2=true;
EixoY2=true;
flag2=false;
atrasoY2=0;
DeslX=0;
DeslY=0;
}
if (ValorRX==124)
{
EixoX2=true;
EixoY1=true;
flag1=false;
atrasoY1=0;
DeslX=0;
DeslY=0;
}
if (ValorRx==126) Sobepena = true;
if (ValorRx==128) Sobepena = false;
if (ValorRx==130) //comando zerar pena
{
Sobepena = true;
CmdZeraX = true;
CmdZeraY = True;
}
if (ValorRx==132)
{
ExecPad = true;
PassoPad=1;
Pad = false;
}
rxDados=false;break;
}
}
if (Calcule)
{
ComprX=((long)((Var1X * Var2X)+RestoX));
ComprY=((long)((Var1Y * Var2Y)+RestoY));
Calcule=false;
}
ValorRx=0;//zere o comando
}
#int_timer0
void trata_t0 ()
{
static int conta, conta1, conta2;
// reinicia o timer 1 em 175
set_timer0(IntervX);
conta++;
62
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
conta1++;
conta2++;
if (conta >= velX)//intervalo eixo X
{
conta=0;
T_FimX=true;
}
if(conta1>= 100)
{
led=!led;
output_bit(run, led);
}
if(conta2>=3)//interrupção do motor da pena
{
conta2=0;
T_FimPN=true;
}
}
#int_timer2
void trata_t2 ()
{
static int conta1, conta2, Atraso;
// reinicia o timer 1 em 175
set_timer2(IntervY);
conta1++;
conta2++;
atraso++;
if (conta1 >= velY)//intervalo eixo Y
{
conta1=0;
T_FimY=true;
}
if(atraso>=2)
{
atraso=0;
if ((EixoY1)&&(!flag1))atrasoY1++;
if ((EixoY2)&&(!flag2))atrasoY2++;
}
}
void PulsoEncoderX(boolean frenteX)
{
//PULSO ENCODER EIXO X
if((input(PulsoX))&&(!Pulso1))//PULSO ENCONDER X
{
Pulso1=true;
if(frenteX)DeslPenaX++;
else DeslPenaX--;
}
if((!input(PulsoX))&&(Pulso1))
{
Pulso1=false;
if(frenteX)DeslPenaX++;
else DeslPenaX--;
}
}
void PulsoEncoderY(int1 frenteY)
{
//PULSO ENCONDER EIXO Y
if((input(PulsoY))&&(!Pulso2))//PULSO ENCONDER Y
{
Pulso2=true;
if(frenteY)DeslPenaY++;
else DeslPenaY--;
}
if((!input(PulsoY))&&(Pulso2))
{
Pulso2=false;
63
320: if(frenteY)DeslPenaY++;
321: else DeslPenaY--;
322: }
323: }
324: void MotorPnUp() //subrotina para subir o motor da pena
325: {
326: if (p>10) p=3;
327: p++;
328:
329: saidaPn=saidaPn & 240;
330: saidaPn=tabela2[p]^saidaPn;
331: output_c(saidaPn);
332: output_float(pin_c7);
333: output_float(pin_c6);
334: output_float(pin_C5);//COLOCA O PINO RC5 EM ALTA IMPEDANCIA (INPUT
PULSOX)
335: }
336: void MotorPnDn() //subrotina para descer o motor da pena
337: {
338: if (p<5) p=12;
339: p--;
340:
341: saidaPn=saidaPn & 240;
342: saidaPn=tabela2[p]^saidaPn;
343: output_c(saidaPn);
344: output_float(pin_c7);
345: output_float(pin_c6);
346: output_float(pin_C5);//COLOCA O PINO RC5 EM ALTA IMPEDANCIA (INPUT
PULSOX)
347: }
348: void MotorXFrente()
349: {
350: /* entrada = 10111001
351: 11110000 &
352: 10111001
353: -------354: 10110000 result
355: 10110000 'xou' ou exclusivo
356: 00000011
357: -------358: 10110011 result
359:
360: saida 10110011 */
361:
362: if(i<5)i=12;
363: i--;
364:
365: saida= saida & 240;//11110000
366: saida=tabela2[i] ^ saida;
367: output_b(saida);
368: }
369: void MotorXTras()
370: {
371: if(i>10)i=3;
372: i++;
373:
374: saida= saida & 240;//mascara '11110000'
375: saida=tabela2[i] ^ saida;
376: output_b(saida);
377: }
378: void MotorYFrente()
379: {
380: if(d<5)d=12;
381: d--;
382:
383: saida= saida & 15;//MASCARA '00001111'
384: saida=tabela1[d] ^ saida;
385: output_b(saida);
64
386: }
387: void MotorYTras()
388: {
389: if(d>10)d=3;
390: d++;
391:
392: saida= saida & 15;//00001111
393: saida=tabela1[d] ^ saida;
394: output_b(saida);
395: }
396: void ParaMotorX()
397: {
398: if(!StopX)
399: {
400: StopX=true;
401: saida= saida & 240;//mascara '11110000'
402: output_b(saida);
403: RetX=1;
404: Calcula_Desl();
405: if(RetY)
406: {
407: Ret=1;
408: EnviaDadosPC();
409: Ret=0;
410: }
411: }
412: }
413: void ParaMotorY()
414: {
415: if(!StopY)
416: {
417: StopY=true;
418: saida= saida & 15;//mascara '00001111'
419: output_b(saida);
420: RetY=1;
421: Calcula_Desl();
422: if(RetX)
423: {
424: Ret=1;
425: EnviaDadosPC();
426: Ret=0;
427: }
428: }
429: }
430: void ParaMotorPn()
431: {
432: if(!StopPn)
433: {
434: StopPn=true;
435: saidaPn= saidaPn & 240;//mascara '00001111'
436: output_c(saidaPn);
437: output_float(pin_c7); //seta pino para alta impedancia
438: output_float(pin_c6); //seta pino para alta impedancia (recebe dados da
serial)
439: output_float(pin_C5);//COLOCA O PINO RC5 EM ALTA IMPEDANCIA (INPUT
PULSOX)
440: }
441: }
442: void Calcula_Desl(void)
443: {
444: if (DeslPenaX>150)
445: {
446: CalcX[1]=150;
447: CalcX[2]= DeslPenaX / 150;
448: CalcX[3]= DeslPenaX % 150;//resto
449: }
450: else
451: {
65
452:
453:
454:
455:
456:
457:
458:
459:
460:
461:
462:
463:
464:
465:
466:
467:
468:
469:
470:
471:
472:
473:
474:
475:
476:
477:
478:
479:
480:
481:
482:
483:
484:
485:
486:
487:
488:
489:
490:
491:
492:
493:
494:
495:
496:
497:
498:
499:
500:
501:
502:
503:
504:
505:
506:
507:
508:
509:
510:
511:
512:
513:
514:
515:
516:
517:
518:
519:
CalcX[1]=DeslPenaX;
CalcX[2]=1;
CalcX[3]=0;
}
if (DeslPenaY>150)
{
CalcY[1]=150;
CalcY[2]= DeslPenaY / 150;
CalcY[3]= DeslPenaY % 150;//resto
}
else
{
CalcY[1]=DeslPenaY;
CalcY[2]=1;
CalcY[3]=0;
}
}
void tempoAtraz()
{
delay_ms(150);
}
void main()
{
//configura o timer 0 para clock interno e prescaler dividindo por 4
setup_timer_0 ( RTCC_INTERNAL | RTCC_DIV_4 );
setup_timer_2 ( T2_DIV_BY_1, 0xc0, 2);
set_timer0(150); // inicia o timer 0 em 150
set_timer0(150); // inicia o timer 2 em 150
enable_interrupts (global);// habilita interrupções
enable_interrupts (int_timer0);
enable_interrupts (int_Timer2);
enable_interrupts (int_rda);
m=12;
n=5;
i=5;
d=5;
ExecPad=false;
Pad=false;
DeslX=0;
DeslY=0;
DeslPenaX=0;
DeslPenaY=0;
EixoX1=false; EixoY1=false; EixoX2=false; EixoY2=false;
VelX=2;
VelY=7;
IntervX=150;
IntervY=150;
OffSetPenaX=0;
OffSetPenaY=0;
SobePena= true;
CmdZeraX=false;
CmdZeraY=false;
ValorAtraso=4;//valor teste para atrasar o eixo Y quando fazer diagonais
TDescPena=0;
atrasoY1=0;
atrasoY2=0;
Flag1=false;
Flag2=false;
Flag4=false;
Flag5=false;
PenaDescanso=false;
PenaAlta=false;
PenaUp=false;
DeslPn=0;
Ret=0;
66
520: //faça PENA subir na posição ALTA
521: while (!input(FimCursoPN))
522: {
523: if(T_FimPn)
524: {
525: T_FimPn=false;
526: MotorPnUp();
527: }
528: }
529: PenaUp=true;
530: DeslPn=0;
531: StopPn=false;
532: ParaMotorPn();
533:
534: While(true)
535: {
536: //*************** E X E C U T A P A D ****************************
537:
538: if(ExecPad)
539: {
540: DeslX=0;
541: DeslY=0;
542: while(!Pad)
543: {
544: if(PassoPad==1)
545: {
546: if(T_FimX)
547: {
548: if(DeslX >= TamPadX)
549: {
550: TamPadX= TamPadX + OffSetPenaX;
551: saida= saida & 240;//mascara
'11110000'
552: output_b(saida);
553: tempoAtraz();
554: PassoPad=2;
555: DeslX=0;
556: }
557: else
558: {
559: DeslX++;
560: MotorXFrente();
561: }
562: T_FimX=false;
563: T_FimY=false;
564: }
565: }
566: if(PassoPad==2)
567: {
568: if(T_FimY)
569: {
570: if(DeslY >= TamPadY)
571: {
572: saida= saida & 15;//mascara '00001111'
573: output_b(saida);
574: TamPadY= TamPadY + OffSetPenaY;
575: PassoPad=3;
576: DeslY=0;
577: tempoAtraz();
578: }
579: else
580: {
581: DeslY++;
582: MotorYFrente();
583: }
584: T_FimX=false;
585: T_FimY=false;
586: }
67
587: }
588: if(PassoPad==3)
589: {
590: if(T_FimX)
591: {
592: if(DeslX >= TamPadX)
593: {
594: saida= saida & 240;//mascara
'11110000'
595: output_b(saida);
596: PassoPad=4;
597: DeslX=0;
598: tempoAtraz();
599: }
600: else
601: {
602: DeslX++;
603: MotorXTras();
604: }
605: T_FimX=false;
606: T_FimY=false;
607: }
608: }
609: if(PassoPad==4)
610: {
611: if(T_FimY)
612: {
613: if(DeslY >= TamPadY)
614: {
615: Pad=true;
616: ExecPad=false;
617: RetX=1;
618: RetY=1;
619: StopY=false;
620: PenaUp=false;
621: SobePena=true;
622: delay_ms(100);
623: ParaMotorY();
624: DeslY=0;
625: }
626: else
627: {
628: DeslY++;
629: MotorYTras();
630: }
631: T_FimY=false;
632: }
633: }
634: }
635: }
636: //*************** Z E R A P E N A S *********************************
637: if (CmdZeraX)
638: {
639: if(T_FimX)
640: {
641: MotorXTras();
642: T_FimX=false;
643: }
644: }
645: if (input(FimCursoXE))
646: {
647: if (CmdZeraX)
648: {
649: StopX=false;
650: DeslPenaX=0;
651: DeslX=0;
652: ParaMotorX();
653: CmdZeraX=false;
68
654: }
655: }
656: //-------------------------####-----------------------------------------657: if (CmdZeraY)
658: {
659: if(T_FimY)
660: {
661: MotorYTras();
662: T_FimY=false;
663: }
664: }
665: if (input(FimCursoYE))
666: {
667: if (CmdZeraY)
668: {
669: StopY=false;
670: DeslPenaY=0;
671: DeslY=0;
672: ParaMotorY();
673: CmdZeraY=false;
674: }
675: }
676: //***********************************************************************
677: // CONTROLE DA PENA
678: //***********************************************************************
679: if((!Sobepena)&&(PenaUp)) //descer pena
680: {
681: if(T_FimPn)
682: {
683: T_FimPn=false;
684: if(DeslPn>ComprPn) //ComprPn é um valor que o borland envia
(dado pelo usuário)distancia de descida da pena
685: {
686: PenaUp=false;
687: StopPn=false;
688: ParaMotorPn();
689: DeslPn=0;
690: }
691: else
692: {
693: DeslPn++;
694: MotorPnDn();
695: }
696: }
697: }
698: if((Sobepena)&&(!PenaUp)) //subir pena
699: {
700: if(T_FimPn)
701: {
702: T_FimPn=false;
703: if (input(FimCursoPN))
704: {
705: PenaUp=true;
706: DeslPn=0;
707: StopPn=false;
708: ParaMotorPn();
709: }
710: else
711: MotorPnUp();
712: }
713: }
714: //***********************************************************************
715: if(EixoX1)//retorna para origem
716: {
717: PulsoEncoderX(false);
718: if(T_FimX)
719: {
720: T_FimX=false;
69
721:
722:
723:
724:
725:
726:
727:
728:
729:
730:
731:
732:
733:
734:
735:
736:
737:
738:
739:
740:
741:
742:
743:
744:
745:
746:
747:
748:
749:
750:
751:
752:
753:
754:
755:
756:
757:
758:
759:
760:
761:
762:
763:
764:
765:
766:
767:
768:
769:
770:
771:
772:
773:
774:
775:
776:
777:
778:
779:
780:
781:
782:
783:
784:
785:
786:
787:
788:
if(DeslX>= ComprX)
{
EixoX1=false;
StopX=false;
ParaMotorX();
DeslX=0;
}
else
{
MotorXTras();
DeslX++;
}
}
//Se encostou no sensor de zero, páre o motor
if (input(FimCursoXE))
{
T_FimX=0;
EixoX1=0;
DeslX=0;
DeslPenaX=0;
StopX=false;
ParaMotorX();
}
}
if(EixoX2)//sai da origem
{
PulsoEncoderX(true);
if(T_FimX)
{
T_FimX=false;
if(DeslX >= ComprX)
{
EixoX2=false;
StopX=false;
ParaMotorX();
DeslX=0;
}
else
{
MotorXFrente();
DeslX++;
}
}
//Se encostou no Fim curso máximo, páre o motor
if (input(FimCursoXD))
{
T_FimX=0;
EixoX2=false;
DeslX=0;
StopX=false;
ParaMotorX();
}
}
//*****************************************************
if (EixoY1)//RETORNA PARA ORIGEM
{
flag1=true;
if((input(PulsoY))&&(!Flag11))//PULSO ENCONDER Y
{
Flag11=true;
DeslPenaY--;
}
if((!input(PulsoY))&&(Flag11))
{
Flag11=false;
DeslPenaY--;
}
if(T_FimY)
70
789:
790:
791:
792:
793:
794:
795:
796:
797:
798:
799:
800:
801:
802:
803:
804:
805:
806:
807:
808:
809:
810:
811:
812:
813:
814:
815:
816:
817:
818:
819:
820:
821:
822:
823:
824:
825:
826:
827:
828:
829:
830:
831:
832:
833:
834:
835:
836:
837:
838:
839:
840:
841:
842:
843:
844:
845:
{
T_FimY=false;
if(DeslY >= ComprY)
{
EixoY1=false;
StopY=false;
ParaMotorY();
DeslY=0;
}
else
{
MotorYTras();
DeslY++;
}
}
//Se encostou no sensor de zero, páre o motor
if (input(FimCursoYE))
{
T_FimY=0;
EixoY1=false;
DeslY=0;
DeslPenaY=0;
StopY=false;
ParaMotorY();
}
}
if(EixoY2)//SAI DA ORIGEM
{
flag2=true;
if(T_FimY)
{
T_FimY=false;
if(DeslY>= ComprY)
{
EixoY2=false;
StopY=false;
ParaMotorY();
DeslY=0;
}
else
{
MotorYFrente();
DeslY++;
}
}
//Se encostou no Fim curso máximo, páre o motor
if (input(FimCursoYD))
{
T_FimY=0;
EixoY2=false;
DeslY=0;
StopY=false;
ParaMotorY();
}
}
}
}
71
APÊNDICE F
FIGURA 23 - Placa de potência do eixo Y
Fonte: Própria
FIGURA 24 - Desenho placa principal
Fonte: Própria
FIGURA 25 - Desenho do sensor óptico
Fonte: própria
72
REFERÊNCIA
ALVES, W. P. C++ Builder 6: desenvolva aplicações para Windows.
2ª ed. São Paulo: Erica, 2002.
LACERDA, J. M. Projetos eletrônicos com Circuitmaker (CM) e
TraxMaker(TM). Disponível em: <http://academicos.cefetmg.br/admin/down
loads/2115/apostilaCircTraxMakerAlfa-Parte1-18abril07.pdf> Acesso em: 14
abril 2008.
MEZENGA, B. Mezenga's Home Page. 2001. Disponível em:
<www.geocities.com/CollegePark/Dorm/8863/motordepasso.htm>. Acesso em:
07 de abril de 2008.
PROTEL INTERNATOINAL LIMITED. TraxMaker User Manual
1993–2000. Disponível em: <www.circuitmaker.com/pdfs/tm_usermanual.pdf>.
Acesso em: 14 abril 2008.
TEXAS INSTRUMENTS. MAX232. Março de 2004. Disponível em:
<www.alldatasheet.com/datasheet-pdf/pdf/27224/TI/MAX232.html> Acesso em:
23 de maio de 2008.
DUARTE, R. O. Comunicação Paralela e Serial. Disponível em:
<www.decom.iceb.ufop.br/prof/rduarte/CIC282/sem23.pdf> Acesso em: 23 de
maio de 2008.
WIKIPEDIA. Plotter. Disponível em <pt.wikipedia.org/wiki/Plotter>
Acesso em: 23 de maio de 2008.