TCC IMPRESSORA 3D

ESCOLA DE EDUCAÇÃO PROFISSIONAL SENAI PORTO ALEGRE

James Fraga

Karolyne Pereira

IMPRESSORA 3D

PORTO ALEGRE

2013

2

James e Karolyne

IMPRESSORA 3D

Trabalho de Conclusão apresentado para

obtenção do título de Técnico em

Eletrônica na Escola de Educação

Profissional SENAI Porto Alegre do Curso

Técnico em Eletrônica

Orientador: Fábio Matos Bock.

Coorientador: Tiago Leonardo Broilo.

Porto Alegre

2013

3

Agradecimentos

James Fraga:

Agradeço a Deus, a minha família, as minhas colegas Claudinete, Cintia

Deboráh, Lohana, Karolyne e Priscila que me ajudaram e me apoiaram durante

o curso. Agradeço também aos meus professores: Ronald, Melissa, Tiago e

Fábio que me ensinaram boa parte do que sei.

Karolyne Pereira:

Agradeço a Deus, à minha família e a todos que me ajudaram a concluir

este curso, incluindo meus professores (Ronald, Melissa, Fábio e Tiago),

minhas colegas Claudinete, Cintia, Deboráh, Lohana, Priscila e a minha dupla

James.

4

"Para uma mente bem estruturada, a morte é

apenas uma aventura seguinte."

Alvo Percival Wulfrico Brian Dumbledore

5

RESUMO

Nos dias de hoje, a prototipagem rápida é muito requerida em muitas

empresas. Assim, o projeto Impressora 3D tem como objetivos principais,

sendo uma máquina de prototipagem rápida, criar objetos a partir de plástico

PLA/ABS que podem ser utilizados em várias áreas e ter um custo baixo. A

impressora funciona a partir de uma plataforma de desenvolvimento, que é

programada com linguagem C, e se comunica com o computador através da

entrada USB. Assim, pode ser utilizado qualquer software 3D para fazer

desenhos de objetos e os softwares RepRap ou ReplicatorG para transferir o

gcode para a plataforma de desenvolvimento através do cabo USB,

transformando assim, o desenho 3D em um objeto real. Desta maneira, tem-se

então uma máquina que pode transformar seus pensamentos em realidade.

Um dos benefícios da Impressora 3D é que várias peças utilizadas para

realizar sua montagem são de plástico, ou seja, ela pode, de certo modo, se

replicar.

Palavras-chave: Impressora 3D, Objetos, Plástico, RepRap.

6

ABSTRACT

These days, rapid prototyping is very required in many companies. Thus, the

project 3D printer has as main objectives, being a rapid prototyping machine,

create objects from PLA/ABS plastic which can be used in many areas and

have a low cost. The printer works from a development platform, which is

programmed with C language, and communicates with the computer through

the USB port. So, any 3D software can be used to make 3D objects and used

RelicatorG or RepRap software to download the gcode for the development

platform via the USB cable, thus turning the 3D drawing into a real object. This

way, there is then a machine that can turn your thoughts into reality. One of the

benefits of the 3D printer is that various parts used to make their assembly are

plastic, so it can somehow replicate.

Keywords: 3D Printer, Objects, Plastic, RepRap.

7

LISTA DE FIGURAS

FIGURA 1 - Estado da arte .............................................................................. 15

FIGURA 2 - Microcontrolador PIC18F4550 ...................................................... 16

FIGURA 3 - Motor de Passo............................................................................. 17

FIGURA 4 - Motor de Passo Unipolar .............................................................. 18

FIGURA 5 - Motor de passo bipolar ................................................................. 21

FIGURA 6 - Driver Pololu ................................................................................. 22

FIGURA 7 - Mesa Aquecida ............................................................................. 23

FIGURA 8 - Sensor de fim-de-curso ................................................................ 24

FIGURA 9 - Termistor NTC .............................................................................. 25

FIGURA 10 - Interior de uma Extrusora ........................................................... 25

FIGURA 11 - Extrusora .................................................................................... 26

FIGURA 12 - Filamento PLA ............................................................................ 26

FIGURA 13 - Peças impressas ........................................................................ 29

FIGURA 14 - Montagem 1 ................................................................................ 30

FIGURA 15 - Montagem 2 ................................................................................ 30

FIGURA 16 - Montagem 3 ................................................................................ 30

FIGURA 17 - Montagem 4 ................................................................................ 30

FIGURA 18 - Montagem 5 ................................................................................ 31

FIGURA 19 - Montagem 6 ................................................................................ 31

FIGURA 20 - Montagem 7 ................................................................................ 31

FIGURA 21 - Montagem 8 ................................................................................ 31

FIGURA 22 - Montagem 9 ................................................................................ 32

FIGURA 23 - MONTAGEM 10 .......................................................................... 32

FIGURA 24 - MONTAGEM 11 .......................................................................... 32

FIGURA 25 - MONTAGEM 12 .......................................................................... 33

FIGURA 26 - MONTAGEM 13 .......................................................................... 33

FIGURA 27 - MONTAGEM 14 .......................................................................... 33

FIGURA 28 - MONTAGEM 15 .......................................................................... 34

FIGURA 29 - MONTAGEM 16 .......................................................................... 34

8

FIGURA 30 - MONTAGEM 17 .......................................................................... 34

FIGURA 31 - MONTAGEM 18 .......................................................................... 34

FIGURA 32 - MONTAGEM 19 .......................................................................... 35

FIGURA 33 - MONTAGEM 20 .......................................................................... 35

FIGURA 34 - MONTAGEM 21 .......................................................................... 35

FIGURA 35 - MONTAGEM 22 .......................................................................... 35

FIGURA 36 - MONTAGEM 24 .......................................................................... 36

FIGURA 37 - MONTAGEM 25 .......................................................................... 36

FIGURA 38 - MONTAGEM 26 .......................................................................... 36

FIGURA 39 - MONTAGEM 27 .......................................................................... 36

FIGURA 40 - MONTAGEM 28 .......................................................................... 37

FIGURA 41 - MONTAGEM 29 .......................................................................... 37

FIGURA 42 - MONTAGEM 30 .......................................................................... 37

FIGURA 43 - MONTAGEM 31 .......................................................................... 37

FIGURA 44 - MONTAGEM 32 .......................................................................... 38

FIGURA 45 - MONTAGEM 33 .......................................................................... 38

FIGURA 46 - MONTAGEM 34 .......................................................................... 38

FIGURA 47 - MONTAGEM 35 .......................................................................... 38

FIGURA 48 - MONTAGEM 36 .......................................................................... 39

FIGURA 49 - MONTAGEM 37 .......................................................................... 39

FIGURA 50 - MONTAGEM 38 .......................................................................... 39

FIGURA 51 - MONTAGEM 39 .......................................................................... 39

FIGURA 52 - MONTAGEM 40 .......................................................................... 39

FIGURA 53 - MONTAGEM 41 .......................................................................... 40

FIGURA 54 - MONTAGEM 42 .......................................................................... 40

FIGURA 55 - MONTAGEM 43 .......................................................................... 40

FIGURA 56 - MONTAGEM 44 .......................................................................... 41

FIGURA 57 - MONTAGEM 45 .......................................................................... 41

FIGURA 58 - MONTAGEM 46 .......................................................................... 42

FIGURA 59 - MONTAGEM 47 .......................................................................... 42

FIGURA 60 - Parte mecânica completa ........................................................... 42

FIGURA 61 - Plataforma de desenvolvimento.................................................. 43

FIGURA 62 - Layout da plataforma de desenvolvimento ................................. 44

FIGURA 63 - Placa após a corrosão ................................................................ 44

9

FIGURA 64 - Estrutura de um programa em C ................................................ 46

FIGURA 65 - ReplicatorG 0017 ........................................................................ 47

FIGURA 66 - Software MPLAB ........................................................................ 48

FIGURA 67 - Software Repic Beta ................................................................... 48

FIGURA 68 - Fluxograma ................................................................................. 49

10

LISTA DE TABELAS

TABELA 1 - Acionamento de um motor de passo unipolar .............................. 19

TABELA 2 - Atuação de um motor de passo unipolar (FULL-STEP) ............... 20

TABELA 3 - Acionamento de um motor de passo unipolar (Half-Step) ............ 20

TABELA 4 - Atuação de um motor de passo bipolar de 4 fases....................... 21

TABELA 5 - Cronograma ................................................................................. 28

TABELA 6 - Lista de preço do Hardware ......................................................... 45

11

SUMÁRIO

INTRODUÇÃO ................................................................................................. 13

OBJETIVOS ..................................................................................................... 14

ESTADO DA ARTE .......................................................................................... 15

1 FUNDAMENTAÇÃO TEÓRICA .............................................................. 16

1.1 PIC18F4550 ........................................................................................ 16

1.2 Motores ............................................................................................... 17

1.2.1 Motor de Passo ................................................................................... 17

1.3 Driver DRV8825 Pololu ....................................................................... 22

1.4 Mesa Aquecida ................................................................................... 23

1.5 Sensores de fim de curso .................................................................... 23

1.6 Termistor ............................................................................................. 24

1.7 Extrusora ............................................................................................. 25

1.8 Filamento PLA ..................................................................................... 26

1.9 Código G ............................................................................................. 27

2 METODOLOGIA ..................................................................................... 28

3 DESENVOLVIMENTO ............................................................................ 29

3.1 Mecânica ............................................................................................. 29

3.2 Hardware ............................................................................................. 43

3.2.1 Plataforma de Desenvolvimento ......................................................... 43

3.1 Software .............................................................................................. 45

3.1.1 ReplicatorG ......................................................................................... 46

3.1.2 MPLAB ................................................................................................ 47

3.1.3 Repic Beta ........................................................................................... 48

3.2 Firmware ............................................................................................. 49

CONCLUSÃO ................................................................................................... 50

REFERÊNCIAS BIBLIOGRÁFICAS ................................................................. 51

12

ANEXOS .......................................................................................................... 52

13

INTRODUÇÃO

A tecnologia da impressão 3D, também conhecida como prototipagem

rápida, surgiu na década de 80, mas só em 1990 começou a ganhar destaque.

Atualmente, as Impressoras 3D invadiram as indústrias de pequeno e grande

porte. Elas são mais rápidas, poderosas e mais fáceis de serem manipuladas

do que outras tecnologias de fabricação aditiva.

Este projeto possui como finalidade construir uma máquina com a

tecnologia de impressão 3D, com baixo custo e didática para ser utilizada em

ambientes que necessitem de uma prototipagem rápida. Neste relatório será

apresentado a fundamentação teórica de todos os componentes utilizados e o

desenvolvimento de Hardware, Software e Mecânico de como fazer uma

Impressora 3D passo a passo.

14

OBJETIVOS

Criar uma máquina de prototipagem rápida com baixo custo, principal

objetivo deste projeto, proporcionando uma facilidade maior de acesso. Tem a

capacidade de ser utilizada em diversas áreas, como: medicina, educação,

arquitetura, engenharia, alimentação e moda.

Assim, destaca-se também como objetivo construir um produto que

satisfaça todas as necessidades do consumidor. Trata-se de um protótipo com

comodidade, qualidade e segurança.

15

ESTADO DA ARTE

O estado da arte é o nível mais alto de desenvolvimento, seja de um

aparelho, de uma técnica ou de uma área científica. Para “estado da arte” do

