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 DESENVOLVIMENTO
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 FIGURA 15 - MONTAGEM 2
Após isso foi posto uma barra e os parafusos inseridos anteriormente
para apertá-lo.
FIGURA 16 - MONTAGEM 3
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).
FIGURA 28 - MONTAGEM 15 FIGURA 29 - MONTAGEM 16 FIGURA 30 - MONTAGEM 17
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 BIBLIOGRÁ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

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a TCC IMPRESSORA 3D

TCC IMPRESSORA 3D