nosso projeto, selecionamos a Mojo 3D Printer (conforme a Figura 1). Essa

impressora 3D é compacta o suficiente para caber em sua mesa e trazer a

impressão 3D ao alcance de todos, é tão simples de usar como uma

impressora jato de tinta, mas poderosa o suficiente para atender os mais altos

padrões de impressão 3D.

FIGURA 1 - ESTADO DA ARTE

16

1 FUNDAMENTAÇÃO TEÓRICA

A seguir estão os principais componentes utilizados na elaboração

deste trabalho, juntamente com sua respectiva definição.

1.1 PIC18F4550

O PIC18F4550 é um componente de 40 pinos com o encapsulamento

PDIP (Encapsulamento plástico em linha dupla). Esses pinos são divididos em

terminais de alimentação, reset, conexão com oscilador e os terminais de

portais e periféricos. Como se trata de um componente com diversas

características e um pequeno número de terminais, muitos terminais possuem

mais de uma função. Assim, temos terminais de entrada e saída junto com

terminal do oscilador, reset, etc. De uma maneira geral, quando usamos um

determinado periférico, o terminal associado a ele serve ao periférico e sua

função de entrada e saída fica desativada, quando o periférico não é utilizado,

o terminal trabalha como I/O (Entrada ou saida).

Esse é um microcontrolador bastante parecido com o PIC16F877A com

a diferença de que ele pode se comunicar através porta USB. Ele possui 13

conversores analógicos, pode se comunicar com cartão de memória dos tipos

de câmeras e celulares e consegue trabalhar a uma frequência de até 48MHz.

FIGURA 2 - MICROCONTROLADOR PIC18F4550

17

1.2 Motores

O acionamento dos movimentos fica por conta de cinco motores de

passo de 200 passos por revolução e 4kgfcm de torque. Um motor de passo

para o movimento linear do eixo X, um no Z, dois no Y e um para extrusora.

Neste projeto, os motores de passo são acionados por drivers, leia

mais no item 1.3. Eles atuam conforme os comandos do Código G, estes

códigos são processados e enviados para a plataforma de desenvolvimento,

que por sua vez converte o mesmo em movimentos. Sendo que a

movimentação é controlada por micropassos, ou seja, o motor normal possui

1.8º por passo, o driver de controle do motor de passo pode dividir em até 1/16

cada passo, 1.8º dividido por 16 é igual a 0,1125º por passo.

FIGURA 3 - MOTOR DE PASSO

1.2.1 Motor de Passo

Um motor de passo consiste em um motor DC de magnetos

permanentes ou relutância variável que apresenta rotação em ambas as

direções, variações incrementais de precisão angular, repetição de movimentos

exatos, um torque de sustentação à velocidade zero e a possibilidade de serem

controlados digitalmente através de um hardware específico ou de um

software. Eles são encontrados em aparelhos onde a precisão é um fator muito

18

importante, como impressoras, scanners, discos rígidos e muitos outros

aparelhos.

Os motores de passo podem ser bipolares (requerem fontes de

alimentação simétrica) ou unipolares (requerem apenas uma fonte de

alimentação).

Em ambos os casos as fontes utilizadas são de tensão contínua e

requerem um circuito digital que produza as sequências para produzir a rotação

do motor. Para o controle do motor de passo nem sempre é necessária a

implementação de uma estratégia de realimentação, mas a utilização de um

encoder ou de outro sensor de posição poderá assegurar uma melhor exatidão.

A vantagem de operar sem realimentação é que não é mais necessário ter um

sistema de controle em malha fechada.

1.2.1.1 Motores de Passo Unipolares

São facilmente reconhecidos pela derivação ao centro de cada um dos

enrolamentos. O número das fases é duas vezes o número de bobinas, uma

vez que cada bobina se encontra dividida em duas. Na figura abaixo, tem-se a

representação de um motor de passo unipolar de 4 fases. Normalmente, a

derivação central dos enrolamentos está ligada ao terminal positivo da fonte de

alimentação e os extremos de cada enrolamento são ligados alternadamente

ao terra para inverter a direção do campo gerado por cada um dos

enrolamentos.

FIGURA 4 - MOTOR DE PASSO UNIPOLAR

O enrolamento 1 encontra-se distribuído entre o pólo superior e o pólo

inferior do estator do motor, enquanto que o enrolamento 2 encontra-se

19

distribuído entre o pólo esquerdo e o pólo direito do estator. O rotor é um

magneto permanente de seis polos (3 sul e 3 norte), dispostos ao longo da

circunferência do rotor. Para uma resolução angular maior, o rotor deve

possuir mais pólos.

Como é apresentado na figura acima, a corrente a fluir da derivação

central do enrolamento 1 para o terminal “a” faz com que o pólo superior do

estator seja um pólo norte enquanto que o pólo inferior seja um pólo sul. Esta

situação provoca uma deslocação do rotor para a posição que foi indicada na

figura 4. Se for removida a alimentação do enrolamento 1 e for alimentado o

enrolamento 2, o rotor irá deslocar-se um passo, ou seja 30º. Para obter uma

cotação completa, deverão ser alimentados alternadamente os enrolamentos

do motor. Na tabela abaixo, tem-se a atuação de um motor de passo unipolar

realizando uma lógica positiva, em que o valor lógico 1 significa passar

acorrente em um dos enrolamentos. A sequência apresentada na figura abaixo

produzirá uma deslocação dos 4 passos.

TABELA 1 – ACIONAMENTO DE UM MOTOR DE PASSO UNIPOLAR

Este é o tipo de acionamento padrão, para atuar além do padrão é

possivel utilizar outra estratégia de acionamento, em que o torque produzido é

duas vezes maior. Neste tipo, são acionadas ao mesmo tempo 2 bobinas para

cada passo. O que diferencia é que o consumo é duas vezes superior do que o

acionamento padrão. Esta estratégia de comando encontra-se na tabela 2.

A B C D

1 1 0 0 0

2 0 1 0 0

3 0 0 1 0

4 0 0 0 1

20

TABELA 2 - ATUAÇÃO DE UM MOTOR DE PASSO UNIPOLAR (FULL-STEP)

Um acionamento alternativo consiste em alimentar, alternadamente um e

dois enrolamentos, permitindo avançar meio passo de cada vez. Este tipo de

atuação é chamado de meio-passo ou half-step. Nessa atuação, como se pode

verificar, é duplicado o número de passos para completar uma revolução. Na

realidade passamos a deslocar o rotor em apenas meios passos, ou seja, o

rotor desloca-se 15º por cada atuação. Na tabela abaixo é apresentada uma

atuação do tipo half-step para os mesmos 120º de deslocação do rotor.

TABELA 3 - ACIONAMENTO DE UM MOTOR DE PASSO UNIPOLAR (HALF-STEP)

A B C D

1 1 1 0 0

2 0 1 1 0

3 0 0 1 1

4 1 0 0 1

A B C D

1 1 0 0 0

2 1 1 0 0

3 0 1 0 0

4 0 1 1 0

5 0 0 1 0

6 0 0 1 1

7 0 0 0 1

8 1 0 0 1

21

1.2.1.2 Motores de Passo Bipolares

Os motores de passo bipolares, diferentes dos unipolares, requerem um

circuito de atuação bem mais complexo. Eles são conhecidos pelo seu

excelente torque. Pois, proporcionam um maior torque comparativamente a um

motor unipolar do mesmo tamanho.

FIGURA 5 - MOTOR DE PASSO BIPOLAR

São constituídos por enrolamentos separados que devem ser atuados

em ambas as direções para permitir avanço de um passo, ou seja, a polaridade

deve ser invertida durante o funcionamento do motor. O padrão de atuação do

driver é semelhante ao obtido para o acionamento padrão do motor de passo

unipolar, mas ao invez de 0 e 1, temos o sinal da polaridade que é aplicada nas

bobinas. Abaixo tem-se um exemplo de atuação do motor.

TABELA 4 - ATUAÇÃO DE UM MOTOR DE PASSO BIPOLAR DE 4 FASES

A B C D

1 + - - -

2 - + - -

3 - - + -

4 - - - +

22

1.3 Driver DRV8825 Pololu

O DRV8823 é um driver de motor de passo utilizado em impressoras,

scanners e outras aplicações de equipamentos automatizados. O dispositivo

tem duas ponte H e pode conduzir um motor de passo unipolar, bipolar ou dois

de corrente contínua. Possui uma função de desligamento interno que é

fornecida para proteção contra curto circuito, bloqueio por subtensão e

superaquecimento.

Este driver possui também como características: interface de controle

de passo simples; seis diferentes resoluções; controle de corrente ajustável

permitindo a utilização de voltagens superiores à capacidade do motor;

voltagem máxima de 45V; desligamento por superaquecimento, sobrecorrente

e travamento por sub-voltagem; proteção contra curtos ao terra e de

alimentação em curto, etc.

O CI DRV8825 possui uma taxa máxima de corrente de 2,5A por

bobina, mas a corrente real que você pode fornecer ao motor depente da

capacidade de manter o chip refrigerado. A placa de circuito impresso foi

desenvolvida para drenar calor do chip mas para oferecer mais do que 1A por

bobina é necessário colocar um dissipador de calor ou utilizar outro método de

refrigeração.

Abaixo segue uma imagem do driver utilizado.

FIGURA 6 - DRIVER POLOLU

23

1.4 Mesa Aquecida

A mesa aquecida numa Impressora 3D tem o propósito de evitar que a

peça tenha uma deformação na base. Não são todos os tipos de materiais que

sofrem desse problema, mas alguns materiais comuns como o ABS e PLa tem

resultado melhor quando são impressos em mesas aquecidas.

Algumas impressoras 3D industriais controlam a temperatura e

umidade do filamento plástico para diminuir a variação de qualidade durante a

impressão. Existem também impressoras que isolam a área de impressão do

ambiente, com câmaras que controlam a temperatura e a umidade.

FIGURA 7 - MESA AQUECIDA

1.5 Sensores de fim de curso

Os sensores de fim de curso são importantes para determinar os

limites máximos e mínimos da mesa evitando que o motor chegue aos limites

físicos e acabe colocando em risco todo o circuito de potência.

Cada um dos eixos possui um sensor de fim de curso que serve como

referência para o controlador. O posicionamento dos sensores dos Eixos X e Y

deve ser feito de forma com que eles sejam acionados assim que o bico

extrusor abandone a área imprimível, eles marcam o início do eixo. Já o do

24

eixo Z deve ser feito de forma a impedir que o bloco extrusor atinja a parte

superior da estrutura da impressora, e marca o término do eixo.

FIGURA 8 - SENSOR DE FIM DECURSO

1.6 Termistor

Na maioria dos RepRap, um termistor detecta a temperatura na

extrusora e um segundo termistor detecta a temperatura da mesa aquecida.

Termistores são resistores que variam a resistência de acordo com a

temperatura. Assim, eles podem serem utilizados como proteção contra

sobreaquecimento, limitando a corrente elétrica quando determinada

temperatura é ultrapassada. Outro tipo de aplicação é em medição de

temperatura em motores, pois obtem-se uma variação de uma grandeza

elétrica em função da temperatura a que este se encontra. No ar condicionado

também é utilizado o termistor para controle de temperatura.

Existem dois tipos de termistores:

NTC (Coeficiente de Temperatura Negativa) – São termistores cujo coeficiente

de variação da resistencia é negativo, ou seja, a resistência diminui com o

aumento da temperatura.

PTC (Coeficiente de Temperatura Positiva) – São termistores cujo coeficiente

de variação de resistencia é positivo, ou seja, a resistência aumenta com o

aumento da temperatura.

25

FIGURA 9 - TERMISTOR NTC

1.7 Extrusora

A extrusora é a parte da Impressora 3D que é responsavel pela

aplicação do plástico aquecido em pequenas camadas na mesa aquecida. A

extremidade fria força o filamento no interior da extremidade quente para

dentro da câmara de aquecimento e o plástico ABS/PLA sai pelo orifício de

0,5mm.

O calor necessário é por folta de 20W com temperaturas entre 150 a

250ºC. Para o controle desta temperatura, é utilizado um termistor ligado perto

do bico.

FIGURA 10 – INTERIOR DE UMA EXTRUSORA

26

FIGURA 11 - EXTRUSORA

1.8 Filamento PLA

As impressoras 3D em geral utilizam um filamento de plástico como

“tinta” para criar objetos. Para este projeto foi escolhido o PLA (Polylactic Acid),

que é um polímero bioplástico, obtido a partir do açúcar presente em grãos

como o milho.

Este material apresenta um ótimo desempelho estético e é o mais

recomendado para aplicações gerais. Outro material que pode ser utilizado é o

ABS, um plástico derivado de petróleo com excelente resistência mecânica. No

entando, este material trabalha com uma temperatura mais alta que o PLA e é

muito sensível a umidade e à temperatura ambiente. É recomendado apenas

para usuários experientes.

FIGURA 12 - FILAMENTO PLA

27

1.9 Código G

O sistema de linguagem ISO, também conhecido como “Linguagem de

Código G”, é a forma utilizada para escrever os programas de usinagem CNC,

ou seja, é por meio dessa linguagem de programação que as máquinas CNC

entendem os comandos e as coordenadas para executar a usinagem de peças.

No projeto Impressora 3D, a linguagem utilizada para movimentar os

motores foi a Linguagem de Código G. Abaixo segue um exemplo do Código G.

N1 G43 H05

N2 M03

X0 Y0 Z2

N3 T1 M6

N4 S2000 M3

N5 G0 X125. Y33. 872

N6 Z2.

N7 Z-38.419

N8 G1 Z-40.419 F1000.

28

2 METODOLOGIA

Foi elaborado um cronograma, para organização e disposição dos

horários. Definimos horários como base para cada processo do projeto. Este

cronograma pode ser visto na tabela abaixo:

TABELA 5 - CRONOGRAMA

Atividades Setembro Outubro Novembro

S1 S2 S3 S4 S1 S2 S3 S4 S1 S2 S3 S4

Delimitação do Tema x x x Relatório x x x x x x x

Elaboração do Hardware x x Compra dos componentes* x x Desenvolvimento da Repic x Elaboração da Mecânica** x x x x

Integração (Hardware + Mecânica) x x Correção de Erros x x

Elaboração do Fluxograma x Elaboração Power Point x x

Apresentação para Banca x Legenda: S = Semana

*Material concedido pelo ensino superior

**Realizada pelo ensino superior

29

3 DESENVOLVIMENT O

3.1 Mecânica

É um conjunto de peças que são ligadas entre si, formando o protótipo

do projeto. Para começar a montagem, foi impressa as peças necessárias com

outra Impressora 3D.

FIGURA 13 - PEÇAS IMPRESSAS

Em seguida, foi montado o corpo da impressora 3D. Montando

primeiramente duas bases. Foi colocado dois parafusos nos furos, anexado

duas porcas. (Utilizando outro parafuso para inserir a porca a partir do outro

lado). Insirido duas porcas nos orifícios para a fixação e rolamento.

30

FIGURA 14 - MONTAGEM 1


Após isso foi posto uma barra e os parafusos inseridos anteriormente

para apertá-lo.


Foi inserido dois rolamentos lineares em cima da base Usou-se dois

suportes de rolamento, parafusos e arruelas. Logo após parafusou-se dois

parafusos curtos de um lado do motor e o outro lado não foi fixado.


No passo seguinte foram colocadas as barras rosqueadas junto aos

acoplamentos dos motores, adicionado uma arruela e, em seguida, uma porca

em ambos os lados para fixar a barra roscada.

31




Foi inserido um parafuso na parte inferior do acoplador para fixar o eixo

do motor e na parte superior foi colocada a porca que irá fixar a barra roscada


32

Foi feito tudo de novo para a segunda base.


Para ligar as duas bases foi adicionado uma porca e uma arruela para

ambas as hastes rosqueadas (perto do centro). Em seguida, foi adicionado o

suporte do outro motor e, novamente, uma arruela e uma porca.


Também foi posto uma porca e uma arruela no outro lado a partir de

ambas as barras roscadas. Em seguida, adicionado reboque e, novamente,

uma arruela e uma porca .


33

Foi posto uma arruela em ambas as hastes nos dois lados e inserido

as barras nas duas bases. Prendendo-as com outra arruela e porca. Todas as

porcas ficaram um pouco soltas, para assim poder ajustar o espaçamento

depois.


Após isso foi adicionado o motor ao suporte com quatro parafusos e

cinco arruelas por parafuso.


Foi parafusado através de um dos orifícios da polia e fixado a polia

para o eixo do motor .


34

Após isso, foi pego dois parafusos e adicionado uma arruela, um

rolamento, um reboque, e duas arruelas. Em seguida, colocado os dois

parafusos na parte do reboque Y e adicionado uma porca em ambos os

parafusos para fixá-lo no lugar (não prendendo demais para o reboque poder

virar).




Para o eixo X foram colocados dois rolamentos em ambas as

extremidades do carro.


35

No passo seguinte, foi posto três rolamentos nas partes x-carro e

adicionado graxa para um melhor movimento. Em seguida, foi empurrado as

duas hastes lisas do eixo X através das peças do carro-x.



Nesta etapa, foi usado um parafuso e adicionado uma arruela , um

rolamento, uma polia de tensão e duas arruelas. Foi empurrado esta pilha

através da parte final de x com suporte do motor e adicionado o sinalizador de

fim de curso e prendido com uma porca. Então, foi fixado este parafuso até que

não fosse mais possível virar as hastes lisas do eixo X.



36

Para continuar o processo de montagem, foi usado um parafuso e

adicionado uma arruela, um rolamento, uma polia de tensão e duas arruelas .

Após isso foi empurrado esta pilha através da outra parte final de x e corrigido

com uma porca. Foi apertado este parafuso até as hastes lisas do eixo x serem

fixadas bem. Em seguida, foi adicionado o sensor de fim de curso a esse

parafuso e fixado com uma porca e arruelas.



Foi adicionado o motor à extrusora com o suporte do motor. Usado

parafusos e arruelas para prendê-lo. Então, foi adicionado a polia do motor e

fixado com um parafuso.



37

Para colocar o eixo X na base foi colocado uma porca em ambas as

hastes rosqueadas diretamente no final.


Foi levantado as duas hastes do eixo x, engatado nas hastes do eixo y

e rosqueadas até chegar nas porcas.



Foi utilizado um cinto para fazer um pequeno laço em uma extremidade

com os dentes voltados para fora. Foi formado um segundo pequeno um laço

do outro lado. Foi utilizado um terceiro laço para conectar ambos os laços e

fixá-los de modo que o cinto ficasse sobre pouco tensão.


38

Foi apertado o cinto na ranhura do carro como visto na foto. Também

foi empurrado um parafuso no furo, e anexado uma porca no outro lado.



A extrusora foi presa com parafusos, arruelas e porcas no carro. No

lado não-motorizado foi adicionado o sinalizador de fim-de-curso antes da

porca.



39

Para colocar a mesa aquecida e acabamento da impressora foi

empurrado as duas hastes suavemente através dos rolamentos na base.


Também foi adicionado os suportes para mesa de impressão. E foram

corrigidos com um parafuso, uma arruela em cima e em baixo e uma porca,

como na imagem.



Foram usados parafusos e colocados com arruelas nos furos do meio

da mesa de impressão e corrigidos com arruelas e porcas.



40

Após isso, foi colocado uma pequena mola para os quatro parafusos

dos suportes da mesa de impressão, colocado a mesa de impressão em cima e

fixada com porcas.



Com cinto foi feito um pequeno laço em uma extremidade com os

dentes para fora e fixado o laço com uma braçadeira.


41

O laço foi posto em um dos parafusos no meio de um dos lados da

mesa de impressão e colocado o cinto em torno da polia, até chegar no outro

parafuso e feito outro pequeno laço com uma braçadeira. Após isso, foi

apertado o cinto e fechado a braçadeira totalmente.


Colocado foi uma porca no parafuso da frente e adicionado o sensor de

fim-de-curso a ele.


Foi adicionado uma porca para ambos os parafusos de correia para

evitar que ele caia. Então, foi colocado um suporte de fim de curso óptico e

empurrado para a haste-z no lado do motor-x. Após isso, foi empurrado um

parafuso com uma arruela e também uma outra arruela o outro lado. Em

seguida, foi adicionado um sensor de fim-de-curso e corrigido juntamente com

uma porca.

42


Foi também posto o outro suporte de fim de curso óptico e empurrado

na haste de rosca, além do reboque-y, como visto na foto. Foi também utilizado

um parafuso, arruelas e uma porca para corrigir o fim de curso óptico como no

anterior.


Por fim, após todo este processo de montagem, na imagem a seguir,

pode se ver a mecânica completa.

FIGURA 60 - PARTE MECÂNICA COMPLETA

43

3.2 Hardware

É um conjunto de componentes eletrônicos e circuitos integrados que

se comunicam entre si através de barramentos. Em complemento ao

Hardware, temos o software, que é a parte lógica, ou seja, o conjunto de

instruções processadas pelo circuito eletrônico do hardware.

3.2.1 Plataforma de Desenvolvimento

Neste projeto, faz parte do Hardware a Plataforma de Desenvolvimento

Repic. Ela é uma placa de circuito impresso com apenas um lado, não possui

jumpers, contém um conector USB, entrada para até quatro drivers de motor de

passo e suporta programação através da porta USB para atualizações de

firmware.

FIGURA 61 - PLATAFORMA DE DESENVOLVIMENTO

44

Para realizar a montagem da Plataforma de desenvolvimento, foi feito o

esquemático e o layout da placa no software CadSoft EAGLE PCB Design.

FIGURA 62 - LAYOUT DA PLATAFORMA DE DESENVOLVIMENTO

Em seguida, foi transferido o layout para a placa de fibra cobreada de

forma artesanal e para corrosão da placa foi utilizado Percloreto de Ferro em

solução aquosa.

FIGURA 63 - PLACA APÓS A CORROSÃO

45

Por fim, foi realizado um orçamento dos componentes necessários,

conforme a Tabela 2, para a montagem da plataforma de desenvolvimento e

então foi feita a compra.

TABELA 6 - LISTA DE PREÇO DO HARDWARE

Qtd. MATERIAL PREÇO TOTAL

1 Placa De Fibra De Vidro Cobreada 15x15cm R$ 8,00 R$ 8,00

4 Pololu Stepper driver board R$ 29,00 R$ 116,00 1 PIC18F4550 Microcontroller R$ 25,00 R$ 25,00 5 Resistor 4k7 1/8W R$ 0,10 R$ 0,50 1 Resistor 10k 1/8W R$ 0,10 R$ 0,10 2 Capacitor 22pF 50V Cerâmico R$ 0,10 R$ 0,20

1 Capacitor 0.1uF 50V Eletrolítico R$ 0,12 R$ 0,12

3 Capacitor 10uF 25V Eletrolítico R$ 0,20 R$ 0,60

1 Capacitor 0.47uF 50V Eletrolítico R$ 0,15 R$ 0,15

1 Cristal 20MHz R$ 1,00 R$ 1,00 3 Mosfet VNP14NV04-E R$ 5,00 R$ 15,00 1 Soquete 40 pinos R$ 0,50 R$ 0,50 3 Barra de pinos femea R$ 0,45 R$ 1,35 2 Chave Táctil R$ 0,35 R$ 0,70 2 LED 5mm R$ 0,20 R$ 0,40 1 USB Tipo B R$ 1,40 R$ 1,40 10 Conector KRE de 2 vias R$ 0,53 R$ 5,30 6 Conector KRE de 3 vias R$ 0,84 R$ 5,04

VALOR TOTAL

R$ 181,36

3.1 Software

O software é a parte lógica, o conjunto de instruções e dados

processado pelos circuitos eletrônicos do hardware. Toda interação dos

usuários de computadores modernos é realizada através do software, que é a

camada, colocada sobre o hardware, que transforma o computador em algo útil

para o ser humano.

46

Um software pode ser feito utilizando uma ou mais linguagens de

programaçao. Entre as linguagens de programaçao temos Visual basic, Python,

SQL, Java, Perl, Delphi, Pascal, C, C++, Assembly, BadCom, BigNum, Cobol,

Javascript, HTML, etc.

Uma linguagem de programação é um método padronizado para

comunicar instruções para um computador. Permite que um programador

especifique precisamente sobre quais dados que um computador vai atuar,

como estes dados serão armazenados ou transmitidos e quais ações devem

ser tomadas sob várias circunstâncias. Linguagens de programação podem ser

usadas para expressar algoritmos com precisão.

FIGURA 64 - ESTRUTURA DE UM PROGRAMA EM C

Os Softwares utilizados para o funcionamento da Impressora 3D foram

o ReplicatorG e o RepRap. Para realizar a programação do software deste

projeto foi utilizada a linguagem C e para programação do microcontrolador foi

necessário o MPLAB, leia mais no item 3.2.1

3.1.1 ReplicatorG

É um simples programa de impressão 3D utilizado para conduzir

máquinas como MakerBot Replicator, CupCake CNC, RepRap e outras

máquinas CNC. Ele é um aplicativo de código aberto, não é muito fácil para os

47

usuários comuns, mas oferece um controle um pouco mais avançado sobre a

impressora e os objetos a serem impressos.

FIGURA 65 - REPLICATORG 0017

3.1.2 MPLAB

O MPLAB IDE(Integrated Development Environment) é um software

editor para gerentes de projetos e ambiente de programação para

desenvolvimento de aplicações e sistemas embarcados. Fornecido

gratuitamente pela empresa Microchip Technology integrando diversos

ambientes de trabalho para programação, simulação e gravação de

microcontroladores.

Foi projetado para trabalhar com vários modelos de Microchip e

flexibilidade para uso de ferramentas de linguagem de programação de

terceiros. Pode ser usado para projetos escritos em linguagem de

programação em assembly, C ou linguagem BASIC. Para programação dos

microprocessadores, o MPLAB possui interface de programação possibilitando

a programação diretamente do MPLAB para a memoria flash do micro

controlador atravez da porta serial ou usb pela interface MPLAB ICD2 , MPLAB

ICE 2000 e PICKIT 2

48

FIGURA 66 - SOFTWARE MPLAB

3.1.3 Repic Beta

O Repic é um programa de impressão 3D recomendado para a placa

Repic. Tem funções para testar os eixos X, Y, Z e também mostra a

temperatura que está a extrusora e a mesa aquecida. Ele funciona da mesma

maneira que todos os softwares para impressão 3D, tem opção para selecionar

o código g e para dar início ou fim no objeto a ser impresso.

FIGURA 67 - SOFTWARE REPIC BETA

49

3.2 Firmware

Em eletrônica e computação, firmware é o conjunto de instruções

operacionais programadas diretamente no hardware de um equipamento

eletrônico. É armazenado permanentemente num circuito integrado (chip) de

memória de hardware, como uma ROM, PROM, EPROM ou ainda EEPROM e

memória flash, no momento da fabricação do componente. O

termo firmware foi originalmente inventado para contrastar com software de alto

nível que poderia ser alterado sem a troca de um componente de hardware.

FIGURA 68 - FLUXOGRAMA

50

CONCLUSÃO

Durante o curso de eletrônica, foi possível adquirir o conhecimento para

então, no módulo IV, ser possível fazer o projeto de TCC (Trabalho de

Conclusão de Curso). Neste caso, foi a elaboração de uma Impressora 3D.

A principal dificuldade encontrada neste projeto foi a utilização da

plataforma de desenvolvimento Reprap, pois não é a usualmente utilizada pelo

módulo IV, isso necessitou de pesquisas extras. Essa mudança foi realizada

porque era necessário uma placa com um PIC compatível com os softwares de

impressão 3D.

Os objetivos principais foram atingidos com sucesso, a impressora

funciona como o esperado. Para melhora-la pode ser implementado

mecanismos que possibilitem a impressão em mais de uma cor e pode também

ser feito um Scanner 3D para complementar o projeto.

51

REFERÊNCIAS B IBL IOGRÁFICAS

ELETRÔNICA TOTAL. Impressora 3D. 155 ed. Brasil, 2013.

KLEBER AUTOMATION. PIC16F877A x PIC18F4550. Disponível em:

<http://kleberautomation.blogspot.com.br/2011/08/pic16f877a-x-

pic18f4550.html> Acesso em: 23.Out.2013

MATT LAB BLOG. Construindo uma impressora 3D. Disponível em:

<http://www.mattlabb.com/blog/2013/08/18/construindo-uma-impressora-3d-4-

estrutura-finalizada/> Acesso em: 23.Out.2013

REPRAP WIKI. Repic. Disponível em: <http://reprap.org/wiki/Repic> Acesso

em: 15.Out.2013

REPLICAT. ReplicatorG. Disponível em: <http://replicat.org/> Acesso em:

08.Nov.2013

WIKIPÉDIA. Hardware. Disponível em: <http://pt.wikipedia.org/wiki/Hardware/

> Acesso em: 09.Nov.2013

WIKIPÉDIA. Software. Disponível em: <http://pt.wikipedia.org/wiki/Software/ >

Acesso em: 09.Nov.2013

WIKIPÉDIA. Linguagem de Programação. Disponível em:

<http://pt.wikipedia.org/wiki/Linguagem_de_programa%C3%A7%C3%A3o>


WIKIPÉDIA. MPLab. Disponível em: <http://pt.wikipedia.org/wiki/MPLab>


52

ANEXOS

Anexo 1 – Esquemático da plataforma de desenvolvimento

53

Anexo 2 – Pinagem PIC18F4550

Anexo 3 – Pinagem Sensor de fim-de-curso

54

Anexo 4 – Esquemático DRV8825

Anexo 4 – Código Fonte da REPIC

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

FileName: main.c

Dependencies: See INCLUDES section

Processor: PIC18, PIC24, and PIC32 USB Microcontrollers

Hardware: This demo is natively intended to be used on Microchip USB demo

boards supported by the MCHPFSUSB stack. See release

notes for

support matrix. This demo can be modified for use on other

hardware

platforms.

55

Complier: Microchip C18 (for PIC18), C30 (for PIC24), C32 (for PIC32)

Company: Microchip Technology, Inc.

Software License Agreement:

The software supplied herewith by Microchip Technology Incorporated

(the “Company”) for its PIC® Microcontroller is intended and

supplied to you, the Company’s customer, for use solely and

exclusively on Microchip PIC Microcontroller products. The

software is owned by the Company and/or its supplier, and is

protected under applicable copyright laws. All rights are reserved.

Any use in violation of the foregoing restrictions may subject the

user to criminal sanctions under applicable laws, as well as to

civil liability for the breach of the terms and conditions of this

license.

THIS SOFTWARE IS PROVIDED IN AN “AS IS” CONDITION. NO WARRANTIES,

WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED

TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A

PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. THE COMPANY SHALL NOT,

IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL OR

CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.

********************************************************************

File Description:

56

Change History:

Rev Description

---- -----------------------------------------

1.0 Initial release

2.1 Updated for simplicity and to use common

coding style

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

#ifndef MAIN_C

#define MAIN_C

/** INCLUDES *******************************************************/

#include "./USB/usb.h"

#include "HardwareProfile.h"

#include "./USB/usb_function_hid.h"

/** CONFIGURATION **************************************************/

#if defined(PICDEM_FS_USB) // Configuration bits for PICDEM FS USB Demo Board

(based on PIC18F4550)

#pragma config PLLDIV = 5 // (20 MHz crystal on PICDEM FS USB board)

#pragma config CPUDIV = OSC1_PLL2

#pragma config USBDIV = 2 // Clock source from 96MHz PLL/2

#pragma config FOSC = HSPLL_HS

#pragma config FCMEN = OFF

#pragma config IESO = OFF

#pragma config PWRT = OFF

57

#pragma config BOR = ON

#pragma config BORV = 3

#pragma config VREGEN = ON //USB Voltage Regulator

#pragma config WDT = OFF

#pragma config WDTPS = 32768

#pragma config MCLRE = ON

#pragma config LPT1OSC = OFF

#pragma config PBADEN = OFF

// #pragma config CCP2MX = ON

#pragma config STVREN = ON

#pragma config LVP = OFF

// #pragma config ICPRT = OFF // Dedicated In-Circuit Debug/Programming

#pragma config XINST = OFF // Extended Instruction Set

#pragma config CP0 = OFF

#pragma config CP1 = OFF

// #pragma config CP2 = OFF

// #pragma config CP3 = OFF

#pragma config CPB = OFF

// #pragma config CPD = OFF

#pragma config WRT0 = OFF

#pragma config WRT1 = OFF

// #pragma config WRT2 = OFF

// #pragma config WRT3 = OFF

#pragma config WRTB = OFF // Boot Block Write Protection

#pragma config WRTC = OFF

// #pragma config WRTD = OFF

58

#pragma config EBTR0 = OFF

#pragma config EBTR1 = OFF

// #pragma config EBTR2 = OFF

// #pragma config EBTR3 = OFF

#pragma config EBTRB = OFF

#else

#error No hardware board defined, see "HardwareProfile.h" and __FILE__

#endif

/** VARIABLES ******************************************************/

#pragma udata

// #if defined(__18F4550)

#pragma udata USB_VARIABLES=0x500

unsigned char ReceivedDataBuffer[64];

unsigned char ToSendDataBuffer[64];

#pragma udata

USB_HANDLE USBOutHandle = 0;

USB_HANDLE USBInHandle = 0;

BOOL blinkStatusValid = TRUE;

unsigned char g_StepperX = 0;

unsigned char g_StepperY = 0;

59

unsigned char g_StepperZ = 0;

unsigned char g_StepperE = 0;

unsigned char g_ExtruderHeater = 0;

unsigned char g_ExtruderTooHot = 1;

unsigned char g_ExtruderTemp = 220;

WORD_VAL g_ExtruderADC = 40;

int g_MsCounter;

WORD_VAL g_DwellCounter;

long deltaTicks;

unsigned char g_FineHome;

unsigned char g_FineHomeCount = 0;

int g_tempCounter = 0;

WORD_VAL g_currentTemp;

// interpolation variables

long currentTicks, currentX, currentY, currentZ, currentE;

long dX, dY, dZ, dE;

long ticksLeft;

long dxi, ddxi, x, slopeX, errorX;

long dyi, ddyi, y, slopeY, errorY;

long dei, ddei, e, slopeE, errorE;

#define TimerFrequency 10000

const unsigned char Timer0Lo = (0x10000 - CLOCK_FREQ / 4 / TimerFrequency - 2);

60

const unsigned char Timer0Hi = (0x10000 - CLOCK_FREQ / 4 / TimerFrequency - 2) / 256;

struct Command

{

unsigned char commandType;

union

{

struct Extrude4D

{

long Ticks;

WORD_VAL X;

WORD_VAL Y;

WORD_VAL Z;

WORD_VAL E;

} Extrude4D;

struct Extrude5D

{

long Ticks;

long dxi;

long ddxi;

long slopeX;

long errorX;

long dyi;

long ddyi;

long slopeY;

long errorY;

61

long dei;

long ddei;

long slopeE;

long errorE;

unsigned char dirs;

} Extrude5D;

WORD_VAL Dwell;

} Args;

};

#define NUM_BUFFERED_COMMANDS 4

volatile int g_NumCommands = 0;

volatile int g_CurrentCommand = 0;

volatile unsigned char g_ProcessingCommand = 0;

#pragma udata CommandSection

volatile struct Command g_Commands[NUM_BUFFERED_COMMANDS];

/** PRIVATE PROTOTYPES *********************************************/

void UpdateSteppers(void);

void BlinkUSBStatus(void);

BOOL Switch2IsPressed(void);

BOOL Switch3IsPressed(void);

static void InitializeSystem(void);

void ProcessIO(void);

62

void UserInit(void);

void YourHighPriorityISRCode();

void YourLowPriorityISRCode();

void mInitPOT();

WORD_VAL ReadPOT(void);

void AdvanceCommand(void);

/** VECTOR REMAPPING ***********************************************/

#if defined(__18CXX)

//On PIC18 devices, addresses 0x00, 0x08, and 0x18 are used for

//the reset, high priority interrupt, and low priority interrupt

//vectors. However, the current Microchip USB bootloader

//examples are intended to occupy addresses 0x00-0x7FF or

//0x00-0xFFF depending on which bootloader is used. Therefore,

//the bootloader code remaps these vectors to new locations

//as indicated below. This remapping is only necessary if you

//wish to program the hex file generated from this project with

//the USB bootloader. If no bootloader is used, edit the

//usb_config.h file and comment out the following defines:

//#define PROGRAMMABLE_WITH_USB_HID_BOOTLOADER

//#define

PROGRAMMABLE_WITH_USB_LEGACY_CUSTOM_CLASS_BOOTLOADER

#if defined(PROGRAMMABLE_WITH_USB_HID_BOOTLOADER)

#define REMAPPED_RESET_VECTOR_ADDRESS 0x1000

#define REMAPPED_HIGH_INTERRUPT_VECTOR_ADDRESS 0x1008

63

#define REMAPPED_LOW_INTERRUPT_VECTOR_ADDRESS 0x1018

#elif defined(PROGRAMMABLE_WITH_USB_MCHPUSB_BOOTLOADER)




#else




#endif

#if

defined(PROGRAMMABLE_WITH_USB_HID_BOOTLOADER)||defined(PROGRAMMABLE_WI

TH_USB_MCHPUSB_BOOTLOADER)

extern void _startup (void); // See c018i.c in your C18 compiler dir

#pragma code REMAPPED_RESET_VECTOR =

REMAPPED_RESET_VECTOR_ADDRESS

void _reset (void)

{

_asm goto _startup _endasm

}

#endif

#pragma code REMAPPED_HIGH_INTERRUPT_VECTOR =

REMAPPED_HIGH_INTERRUPT_VECTOR_ADDRESS

void Remapped_High_ISR (void)

{

_asm goto YourHighPriorityISRCode _endasm

64

}

#pragma code REMAPPED_LOW_INTERRUPT_VECTOR =

REMAPPED_LOW_INTERRUPT_VECTOR_ADDRESS

void Remapped_Low_ISR (void)

{

_asm goto YourLowPriorityISRCode _endasm

}

#if


TH_USB_MCHPUSB_BOOTLOADER)

//Note: If this project is built while one of the bootloaders has

//been defined, but then the output hex file is not programmed with

//the bootloader, addresses 0x08 and 0x18 would end up programmed with 0xFFFF.

//As a result, if an actual interrupt was enabled and occured, the PC would jump

//to 0x08 (or 0x18) and would begin executing "0xFFFF" (unprogrammed space). This

//executes as nop instructions, but the PC would eventually reach the

REMAPPED_RESET_VECTOR_ADDRESS

//(0x1000 or 0x800, depending upon bootloader), and would execute the "goto

_startup". This

//would effective reset the application.

//To fix this situation, we should always deliberately place a

//"goto REMAPPED_HIGH_INTERRUPT_VECTOR_ADDRESS" at address 0x08, and

a

//"goto REMAPPED_LOW_INTERRUPT_VECTOR_ADDRESS" at address 0x18.

When the output

//hex file of this project is programmed with the bootloader, these sections do not

65

//get bootloaded (as they overlap the bootloader space). If the output hex file is not

//programmed using the bootloader, then the below goto instructions do get

programmed,

//and the hex file still works like normal. The below section is only required to fix this

//scenario.

#pragma code HIGH_INTERRUPT_VECTOR = 0x08

void High_ISR (void)

{

_asm goto REMAPPED_HIGH_INTERRUPT_VECTOR_ADDRESS _endasm

}

#pragma code LOW_INTERRUPT_VECTOR = 0x18

void Low_ISR (void)

{

_asm goto REMAPPED_LOW_INTERRUPT_VECTOR_ADDRESS _endasm

}

#endif //end of "#if


TH_USB_LEGACY_CUSTOM_CLASS_BOOTLOADER)"

#pragma code

//These are your actual interrupt handling routines.

#pragma interrupt YourHighPriorityISRCode

void YourHighPriorityISRCode()

{

struct Command * pCurrentCommand = g_Commands + g_CurrentCommand;

66

TMR0H = Timer0Hi;

TMR0L = Timer0Lo;

g_tempCounter--;

// see if we need to start processing another command

if (!g_ProcessingCommand && (g_NumCommands > 0))

{

// start processing the next command

g_ProcessingCommand = 1;

switch (pCurrentCommand->commandType)

{

// goto home

case 0x60:

g_FineHome = 0;

break;

// controlled move 4D

case 0x61:

// set stepper directions and get all values positive for

bresenham's algorithm

currentX = (long)(int)pCurrentCommand-

>Args.Extrude4D.X.Val * 2L; // * 2 because we need to step twice per step

currentY = (long)(int)pCurrentCommand-

>Args.Extrude4D.Y.Val * 2L;

currentZ = (long)(int)pCurrentCommand-

>Args.Extrude4D.Z.Val * 2L;

67

currentE = (long)(int)pCurrentCommand-

>Args.Extrude4D.E.Val * 2L;

if (currentX >= 0)

mStepperA_Dir = 0;

else

{

mStepperA_Dir = 1;

currentX = -currentX;

}

if (currentY >= 0)

mStepperD_Dir = 0;

else

{

mStepperD_Dir = 1;

currentY = -currentY;

}

if (currentZ >= 0)

mStepperB_Dir = 1;

else

{

mStepperB_Dir = 0;

currentZ = -currentZ;

}

if (currentE >= 0)

mStepperC_Dir = 1;

else

68

{

mStepperC_Dir = 0;

currentE = -currentE;

}

// calculate bresenham values

currentTicks = pCurrentCommand-

>Args.Extrude4D.Ticks;

dX = 2L * currentX - currentTicks;

dY = 2L * currentY - currentTicks;

dZ = 2L * currentZ - currentTicks;

dE = 2L * currentE - currentTicks;

ticksLeft = currentTicks;

break;


case 0x63:

dxi = pCurrentCommand->Args.Extrude5D.dxi;

ddxi = pCurrentCommand->Args.Extrude5D.ddxi;

mStepperA_Step = 0;

mStepperA_Dir = (pCurrentCommand-

>Args.Extrude5D.dirs & 1) ? 1 : 0;

x = 0x40000000;

slopeX = pCurrentCommand->Args.Extrude5D.slopeX;

errorX = pCurrentCommand->Args.Extrude5D.errorX;

69

dyi = pCurrentCommand->Args.Extrude5D.dyi;

ddyi = pCurrentCommand->Args.Extrude5D.ddyi;

mStepperD_Step = 0;

mStepperD_Dir = (pCurrentCommand-


y = 0x40000000;

slopeY = pCurrentCommand->Args.Extrude5D.slopeY;

errorY = pCurrentCommand->Args.Extrude5D.errorY;

dei = pCurrentCommand->Args.Extrude5D.dei;

ddei = pCurrentCommand->Args.Extrude5D.ddei;

mStepperC_Step = 0;

mStepperC_Dir = (pCurrentCommand-


e = 0x40000000;

slopeE = pCurrentCommand->Args.Extrude5D.slopeE;

errorE = pCurrentCommand->Args.Extrude5D.errorE;

currentTicks = pCurrentCommand-

>Args.Extrude5D.Ticks;

ticksLeft = currentTicks;

break;

// dwell

case 0x62:

g_MsCounter = 10;

70

g_DwellCounter = pCurrentCommand->Args.Dwell;

break;

}

}

// command processing

if (g_ProcessingCommand)

{

switch (pCurrentCommand->commandType)

{

// goto home

case 0x60:

if (!g_FineHome)

{

// move quickly to home

mStepperA_Dir = 1;

if (mEndStop_X == 0)

mStepperA_Step = ~mStepperA_Step;

mStepperD_Dir = 1;

if (mEndStop_Y == 0)

mStepperD_Step = ~mStepperD_Step;

if ((mEndStop_X != 0) && (mEndStop_Y != 0))

{

g_FineHome = 1;

g_FineHomeCount = 0;

}

71

}

else

{

if (g_FineHomeCount <= 0)

{

// now move slowly out of home

g_FineHomeCount = 4;

mStepperA_Dir = 0;

if (mEndStop_X != 0)

mStepperA_Step =

~mStepperA_Step;

mStepperD_Dir = 0;

if (mEndStop_Y != 0)

mStepperD_Step =

~mStepperD_Step;

if ((mEndStop_X == 0) &&

(mEndStop_Y == 0))

AdvanceCommand();

}

g_FineHomeCount--;

}

break;


case 0x61:

if (dX < 0)

dX = dX + (2L * currentX);

72

else

{

dX = dX + 2L * (currentX - currentTicks);

if ((mStepperA_Dir==0) || (mEndStop_X == 0))


}

if (dY < 0)

dY = dY + (2L * currentY);

else

{

dY = dY + 2L * (currentY - currentTicks);

if ((mStepperD_Dir==0) || (mEndStop_Y == 0))


}

if (dZ < 0)

dZ = dZ + (2L * currentZ);

else

{

dZ = dZ + 2L * (currentZ - currentTicks);

if ((mStepperB_Dir==0) || (mEndStop_Z == 0))

mStepperB_Step = ~mStepperB_Step;

}

if (dE < 0)

dE = dE + (2L * currentE);

else

{

73

dE = dE + 2L * (currentE - currentTicks);

mStepperC_Step = ~mStepperC_Step;

}

ticksLeft--;

if (ticksLeft <= 0)

AdvanceCommand();

break;


case 0x63:

if ((x & 0x80000000) != 0)

{

x &= 0x7fffffff;

if ((mStepperA_Dir==0) || (mEndStop_X == 0))


}

x += dxi;

dxi += ddxi;

errorX += slopeX;

if (errorX >= 0)

{

errorX -= currentTicks;

dxi++;

}

if ((y & 0x80000000) != 0)

{

74

y &= 0x7fffffff;

if ((mStepperD_Dir==0) || (mEndStop_Y == 0))


}

y += dyi;

dyi += ddyi;

errorY += slopeY;

if (errorY >= 0)

{

errorY -= currentTicks;

dyi++;

}

if ((e & 0x80000000) != 0)

{

e &= 0x7fffffff;


}

e += dei;

dei += ddei;

errorE += slopeE;

if (errorE >= 0)

{

errorE -= currentTicks;

dei++;

}

75

ticksLeft--;

if (ticksLeft <= 0)

AdvanceCommand();

break;

// dwell

case 0x62:

g_MsCounter--;

if (g_MsCounter <= 0)

{

g_MsCounter = 10;

g_DwellCounter.Val--;

if (g_DwellCounter.Val == 0)

AdvanceCommand();

}

break;

}

}

else

UpdateSteppers(); // manual stepper updates

// set the heater

if (g_ExtruderHeater && !g_ExtruderTooHot)

mExtruderHeater = 1;

else

mExtruderHeater = 0;

76

INTCONbits.TMR0IF = 0; // Clear Timer0 interrupt flag

}

#pragma interruptlow YourLowPriorityISRCode

void YourLowPriorityISRCode()

{

//Check which interrupt flag caused the interrupt.

//Service the interrupt

//Clear the interrupt flag

//Etc.

} //This return will be a "retfie", since this is in a #pragma interruptlow section

#endif

void AdvanceCommand()

{

g_NumCommands--;

g_CurrentCommand++;

if (g_CurrentCommand >= NUM_BUFFERED_COMMANDS)

g_CurrentCommand = 0;

g_ProcessingCommand = 0;

}

WORD_VAL UnpackWord(unsigned char * buffer)

{

77

WORD_VAL result;

result.byte.LB = buffer[0];

result.byte.HB = buffer[1];

return result;

}

long UnpackLong(unsigned char * buffer)

{

WORD_VAL l1, l2;

l1 = UnpackWord(buffer);

l2 = UnpackWord(buffer+2);

return (long)l1.Val + ((long)l2.Val << 16);

}

/* EEPROM read/write code, courtesy Raphael Wimmer

http://http://my.opera.com/raphman/blog/show.dml/266030 */

void ee_write_byte(unsigned char address, unsigned char _data){

EEDATA = _data;

EEADR = address;

// start write sequence as described in datasheet, page 91

EECON1bits.EEPGD = 0;

EECON1bits.CFGS = 0;

EECON1bits.WREN = 1; // enable writes to data EEPROM

INTCONbits.GIE = 0; // disable interrupts

EECON2 = 0x55;

78

EECON2 = 0x0AA;

EECON1bits.WR = 1; // start writing

while(EECON1bits.WR){

_asm nop _endasm;}

if(EECON1bits.WRERR){

//printf("ERROR: writing to EEPROM failed!\n");

}

EECON1bits.WREN = 0;

INTCONbits.GIE = 1; // enable interrupts

}

unsigned char ee_read_byte(unsigned char address){

EEADR = address;

EECON1bits.CFGS = 0;

EECON1bits.EEPGD = 0;

EECON1bits.RD = 1;

return EEDATA;

}

/** DECLARATIONS ***************************************************/

#pragma code

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

* Function: void main(void)

*

79

* PreCondition: None

*

* Input: None

*

* Output: None

*

* Side Effects: None

*

* Overview: Main program entry point.

*

* Note: None

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


void main(void)

#else

int main(void)

#endif

{

InitializeSystem();

#if defined(USB_INTERRUPT)

USBDeviceAttach();

#endif

while(1)

{

80

#if defined(USB_POLLING)

// Check bus status and service USB interrupts.

USBDeviceTasks(); // Interrupt or polling method. If using polling, must call

// this function periodically. This function will take care

// of processing and responding to SETUP transactions

// (such as during the enumeration process when you first

// plug in). USB hosts require that USB devices should accept

// and process SETUP packets in a timely fashion. Therefore,

// when using polling, this function should be called

// frequently (such as once about every 100 microseconds) at

any

// time that a SETUP packet might reasonably be expected to

// be sent by the host to your device. In most cases, the

// USBDeviceTasks() function does not take very long to

// execute (~50 instruction cycles) before it returns.

#endif

// Application-specific tasks.

// Application related code may be added here, or in the ProcessIO() function.

ProcessIO();

}//end while

}//end main

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

81

* Function: static void InitializeSystem(void)

*


*

* Input: None

*

* Output: None

*


*

* Overview: InitializeSystem is a centralize initialization

* routine. All required USB initialization routines

* are called from here.

*

* User application initialization routine should

* also be called from here.

*

* Note: None

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

static void InitializeSystem(void)

{

#if (defined(__18CXX) & !defined(PIC18F87J50_PIM))

ADCON1 |= 0x0F; // Default all pins to digital

#elif defined(__C30__)

#if defined(__PIC24FJ256DA210__) || defined(__PIC24FJ256GB210__)

ANSA = 0x0000;

82

ANSB = 0x0000;

ANSC = 0x0000;

ANSD = 0x0000;

ANSE = 0x0000;

ANSF = 0x0000;

ANSG = 0x0000;

#else

AD1PCFGL = 0xFFFF;

#endif

#elif defined(__C32__)

AD1PCFG = 0xFFFF;

#endif

#if defined(PIC18F87J50_PIM) || defined(PIC18F46J50_PIM) ||

defined(PIC18F_STARTER_KIT_1) || defined(PIC18F47J53_PIM)

//On the PIC18F87J50 Family of USB microcontrollers, the PLL will not power up and

be enabled

//by default, even if a PLL enabled oscillator configuration is selected (such as

HS+PLL).

//This allows the device to power up at a lower initial operating frequency, which can be

//advantageous when powered from a source which is not gauranteed to be adequate

for 48MHz

//operation. On these devices, user firmware needs to manually set the

OSCTUNE<PLLEN> bit to

//power up the PLL.

{

unsigned int pll_startup_counter = 600;

83

OSCTUNEbits.PLLEN = 1; //Enable the PLL and wait 2+ms until the PLL locks before

enabling USB module

while(pll_startup_counter--);

}

//Device switches over automatically to PLL output after PLL is locked and ready.

#endif

#if defined(PIC18F87J50_PIM)

//Configure all I/O pins to use digital input buffers. The PIC18F87J50 Family devices

//use the ANCONx registers to control this, which is different from other devices which

//use the ADCON1 register for this purpose.

WDTCONbits.ADSHR = 1; // Select alternate SFR location to access

ANCONx registers

ANCON0 = 0xFF; // Default all pins to digital


WDTCONbits.ADSHR = 0; // Select normal SFR locations

#endif

#if defined(PIC18F46J50_PIM) || defined(PIC18F_STARTER_KIT_1) ||

defined(PIC18F47J53_PIM)

//Configure all I/O pins to use digital input buffers. The PIC18F87J50 Family devices

//use the ANCONx registers to control this, which is different from other devices which

//use the ADCON1 register for this purpose.



#endif

84

#if defined(PIC24FJ64GB004_PIM) || defined(PIC24FJ256DA210_DEV_BOARD)

//On the PIC24FJ64GB004 Family of USB microcontrollers, the PLL will not power up

and be enabled

//by default, even if a PLL enabled oscillator configuration is selected (such as

HS+PLL).

//This allows the device to power up at a lower initial operating frequency, which can be

//advantageous when powered from a source which is not gauranteed to be adequate

for 32MHz

//operation. On these devices, user firmware needs to manually set the

CLKDIV<PLLEN> bit to

//power up the PLL.

{

unsigned int pll_startup_counter = 600;

CLKDIVbits.PLLEN = 1;

while(pll_startup_counter--);

}

//Device switches over automatically to PLL output after PLL is locked and ready.

#endif

// The USB specifications require that USB peripheral devices must never source

// current onto the Vbus pin. Additionally, USB peripherals should not source

// current on D+ or D- when the host/hub is not actively powering the Vbus line.

// When designing a self powered (as opposed to bus powered) USB peripheral

// device, the firmware should make sure not to turn on the USB module and D+

// or D- pull up resistor unless Vbus is actively powered. Therefore, the

85

// firmware needs some means to detect when Vbus is being powered by the host.

// A 5V tolerant I/O pin can be connected to Vbus (through a resistor), and

// can be used to detect when Vbus is high (host actively powering), or low

// (host is shut down or otherwise not supplying power). The USB firmware

// can then periodically poll this I/O pin to know when it is okay to turn on

// the USB module/D+/D- pull up resistor. When designing a purely bus powered

// peripheral device, it is not possible to source current on D+ or D- when the

// host is not actively providing power on Vbus. Therefore, implementing this

// bus sense feature is optional. This firmware can be made to use this bus

// sense feature by making sure "USE_USB_BUS_SENSE_IO" has been defined in the

// HardwareProfile.h file.

#if defined(USE_USB_BUS_SENSE_IO)

tris_usb_bus_sense = INPUT_PIN; // See HardwareProfile.h

#endif

// If the host PC sends a GetStatus (device) request, the firmware must respond

// and let the host know if the USB peripheral device is currently bus powered

// or self powered. See chapter 9 in the official USB specifications for details

// regarding this request. If the peripheral device is capable of being both

// self and bus powered, it should not return a hard coded value for this request.

// Instead, firmware should check if it is currently self or bus powered, and

// respond accordingly. If the hardware has been configured like demonstrated

// on the PICDEM FS USB Demo Board, an I/O pin can be polled to determine the

// currently selected power source. On the PICDEM FS USB Demo Board, "RA2"

// is used for this purpose. If using this feature, make sure

"USE_SELF_POWER_SENSE_IO"

86

// has been defined in HardwareProfile.h, and that an appropriate I/O pin has been

mapped

// to it in HardwareProfile.h.

#if defined(USE_SELF_POWER_SENSE_IO)

tris_self_power = INPUT_PIN; // See HardwareProfile.h

#endif

UserInit();

USBDeviceInit(); //usb_device.c. Initializes USB module SFRs and firmware

//variables to known states.

}//end InitializeSystem

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

* Function: void UserInit(void)

*


*

* Input: None

*

* Output: None

*


*

87

* Overview: This routine should take care of all of the demo code

* initialization that is required.

*

* Note:

*

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

void UserInit(void)

{

unsigned int i;

//Initialize all of the LED pins

mInitAllLEDs();

// initialize all of the endstops

mInitAllEndStops();

// initialize the stepper motors

mInitAllSteppers();

// read the extruder temp from eeprom. if the eeprom doesn't have the extruder

temperature programmed then set the default to 40 ie. 220 degrees.

g_ExtruderTemp = ee_read_byte(0);

g_ExtruderADC.byte.LB = ee_read_byte(1);

g_ExtruderADC.byte.HB = ee_read_byte(2);

if ((g_ExtruderTemp==0) || (g_ExtruderTemp==0xff))

{

88

g_ExtruderTemp = 220;

g_ExtruderADC.Val = 40;

}

// initialize the extruder.

mInitExtruder();

//initialize the variable holding the handle for the last

// transmission

USBOutHandle = 0;

USBInHandle = 0;

blinkStatusValid = TRUE;

// initialize the timer interrupt

T0CONbits.TMR0ON = 0; // Stop the timer

T0CONbits.T08BIT = 0; // Run in 16-bit mode

T0CONbits.T0CS = 0; // Use the system clock i.e. 48MHz/4

T0CONbits.PSA = 1; // No prescaler

INTCONbits.TMR0IF = 0; // Clear Timer0 interrupt flag

INTCONbits.TMR0IE = 1; // Enable Timer0 interrupt

TMR0H = Timer0Hi; // Load the timer with the initial value

TMR0L = Timer0Lo;

INTCONbits.GIEH = 1; // Enable all unmasked interrupts

T0CONbits.TMR0ON = 1; // Start the timer

89

}//end UserInit

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

* Function: void ProcessIO(void)

*


*

* Input: None

*

* Output: None

*


*

* Overview: This function is a place holder for other user

* routines. It is a mixture of both USB and

* non-USB tasks.

*

* Note: None

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

void ProcessIO(void)

{

WORD_VAL l1, l2;

int nextCommand;

//Blink the LEDs according to the USB device status

if(blinkStatusValid)

90

{

BlinkUSBStatus();

}

// read the temperature 8 times a second

if (g_tempCounter <= 0)

{

g_currentTemp = ReadPOT();

g_tempCounter = TimerFrequency >> 3;

}

if(!HIDRxHandleBusy(USBOutHandle)) //Check if data was

received from the host.

{

switch(ReceivedDataBuffer[0]) //Look at the data the

host sent, to see what kind of application specific command it sent.

{

// get status

case 0x10:

ToSendDataBuffer[0] = 0x80; // 0x80

= MSGID_STATUS

ToSendDataBuffer[1] = mEndStop_X;

ToSendDataBuffer[2] = mEndStop_Y;

ToSendDataBuffer[3] = mEndStop_Z;

ToSendDataBuffer[4] = g_currentTemp.byte.LB;

ToSendDataBuffer[5] = g_currentTemp.byte.HB;

91

ToSendDataBuffer[6] = NUM_BUFFERED_COMMANDS -

g_NumCommands;

while (HIDTxHandleBusy(USBInHandle));

USBInHandle =

HIDTxPacket(HID_EP,(BYTE*)&ToSendDataBuffer[0],64);

break;

// get temp setting

case 0x11:

ToSendDataBuffer[0] = 0x81; // 0x81

= MSGID_TEMP_SETTING

ToSendDataBuffer[1] = g_ExtruderTemp;

ToSendDataBuffer[2] = g_ExtruderADC.byte.LB;

ToSendDataBuffer[3] = g_ExtruderADC.byte.HB;

while (HIDTxHandleBusy(USBInHandle));

USBInHandle =

HIDTxPacket(HID_EP,(BYTE*)&ToSendDataBuffer[0],64);

break;

// manual stepper control

case 0x20: g_StepperX = ReceivedDataBuffer[1]; break;

case 0x21: g_StepperY = ReceivedDataBuffer[1]; break;

case 0x22: g_StepperZ = ReceivedDataBuffer[1]; break;

case 0x23: g_StepperE = ReceivedDataBuffer[1]; break;

// extruder heater control

case 0x30: g_ExtruderHeater = ReceivedDataBuffer[1]; break;

92

// set temperature

case 0x40:

ee_write_byte(0, ReceivedDataBuffer[1]); // temp

ee_write_byte(1, ReceivedDataBuffer[2]); // adc lsb

ee_write_byte(2, ReceivedDataBuffer[3]); // adc msb

g_ExtruderTemp = ReceivedDataBuffer[1];

g_ExtruderADC.byte.LB = ReceivedDataBuffer[2];

g_ExtruderADC.byte.HB = ReceivedDataBuffer[3];

break;

// go home

case 0x60:

INTCONbits.TMR0IE = 0; // disable Timer0

interrupt

nextCommand = g_CurrentCommand + g_NumCommands;

while (nextCommand >= NUM_BUFFERED_COMMANDS)

nextCommand -= NUM_BUFFERED_COMMANDS;

g_Commands[nextCommand].commandType = 0x60;

g_NumCommands++;

INTCONbits.TMR0IE = 1; // enable Timer0

interrupt

break;


case 0x61:

93


interrupt





g_Commands[nextCommand].Args.Extrude4D.Ticks =

UnpackLong(ReceivedDataBuffer+1);

g_Commands[nextCommand].Args.Extrude4D.X =

UnpackWord(ReceivedDataBuffer+5);

g_Commands[nextCommand].Args.Extrude4D.Y =


g_Commands[nextCommand].Args.Extrude4D.Z =


g_Commands[nextCommand].Args.Extrude4D.E =


g_NumCommands++;


interrupt

break;


case 0x63:


interrupt





94

g_Commands[nextCommand].Args.Extrude5D.dirs =

ReceivedDataBuffer[1];

g_Commands[nextCommand].Args.Extrude5D.Ticks =


g_Commands[nextCommand].Args.Extrude5D.dxi =


g_Commands[nextCommand].Args.Extrude5D.ddxi =


g_Commands[nextCommand].Args.Extrude5D.slopeX =


g_Commands[nextCommand].Args.Extrude5D.errorX =


g_Commands[nextCommand].Args.Extrude5D.dyi =


g_Commands[nextCommand].Args.Extrude5D.ddyi =


g_Commands[nextCommand].Args.Extrude5D.slopeY =


g_Commands[nextCommand].Args.Extrude5D.errorY =


g_Commands[nextCommand].Args.Extrude5D.dei =


g_Commands[nextCommand].Args.Extrude5D.ddei =


g_Commands[nextCommand].Args.Extrude5D.slopeE =


g_Commands[nextCommand].Args.Extrude5D.errorE =


g_NumCommands++;


interrupt

95

break;

// dwell

case 0x62:


interrupt





g_Commands[nextCommand].Args.Dwell =


g_NumCommands++;


interrupt

break;

}

//Re-arm the OUT endpoint for the next packet

USBOutHandle = HIDRxPacket(HID_EP,(BYTE*)&ReceivedDataBuffer,64);

}

}//end ProcessIO

/** POT ************************************************************/

96

void mInitPOT()

{

// Configure analog pins, voltage reference and digital I/O (ADCON1)

TRISAbits.TRISA5=1;

ADCON1 = 9;

// Select A/D input channel (ADCON0)

ADCON0 = 0x10;

// Select A/D acquisition time (ADCON2)

ADCON2 = 0x3C;

// Select A/D conversion clock (ADCON2)

ADCON2bits.ADFM = 1;

// Turn on A/D module (ADCON0)

ADCON0 |= 1;

}

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

* Function: WORD_VAL ReadPOT(void)

*


*

* Input: None

*

97

* Output: WORD_VAL - the 10-bit right justified POT value

*

* Side Effects: ADC buffer value updated

*

* Overview: This function reads the POT and leaves the value in the

* ADC buffer register

*

* Note: None

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

WORD_VAL ReadPOT(void)

{

WORD_VAL w;


mInitPOT();

ADCON0bits.GO = 1; // Start AD conversion

while(ADCON0bits.NOT_DONE); // Wait for conversion

w.v[0] = ADRESL;

w.v[1] = ADRESH;

// restore all pins to digital IO

ADCON1 = 0x0f;

g_ExtruderTooHot = (w.Val < g_ExtruderADC.Val);

98

#elif defined(__C30__) || defined(__C32__)

#if defined(PIC24FJ256GB110_PIM) || \

defined(PIC24FJ256DA210_DEV_BOARD) || \

defined(PIC24FJ256GB210_PIM)

AD1CHS = 0x5; //MUXA uses AN5

// Get an ADC sample

AD1CON1bits.SAMP = 1; //Start sampling

for(w.Val=0;w.Val<1000;w.Val++); //Sample delay, conversion start automatically



while(!AD1CON1bits.DONE); //Wait for conversion to complete

#elif defined(PIC24FJ64GB004_PIM)








#elif defined(PIC24F_STARTER_KIT)


99







#elif defined(PIC32MX460F512L_PIM) || defined(PIC32_USB_STARTER_KIT) ||

defined(PIC32MX795F512L_PIM)

AD1PCFG = 0xFFFB; // PORTB = Digital; RB2 = analog

AD1CON1 = 0x0000; // SAMP bit = 0 ends sampling ...

// and starts converting

AD1CHS = 0x00020000; // Connect RB2/AN2 as CH0 input ..

// in this example RB2/AN2 is the input

AD1CSSL = 0;

AD1CON3 = 0x0002; // Manual Sample, Tad = internal 6 TPB

AD1CON2 = 0;

AD1CON1SET = 0x8000; // turn ADC ON

AD1CON1SET = 0x0002; // start sampling ...


AD1CON1CLR = 0x0002; // start Converting

while (!(AD1CON1 & 0x0001));// conversion done?

#else

#error

100

#endif

w.Val = ADC1BUF0;

#endif

return w;

}//end ReadPOT

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

* Function: void UpdateSteppers(void)

*


*

* Input: None

*

* Output: None

*


*

* Overview:

* Note:

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

void UpdateSteppers(void)

{

static int estepper = 0;

101

// update stepper X

if (g_StepperX!=0)

{

if (g_StepperX==1)

mStepperA_Dir = 0;

else

mStepperA_Dir = 1;

if ((mEndStop_X == 0) || (mStepperA_Dir==0))


}

// update stepper Y

if (g_StepperY!=0)

{

if (g_StepperY==1)

mStepperD_Dir = 0;

else

mStepperD_Dir = 1;

if ((mEndStop_Y == 0) || (mStepperD_Dir==0))


}

// update stepper Z

if (g_StepperZ!=0)

{

102

if (g_StepperZ==1)

mStepperB_Dir = 1;

else

mStepperB_Dir = 0;

if ((mEndStop_Z == 0) || (mStepperB_Dir==1))

mStepperB_Step = ~mStepperB_Step;

}

// update stepper E

if (g_StepperE!=0)

{

if (g_StepperE==1)

mStepperC_Dir = 1;

else

mStepperC_Dir = 0;

if (estepper <= 0)

{


estepper = 5;

}

estepper--;

}

}

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

103

* Function: void BlinkUSBStatus(void)

*


*

* Input: None

*

* Output: None

*


*

* Overview: BlinkUSBStatus turns on and off LEDs

* corresponding to the USB device state.

*

* Note: mLED macros can be found in HardwareProfile.h

* USBDeviceState is declared and updated in

* usb_device.c.

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

void BlinkUSBStatus(void)

{

static WORD led_count=0;

if (g_StepperX || g_StepperY || g_StepperZ || g_StepperE || g_ProcessingCommand)

{

if(led_count == 0)

{

mLED_1_Toggle();

104

led_count = 10000U;

}

led_count--;

}

else

mLED_1_On();

}//end BlinkUSBStatus

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

// ************** USB Callback Functions

****************************************************************

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

// The USB firmware stack will call the callback functions USBCBxxx() in response to certain

USB related

// events. For example, if the host PC is powering down, it will stop sending out Start of Frame

(SOF)

// packets to your device. In response to this, all USB devices are supposed to decrease their

power

// consumption from the USB Vbus to <2.5mA each. The USB module detects this condition

(which according

// to the USB specifications is 3+ms of no bus activity/SOF packets) and then calls the

USBCBSuspend()

// function. You should modify these callback functions to take appropriate actions for each of

these

105

// conditions. For example, in the USBCBSuspend(), you may wish to add code that will

decrease power

// consumption from Vbus to <2.5mA (such as by clock switching, turning off LEDs, putting the

// microcontroller to sleep, etc.). Then, in the USBCBWakeFromSuspend() function, you may

then wish to

// add code that undoes the power saving things done in the USBCBSuspend() function.

// The USBCBSendResume() function is special, in that the USB stack will not automatically call

this

// function. This function is meant to be called from the application firmware instead. See the

// additional comments near the function.

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

* Function: void USBCBSuspend(void)

*


*

* Input: None

*

* Output: None

*


*

* Overview: Call back that is invoked when a USB suspend is detected

*

* Note: None

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

106

void USBCBSuspend(void)

{

//Example power saving code. Insert appropriate code here for the desired

//application behavior. If the microcontroller will be put to sleep, a

//process similar to that shown below may be used:

//ConfigureIOPinsForLowPower();

//SaveStateOfAllInterruptEnableBits();

//DisableAllInterruptEnableBits();

//EnableOnlyTheInterruptsWhichWillBeUsedToWakeTheMicro(); //should enable

at least USBActivityIF as a wake source

//Sleep();

//RestoreStateOfAllPreviouslySavedInterruptEnableBits(); //Preferrably, this

should be done in the USBCBWakeFromSuspend() function instead.

//RestoreIOPinsToNormal();

//Preferrably, this should be done in the USBCBWakeFromSuspend() function instead.

//IMPORTANT NOTE: Do not clear the USBActivityIF (ACTVIF) bit here. This bit is

//cleared inside the usb_device.c file. Clearing USBActivityIF here will cause

//things to not work as intended.

#if defined(__C30__)

USBSleepOnSuspend();

#endif

}

107

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

* Function: void _USB1Interrupt(void)

*


*

* Input: None

*

* Output: None

*


*

* Overview: This function is called when the USB interrupt bit is set

* In this example the interrupt is only used when the

device

* goes to sleep when it receives a USB suspend

command

*

* Note: None

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

#if 0

void __attribute__ ((interrupt)) _USB1Interrupt(void)

{

#if !defined(self_powered)

if(U1OTGIRbits.ACTVIF)

{

IEC5bits.USB1IE = 0;

108

U1OTGIEbits.ACTVIE = 0;

IFS5bits.USB1IF = 0;

//USBClearInterruptFlag(USBActivityIFReg,USBActivityIFBitNum);

USBClearInterruptFlag(USBIdleIFReg,USBIdleIFBitNum);

//USBSuspendControl = 0;

}

#endif

}

#endif

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

* Function: void USBCBWakeFromSuspend(void)

*


*

* Input: None

*

* Output: None

*


*

* Overview: The host may put USB peripheral devices in low power

* suspend mode (by "sending" 3+ms of idle). Once in

suspend

* mode, the host may wake the device back up by

sending non-

109

* idle state signalling.

*

* This call back is invoked when a wakeup from USB

suspend

* is detected.

*

* Note: None

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

void USBCBWakeFromSuspend(void)

{

// If clock switching or other power savings measures were taken when

// executing the USBCBSuspend() function, now would be a good time to

// switch back to normal full power run mode conditions. The host allows

// a few milliseconds of wakeup time, after which the device must be

// fully back to normal, and capable of receiving and processing USB

// packets. In order to do this, the USB module must receive proper

// clocking (IE: 48MHz clock must be available to SIE for full speed USB

// operation).

}

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

* Function: void USBCB_SOF_Handler(void)

*


*

* Input: None

110

*

* Output: None

*


*

* Overview: The USB host sends out a SOF packet to full-speed

* devices every 1 ms. This interrupt may be useful

* for isochronous pipes. End designers should

* implement callback routine as necessary.

*

* Note: None

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

void USBCB_SOF_Handler(void)

{

// No need to clear UIRbits.SOFIF to 0 here.

// Callback caller is already doing that.

}

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

* Function: void USBCBErrorHandler(void)

*


*

* Input: None

*

* Output: None

111

*


*

* Overview: The purpose of this callback is mainly for

* debugging during development. Check UEIR to see

* which error causes the interrupt.

*

* Note: None

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

void USBCBErrorHandler(void)

{

// No need to clear UEIR to 0 here.

// Callback caller is already doing that.

// Typically, user firmware does not need to do anything special

// if a USB error occurs. For example, if the host sends an OUT

// packet to your device, but the packet gets corrupted (ex:

// because of a bad connection, or the user unplugs the

// USB cable during the transmission) this will typically set

// one or more USB error interrupt flags. Nothing specific

// needs to be done however, since the SIE will automatically

// send a "NAK" packet to the host. In response to this, the

// host will normally retry to send the packet again, and no

// data loss occurs. The system will typically recover

// automatically, without the need for application firmware

// intervention.

112

// Nevertheless, this callback function is provided, such as

// for debugging purposes.

}

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

* Function: void USBCBCheckOtherReq(void)

*


*

* Input: None

*

* Output: None

*


*

* Overview: When SETUP packets arrive from the host, some

* firmware must process the request and respond

* appropriately to fulfill the request. Some of

* the SETUP packets will be for standard

* USB "chapter 9" (as in, fulfilling chapter 9 of

* the official USB specifications) requests, while

* others may be specific to the USB device class

* that is being implemented. For example, a HID

* class device needs to be able to respond to

113

* "GET REPORT" type of requests. This

* is not a standard USB chapter 9 request, and

* therefore not handled by usb_device.c. Instead

* this request should be handled by class specific

* firmware, such as that contained in usb_function_hid.c.

*

* Note: None

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

void USBCBCheckOtherReq(void)

{

USBCheckHIDRequest();

}//end

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

* Function: void USBCBStdSetDscHandler(void)

*


*

* Input: None

*

* Output: None

*


*

* Overview: The USBCBStdSetDscHandler() callback function is

114

* called when a SETUP, bRequest: SET_DESCRIPTOR

request

* arrives. Typically SET_DESCRIPTOR requests are

* not used in most applications, and it is

* optional to support this type of request.

*

* Note: None

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

void USBCBStdSetDscHandler(void)

{

// Must claim session ownership if supporting this request

}//end

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

* Function: void USBCBInitEP(void)

*


*

* Input: None

*

* Output: None

*


*

* Overview: This function is called when the device becomes

115

* initialized, which occurs after the host sends a

* SET_CONFIGURATION (wValue not = 0) request. This

* callback function should initialize the endpoints

* for the device's usage according to the current

* configuration.

*

* Note: None

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

void USBCBInitEP(void)

{

//enable the HID endpoint

USBEnableEndpoint(HID_EP,USB_IN_ENABLED|USB_OUT_ENABLED|USB_HANDSHAKE_

ENABLED|USB_DISALLOW_SETUP);

//Re-arm the OUT endpoint for the next packet

USBOutHandle = HIDRxPacket(HID_EP,(BYTE*)&ReceivedDataBuffer,64);

}

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

* Function: void USBCBSendResume(void)

*


*

* Input: None

*

* Output: None

*

116


*

* Overview: The USB specifications allow some types of USB

* peripheral devices to wake up a host PC (such

* as if it is in a low power suspend to RAM state).

* This can be a very useful feature in some

* USB applications, such as an Infrared remote

* control receiver. If a user presses the "power"

* button on a remote control, it is nice that the

* IR receiver can detect this signalling, and then

* send a USB "command" to the PC to wake up.

*

* The USBCBSendResume() "callback" function is used

* to send this special USB signalling which wakes

* up the PC. This function may be called by

* application firmware to wake up the PC. This

* function should only be called when:

*

* 1. The USB driver used on the host PC supports

* the remote wakeup capability.

* 2. The USB configuration descriptor indicates

* the device is remote wakeup capable in the

* bmAttributes field.

* 3. The USB host PC is currently sleeping,

* and has previously sent your device a SET

* FEATURE setup packet which "armed" the

117

* remote wakeup capability.

*

* This callback should send a RESUME signal that

* has the period of 1-15ms.

*

* Note: Interrupt vs. Polling

* -Primary clock

* -Secondary clock ***** MAKE NOTES ABOUT THIS *******

* > Can switch to primary first by calling USBCBWakeFromSuspend()

* The modifiable section in this routine should be changed

* to meet the application needs. Current implementation

* temporary blocks other functions from executing for a

* period of 1-13 ms depending on the core frequency.

*

* According to USB 2.0 specification section 7.1.7.7,

* "The remote wakeup device must hold the resume signaling

* for at least 1 ms but for no more than 15 ms."

* The idea here is to use a delay counter loop, using a

* common value that would work over a wide range of core

* frequencies.

* That value selected is 1800. See table below:

* ==========================================================

* Core Freq(MHz) MIP RESUME Signal Period (ms)

* ==========================================================

* 48 12 1.05

118

* 4 1 12.6

* ==========================================================

* * These timing could be incorrect when using code

* optimization or extended instruction mode,

* or when having other interrupts enabled.

* Make sure to verify using the MPLAB SIM's Stopwatch

* and verify the actual signal on an oscilloscope.

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

void USBCBSendResume(void)

{

static WORD delay_count;

USBResumeControl = 1; // Start RESUME signaling

delay_count = 1800U; // Set RESUME line for 1-13 ms

do

{

delay_count--;

}while(delay_count);

USBResumeControl = 0;

}

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

* Function: BOOL USER_USB_CALLBACK_EVENT_HANDLER(

* USB_EVENT event, void *pdata, WORD size)

119

*


*

* Input: USB_EVENT event - the type of event

* void *pdata - pointer to the event data

* WORD size - size of the event data

*

* Output: None

*


*

* Overview: This function is called from the USB stack to

* notify a user application that a USB event

* occured. This callback is in interrupt context

* when the USB_INTERRUPT option is selected.

*

* Note: None

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

BOOL USER_USB_CALLBACK_EVENT_HANDLER(USB_EVENT event, void *pdata, WORD

size)

{

switch(event)

{

case EVENT_CONFIGURED:

USBCBInitEP();

break;

120

case EVENT_SET_DESCRIPTOR:

USBCBStdSetDscHandler();

break;

case EVENT_EP0_REQUEST:

USBCBCheckOtherReq();

break;

case EVENT_SOF:

USBCB_SOF_Handler();

break;

case EVENT_SUSPEND:

USBCBSuspend();

break;

case EVENT_RESUME:

USBCBWakeFromSuspend();

break;

case EVENT_BUS_ERROR:

USBCBErrorHandler();

break;

case EVENT_TRANSFER:

Nop();

break;

default:

break;

}

return TRUE;

}

121

/** EOF main.c *************************************************/

#endif

TCC IMPRESSORA 3D

Devices & Hardware

Transcript of TCC IMPRESSORA 3D