View
214
Download
0
Category
Preview:
Citation preview
Universidade Estadual de Londrina
LUIZ CARLOS MARTINS JÚNIOR
SISTEMAS DE INFORMAÇÕES VISUAIS UTILIZANDO
PAINEL COM LEDS
Londrina
2011
LUIZ CARLOS MARTINS JÚNIOR
SISTEMAS DE INFORMAÇÕES VISUAIS UTILIZANDO
PAINEL COM LEDS
Trabalho de Conclusão de Curso
submetido à Universidade Estadual de
Londrina como parte dos requisitos para a
obtenção do grau de Engenheiro
Eletricista.
Orientador: Prof. Dr. Leonimer Flavio de
Melo
Londrina
2011
ii
LUIZ CARLOS MARTINS JÚNIOR
SISTEMAS DE INFORMAÇÕES VISUAIS UTILIZANDO
PAINEL COM LEDS
LONDRINA
2011
iii
UNIVERSIDADE ESTADUAL DE LONDRINA
CURSO DE GRADUAÇÃO EM ENGENHARIA ELÉTRICA
SISTEMAS DE INFORMAÇÕES VISUAIS UTILIZANDO
PAINEL COM LEDS
Trabalho de conclusão de curso submetido á
Universidade Estadual de Londrina
como parte dos requisitos para a obtenção
do grau de Engenheiro Eletricista.
LUIZ CARLOS MARTINS JÚNIOR
Londrina, outubro de 2011.
iv
SISTEMAS DE INFORMAÇÕES VISUAIS UTILIZANDO PAINEL COM
LEDS
Luiz Carlos Martins Júnior
‘Este trabalho foi julgado adequado para a conclusão do curso de engenharia elétrica e
aprovado em sua forma final pela Coordenação do Curso de Engenharia Elétrica da
Universidade Estadual de Londrina.’
_______________________________________
Prof. Dr. Leonimer Flavio de Melo
Orientador
_______________________________________
Profa. Msc. Maria Bernadete de Morais França
Coordenadora de TCC
Banca Examinadora:
_______________________________________
Prof. Msc. André Luiz Batista Ferreira
_______________________________________
Prof. Msc. José Fernando Mangili Júnior
vi
Aos meus pais, Luiz e Celina, e minha irmã
Jéssica pelo amor e apoio incondicional em
todos os momentos da minha vida e que são
minha base para tudo o que sou hoje.
Aos meus avós Ananias e Idiomar, Terezinha e
José Manoel pelo amor e suas orações diárias
me acompanhando espiritualmente.
vii
AGRADECIMENTOS
Eu agradeço às pessoas e Instituição, que compartilharam comigo no decorrer do
curso e que de algum modo contribuíram para a realização do presente trabalho. Vale
lembrar que é impossível agradecer a todos aqueles que conviveram e colaboraram comigo,
pois os nomes seriam demasiados. O que segue é apenas um ponto de partida:
A UEL – Universidade Estadual de Londrina, professores e funcionários,
pelas experiências vivenciadas;
Ao Professor Doutor Leonimer Flavio de Melo, pela orientação, estímulo
constante, apoio, ensinamentos e dedicação; meu respeito e admiração.
Minha gratidão por ter me acompanhado no projeto prático desenvolvido na
UEL e que resultou em todo insumo para elaboração deste trabalho;
Aos meus amigos que me deram total apoio e sempre acreditaram em meus
esforços, seja em conversas formais ou em qualquer momento casual. Em
destaque para Thiago Campos, Rafael Ceribelli, Fábio Nagai, Pedro Elero,
André Bordin, Rogério Tavares, João Ideriha, Tarcísio Andrade, Lucas Balan,
Flávio Vendramini, Fernando Abrahão, Thiago Fontes, Marcelo Cabral, João
Paulo Albuquerque, Bruno Cadorin, Rodrigo Nicoluzzi, Brunno Calado, José
Eduardo Gomes, Guilherme Leal, Felipe Lemes, Tiago Takeo, Gelson Orcioli
e Guilherme Battalini.
viii
RESUMO
Os painéis de LEDs estão a cada dia mais presentes na sociedade atual,
utilizados em diversos tipos de finalidades e expandindo-se com uma grande
rapidez, devido aos custos, tamanho e possibilidade de diversificação. Além disso,
os LEDs cada vez mais são utilizados devido a sua grande eficiência luminosa e
energética. O objetivo é desenvolver um projeto de um sistema de informações
visuais, utilizando painel com LEDs, e implementá-lo. O projeto será dividido em dois
módulos: o primeiro, focando no estudo, projeto e implementação do hardware,
criando uma placa com um microprocessador programado em linguagem C; e o
segundo, voltado para a construção de um firmware que controle o microcontrolador,
fazendo com que o mesmo consiga fazer o painel funcionar de maneira eficiente.
Palavras-chave: Comunicação visual. Painel de LEDs. Interfaces programáveis por
microcontroladores.
ix
ABSTRACT
The LED screens are increasingly present in today's society, being used in a
variety of purposes and expanding with great speed because of the cost, size and
scope for diversification. In addition, LEDs are increasingly being used due to its high
luminous and energy efficiency. The goal is to develop a system design using visual
information panel with LEDs and implement it. The project is divided into two
modules: the first focusing on the study, design and implementation of hardware,
creating a board with a microprocessor which is programmed in C language and the
second aimed at building a firmware that controls the microcontroller and make the
panel work effectively.
Keywords: Visual communication. Led screen. Programmable microcontrollers
interfaces.
x
LISTA DE FIGURAS
Figura 1 – Esquema dos elementos do processo de comunicação ......................................................... 4
Figura 2 – Eficácia luminosa das fontes de luz convencionais mais importantes ................................... 7
Figura 3 - Diagrama de Blocos do Circuito ............................................................................................ 12
Figura 4 – Parte frontal do primeiro protótipo montado ..................................................................... 14
Figura 5 – Parte traseira do primeiro protótipo montado .................................................................... 14
Figura 6 – Conexões do microcontrolador ............................................................................................ 16
Figura 7 – Exemplo das ligações dos latchs (no total são 27 latchs) ..................................................... 17
Figura 8 – Exemplo das ligações dos contadores (no total são 3 contadores) ..................................... 18
Figura 9 – Conector de alimentação ..................................................................................................... 18
Figura 10 – Conector DB9F .................................................................................................................... 18
Figura 11 – Conector do programador PICKit3 ..................................................................................... 19
Figura 12 – Circuito do conversor serial ................................................................................................ 19
Figura 13 – Lado inferior do fotolito ..................................................................................................... 20
Figura 14 – Lado superior do fotolito .................................................................................................... 21
Figura 15 – Placa sem componentes ..................................................................................................... 22
Figura 16 – Programador PICKit3 conectado à placa ............................................................................ 24
Figura 17 – Representação da rotina ‘ZeraPainel’ ................................................................................ 25
Figura 18 – Representação da rotina ‘CarregaBar’ ............................................................................... 26
Figura 19 – Representação da rotina ‘IncColuna’ ................................................................................. 27
Figura 20 – Representação da rotina ‘LoadBuffer’ ............................................................................... 28
Figura 21 – Representação da rotina ‘DeslocaColuna’ ......................................................................... 29
Figura 22 – Placa com os componentes soldados ................................................................................. 32
Figura 23 – Placa em funcionamento .................................................................................................... 33
Figura 24 – Deslocamento dos caracteres (parte 1) ............................................................................. 34
Figura 25 – Deslocamento dos caracteres (parte 2) ............................................................................. 34
Figura 26 – Deslocamento dos caracteres (parte 3) ............................................................................. 34
Figura A1 – Esquemático Latches 1 a 9 e LEDs ...................................................................................... 70
Figura A2 – Esquemático Latches 10 a 18 e LEDs .................................................................................. 71
Figura A3 – Esquemático Latches 19 a 27 e LEDs .................................................................................. 72
Figura A4 – Esquemático Conectores de Alimentação e DB9 ............................................................... 73
Figura A5 – Esquemático Conectores do PICKit3 e USB ........................................................................ 73
xi
Figura A6 – Esquemático dos Contadores HCF4017B ........................................................................... 73
Figura A7 – Esquemático do PIC18F14K50 e do MAX3232 ................................................................... 73
Figura A8 – Layout da placa .................................................................................................................. 74
xii
LISTA DE TABELAS
Tabela 1 – Comparação entre famílias PIC16 e PIC18 ........................................................................... 10
xiii
SUMÁRIO
LISTA DE FIGURAS..................................................................................................................................... x
LISTA DE TABELAS ................................................................................................................................... xii
1 INTRODUÇÃO ....................................................................................................................................... 1
1.1 Contexto ........................................................................................................................................ 1
1.2 Objetivo ......................................................................................................................................... 1
1.3 Justificativa .................................................................................................................................... 2
1.4 Organização do documento .......................................................................................................... 2
2 MEIOS DE COMUNICAÇÃO .................................................................................................................. 4
3 PAINEL DE LEDs .................................................................................................................................... 6
3.2 LED ................................................................................................................................................. 6
3.3 Armazenamento de informações .................................................................................................. 7
3.4.1 Latchs...................................................................................................................................... 8
3.4 Contador ........................................................................................................................................ 8
3.5 Microcontroladores ....................................................................................................................... 9
3.5.1 PIC ........................................................................................................................................... 9
3.5.2 PIC18..................................................................................................................................... 10
3.5.3 Programação de microcontroladores .................................................................................. 10
4 HARDWARE ........................................................................................................................................ 12
5 FIRMWARE ......................................................................................................................................... 24
6 ANÁLISE DOS RESULTADOS ................................................................................................................ 31
7 CONCLUSÕES ...................................................................................................................................... 35
8 REFERÊNCIAS ...................................................................................................................................... 37
ANEXO A – MAPA DE CARACTERES ....................................................................................................... 40
ANEXO B – CÓDIGO COMPLETO DO FIRMWARE .................................................................................. 46
ANEXO C – Esquemático completo do circuito ..................................................................................... 70
ANEXO D – Fotolitos .............................................................................................................................. 74
1
1 INTRODUÇÃO
1.1 Contexto
O campo da comunicação visual está expandindo-se rapidamente com
utilização de sistemas e componentes de tecnologia moderna, que fornecem alto
desempenho associado a baixo consumo de potência. Neste segmento, encontram-
se os LEDs, que tiveram rápido crescimento tecnológico na última década, obtendo
ótimos desempenhos em função da intensidade luminosa emitida com baixíssimo
consumo de potência. Estas características fundamentais, nos tempos modernos,
colocou o LED no topo dos componentes a serem utilizados como sistemas de
iluminação, já um substituto às lâmpadas incandescentes e fluorescentes, em telas
de televisão, como as TVs de LEDs, e em painéis de informações e propagandas,
como os outdoors animados.
Atualmente, os microcontroladores são amplamente utilizados no
desenvolvimento de painéis de comunicação, e podem ser programados para
exercerem diversas funções, e existem diversos softwares que podem ser utilizados
para programarem esse tipo de componente, além de serem componentes de
reduzido tamanho e baixo custo (BRAIN, 2008).
O projeto foi criado e dividido em duas principais partes. A primeira foi voltada
para o hardware da placa, o foco principal desse trabalho, sendo todos os passos
mostrados durante os textos, chegando ao nível mais aprofundado do que foi
realizado. A segunda foi voltada para o firmware do mesmo, com as programações
necessárias para o funcionamento do painel, a qual será relatada, mas não com
todas as etapas, mostrando apenas o essencial para o entendimento dos
procedimentos adotados.
1.2 Objetivo
O principal foco desta pesquisa é implementar uma matriz de LEDs
programável, a qual pudesse atender necessidades simples de escrita, com um
tamanho relativamente reduzido e realizada com um baixo custo, utilizando um
microcontrolador PIC. O trabalho serve como base para a realização de um projeto
de maior tamanho e capacidade de caracteres escritos, realizado com maior
2
investimento e maior tempo disponível, porém com as informações apresentadas. A
implementação de um projeto futuro de maior tamanho se torna muito mais fácil.
Tendo como base o conhecimento adquirido no decorrer da graduação, o
projeto serviu para um aumento de conhecimento prático do autor do trabalho, de
modo que, além da área eletrônica voltada mais especificamente para o hardware,
conseguiu absorver muito conhecimento na área de programação, devido à
construção do firmware.
1.3 Justificativa
O trabalho foi baseado em um projeto de iniciação científica realizado durante
a graduação, o qual surgiu durante uma vontade de aprimoramento de
conhecimento prático, e, em consenso com o professor orientador, chegou-se à
conclusão de que o desenvolvimento do painel seria construtivo para atender às
necessidades encontradas, além de apresentar um resultado físico esperado muito
interessante, por se tratar de algo cada vez mais visto nos dias de hoje.
1.4 Organização do documento
O trabalho foi organizado seguindo os tópicos abaixo:
No primeiro capítulo, é apresentado o objetivo geral, bem como a relevância
do estudo.
No capitulo 2, será relatado sobre os meios de comunicação e a importância
dos mesmos na história.
O capítulo 3 explica o funcionamento e uso dos componentes utilizados no
decorrer do projeto, explicitando sua importância e necessidade de utilização.
O capítulo 4 é dedicado a explicar toda a parte voltada para o hardware do
projeto, mostrando como foi montado e explicando a forma como foi feito.
No capítulo 5, o objetivo será mostrar a parte do firmware da placa,
explicando os passos e relatando o funcionamento do mesmo.
O capítulo 6 será voltado a apresentar os resultados obtidos após a
finalização do painel.
No capítulo 7, serão apresentadas as conclusões que obtidas após o término
da elaboração e implementação do projeto.
3
No final do trabalho, poderão ser encontrados anexos com materiais
necessários para a elaboração do trabalho e apêndices teóricos.
4
2 MEIOS DE COMUNICAÇÃO
A origem da palavra comunicação vem do latim “communicare”, “ato de
repartir, de distribuir”, literalmente “tornar comum”. Segundo Penteado (1991), uma
diversidade de formas às quais os seres humanos transmitem e recebem idéias,
impressões, imagens, num processo dinâmico onde o entendimento transcende as
palavras.
A comunicação tem origem na pré-história com a comunicação de homens
da mesma aldeia, e a escrita foi criada na mesopotâmia, entretanto foram os
sumérios que inventaram a linguagem cuneiforme.
A boa comunicação é uma competência prioritária para todos os seres
humanos. Comunicar é a habilidade de externar informações, emoções, opiniões e
qualquer tipo de conhecimento de um indivíduo para outro.
Os principais elementos que compõem a comunicação, segundo Kotler: o
emissor e o receptor (são as partes envolvidas); a mensagem e o meio (são as
ferramentas de comunicação); codificação, decodificação, resposta e feedback (são
as principais funções da comunicação) e, por último, o ruído (mensagens que podem
interferir na comunicação pretendida). Este modelo realça os fatores fundamentais
para uma comunicação eficaz e pode ser visualizado na figura 1.
Figura 1 – Esquema dos elementos do processo de comunicação
Fonte: Kotler (2000, p. 571)
5
O emissor precisa conhecer o receptor, ou seja, saber que público deseja
atingir. O emissor deve ter em mente que reações pretende provocar, gerar no
público receptor. Assim, cabe ao emissor codificar a mensagem de forma a ser
compreendido pelo público alvo, que vai decodificar a mensagem, através de meios
eficazes e canais de feedback. A principal tarefa do emissor é fazer a mensagem
chegar ao receptor.
O comunicador terá de decidir por quais canais de comunicação optar para
veicular sua mensagem. Existem os canais pessoais, que envolvem o diálogo direto
entre duas pessoas, facilitando a abordagem do serviço e obtenção do feedback.
Existem também os canais não pessoais formados pela mídia, inclusive a eletrônica,
o ambiente que envolve a compra do produto ou serviço, e os eventos organizados
pelo setor de relações públicas, como patrocínios, conferências, inaugurações, etc.
Desde sempre, os seres humanos buscaram a melhor forma de se
comunicarem, limitados pelas possibilidades encontradas em cada época da
evolução. Os gestos mímicos vieram nos tempos mais antigos, evoluindo
posteriormente para a fala, com diversas línguas dependendo da cultura de cada
civilização, de forma que a eficiência da comunicação foi evoluindo com o passar do
tempo.
Torna-se evidente que a comunicação visual sempre foi e será o melhor jeito
de transmitir uma mensagem de forma eficiente. As maneiras como isso foi feito
começaram a se aprimorar com o uso de novas tecnologias e com a capacidade do
ser humano de desenvolver novos métodos comunicativos.
Atualmente, os meios de comunicação visuais podem ser encontrados em
todos os lugares e utilizados por todos os tipos de pessoas, desde impressos como
cartazes, panfletos e jornais, até sistemas mais complexos como televisores e
computadores.
6
3 PAINEL DE LEDs
Uma forma eficiente encontrada para a comunicação visual, foram os painéis
letreiros. Quando surgiram, eram utilizados painéis manuais, com pequenas placas
para cada caractere que poderiam ser alteradas conforme a necessidade do seu uso
e da mensagem a ser transmitida.
Com o avanço da tecnologia e dos meios de comunicação, painéis luminosos
começaram a surgir, proporcionando um meio mais atrativo para propagandas e
anúncios, desde lojas utilizando esse meio para marketing até lugares que
necessitam passar informações importantes de maneira rápida e clara, como
rodoviárias, aeroportos e informações de destinos em ônibus. Esses painéis também
começaram a ser muito utilizados no meio esportivo, como em placares eletrônicos.
Com o passar do tempo, começaram a ser utilizadas lâmpadas LEDs para a
implementação desses painéis, as quais proporcionavam uma melhora significativa
em vários aspectos na montagem e utilização dos mesmos, incluindo luminosidade e
eficiência energética, o que, nos dias atuais, é de extrema importância para qualquer
tipo de aplicação.
3.2 LED
Atualmente, o desenvolvimento e uso de produtos que consigam fornecer
uma boa qualidade de iluminação e ao mesmo tempo eficiência energética, é tido
como objetivo para engenheiros e projetistas que atuem na área de iluminação ou
que precisem desenvolver algum projeto ligado à mesma.
Em 1962, chega ao mercado o primeiro LED vermelho de baixa potência,
produzido pela empresa General Electric. A sigla LED corresponde a Light Emitting
Diode, ou Diodo Emissor de Luz. Em 1994, surge o primeiro LED azul de alta
potência, desenvolvido no Japão pelo professor Shuki Nakamura, o qual serviu
como base para que posteriormente pudessem ser criados os LEDs mais evoluídos
como os LEDs RGB, os quais possuem 3 chips diferentes (um vermelho, um verde e
um azul), podendo ser programados para criarem diferentes cores.
Tendo como base a análise de Pimenta, com o desenvolvimento da
tecnologia dos LEDs, as aplicações dos mesmos foram expandidas para diversas
áreas, sendo que antes eram usados como lâmpadas indicadoras de relógios,
7
calculadoras e outros aparelhos, e atualmente vêm ganhando espaço em sistemas
para controle de tráfego (semáforos), sistemas para a indústria automotiva,
iluminação arquitetônica e painéis luminosos de anúncios e mensagens.
Através do gráfico mostrado na figura 2, podemos ver a eficiência
apresentada pelo LED em relação a outros tipos de fontes luminosas, mostrando,
através dos anos, como o desenvolvimento tecnológico influenciou nessa área. São
apresentados alguns tipos de lâmpadas e a mais incomum é a de metal halide, o
qual é capaz de exibir iluminação em cores e é muito utilizado em projetores de
fimes.
Figura 2 – Eficácia luminosa das fontes de luz convencionais mais importantes
Fonte: Khanh (2011, p. 59)
3.3 Armazenamento de informações
Desde sempre, existiu a importância do ser humano de armazenar
informações, devido ao entendimento de que as mesmas poderiam ser importantes
para outras pessoas, fazendo com que se poupasse tempo e a necessidade de se
estudar ou aprender novamente algo previamente feito.
No caso da eletrônica, existem diversas maneiras de se reter uma
informação. Para a necessidade do projeto de se armazenar temporariamente
8
alguns bits, entendeu-se que os latchs seriam os dispositivos mais eficazes para
cumprir essa demanda.
O flip-flop é o elemento de memória mais importante, produzido a partir de
uma configuração de portas lógicas. Uma porta lógica por si só não tem capacidade
de armazenamento, porém varias portas lógicas podem ser conectadas de modo a
permitir que informações possam ser armazenadas (TOCCI, 1998).
3.4.1 Latchs
Latch também é considerado um flip-flop, apresentando características
diferentes. Flip-flops e latchs são considerados dispositivos lógicos biestáveis, pois
apresentam dois estados estáveis (SET e RESET). Esses dispositivos são utilizados
como elementos para o armazenamento de informações. De maneira mais simples,
pode-se dizer que os latchs “memorizam” seu estado (SEDRA, 2007).
A diferença entre um flip-flop e um latch é o fato de o primeiro mudar seu
estado em sincronia com um sinal de clock, por isso é considerado um dispositivo
biestável síncrono, já o latch não necessita de sincronismo com um trem de pulsos
de controle, então é considerado um dispositivo biestável assíncrono (CASTRO,
2002).
3.4 Contador
Um dos dispositivos mais comumente encontrados em equipamentos
eletrônicos são os contadores. São basicamente arranjos de flip-flops, os quais se
baseiam em certas propriedades de memória dos flip-flops. Existem diversos tipos
de contadores, dependendo da forma que é montado e do modo a ser utilizado. Um
tipo bastante utilizado é o contador com registrador de deslocamento.
Contadores com registradores de deslocamento usam realimentação, ou seja,
a saída do ultimo flip-flop do registrador é conectada ao primeiro flip-flop. O contador
em anel faz exatamente isso, a saída do ultimo flip-flop é conectada à entrada do
primeiro, sem nenhum tipo de alteração. Esse contador em anel pode ser
ligeiramente modificado de modo a se formar o contador Johnson ou contador em
anel torcido, o qual é construído da mesma maneira de um contador em anel
9
comum, porém a saída do ultimo flip-flop é invertida antes de ser ligada à entrada do
primeiro flip-flop (TOCCI, 1998).
3.5 Microcontroladores
Muito se tem comentado sobre a utilização de microcontroladores nos dias
atuais, sendo que os mesmos se tornam cada vez mais importantes na
implementação de circuitos eletroeletrônicos devido a seu baixo custo e infinidade
de funções. Existem dúvidas, porém, quanto a diferenciação de microprocessadores
e microcontroladores.
Os microcontroladores possuem dentro de um único chip, uma CPU e
também elementos como memórias RAM e ROM, contadores, geradores de clock e
canais de comunicação, enquanto que os microprocessadores (apesar de possuírem
uma maior capacidade de processamento) necessitam desses periféricos
externamente (SILVA JÚNIOR, 1988).
A lógica de operação dos microcontroladores é estruturada na forma de um
programa e posteriormente gravada dentro do componente, tornando os mesmos
programáveis. Após essa gravação realizada, toda vez que o microcontrolador for
alimentado, o programa interno será executado. Atualmente, muitos equipamentos
encontrados diariamente utilizam um microcontrolador para executar suas tarefas
básicas, como eletrodomésticos, alarmes, celulares e brinquedos (SOUZA, D. J.,
1999).
3.5.1 PIC
Grande parte dos microcontroladores tradicionais apresenta uma arquitetura
tipo Von-Neumann, enquanto os microcontroladores PIC possuem uma estrutura de
máquina interna do tipo Harvard. Isso difere o processamento dos dados e do
programa interno. Na arquitetura do tipo Von-Neumann, as instruções e os dados
passam por apenas um barramento interno que geralmente possui 8 bits. No tipo
Harvard, existem dois barramentos internos, um voltado apenas para os dados e
outro para as instruções. Nos PICs, o barramento de dados sempre possui 8 bits,
enquanto o barramento de instruções pode possuir 12, 14 ou 16 bits. Isso torna o
processamento mais rápido (SOUZA, D. J.,1999).
10
3.5.2 PIC18
Com o desenvolvimento dos PICs, as chamadas famílias foram criadas e
evoluindo com o passar do tempo. A tabela 1 mostra as vantagens da família PIC18
em relação a PIC16, comprovando a superioridade da mesma. Um detalhe
importante é que, apesar de ser melhor, o custo para se comprar componentes
dessas duas famílias é bem próximo, o que garante a vantagem da escolha de um
elemento da família PIC18 (SOUZA, V.A., 2006).
Tabela 1 – Comparação entre famílias PIC16 e PIC18
Fonte: Souza, V. A. (2006)
Através da tabela 1, é possível analisar que, em todos os aspectos, a família
PIC18 torna-se muito superior, com mais memória disponível tanto para dados
quanto para o programa e maior velocidade de processamento. A evolução pode ser
vista também pelo fato de já utilizar uma tecnologia USB 2.0, a qual possui uma taxa
de transferência maior e indica o acompanhamento do desenvolvimento do
mercado.
3.5.3 Programação de microcontroladores
Podem ser utilizadas diversas linguagens para se programar um
microcontrolador PIC, que vão desde linguagens de alto nível, como C, Pascal e
Basic até linguagens como o Assembly. Ao se construir um programa para um PIC,
11
o mesmo passa a ser chamado de firmware e, com o auxilio de um hardware de
gravação, esse programa é transferido para a memória do microcontrolador.
A linguagem C é considerada uma linguagem extremamente eficiente, devido
principalmente a sua proximidade com o hardware e com a linguagem Assembly,
podendo ser considerada atualmente a linguagem de alto nível mais eficiente.
Utilizando essa linguagem, o programador pode permitir-se preocupar mais com a
programação da aplicação, devido ao fato que o compilador assume para si algumas
tarefas como operações matemáticas e lógicas, controle e localização das variáveis
e verificação de bancos de memória. Dessa forma é possível desenvolver um
programa de forma mais “limpa” e rápida, tornando-o o mais eficiente possível
(PEREIRA, 2007).
12
4 HARDWARE
Ao serem estipulados os objetivos do projeto, começaram a ser
desenvolvidas pesquisas sobre o assunto, maneiras de como seria possível obter os
resultados esperados, e esquemas de montagens e materiais foram estudados. Isso
foi feito de forma a se chegar a um método de montagem que conseguisse atender
às exigências do projeto.
A solução encontrada para realizar uma montagem eficiente do projeto é
mostrada na figura 3. Um computador grava as informações (caracteres) que se
desejam exibir no painel em um microcontrolador. Esse microcontrolador realiza
duas funções principais: na primeira, ele envia os dados para os latchs, os quais
criam um barramento de dados para serem utilizados no momento correto. A
segunda função do microcontrolador é emitir um sinal de clock para os contadores,
de modo que esses habilitem posteriormente os latchs requeridos. Assim, conforme
os latchs eram habilitados, ativavam os LEDs com as informações recebidas
anteriormente. Assim o painel exibe os caracteres que foram escritos no
computador.
Figura 3 - Diagrama de Blocos do Circuito
13
O tamanho do painel foi estipulado de maneira que não ficasse muito grande,
mas que, ao mesmo tempo, pudesse ser capaz de exibir pelo menos 4 caracteres de
uma vez. Assim foi estipulado que o mesmo possuiria 27 colunas com 8 LEDs em
cada uma. Esse tamanho é suficiente para suprir as necessidades e pode servir
como uma ótima base para trabalhos futuros que desejem utilizar a mesma linha de
raciocínio. A figura 3 serve para apresentar uma visão mais clara de como funciona
o projeto. Ela mostra apenas 3 latchs, e somente 1 deles ligado aos LEDs, porém
existem mais latchs e todos estão ligados ao painel de LEDs, assim como existem
mais contadores 4017 que enviam sinal para os latchs. Todos esses componentes
serão melhor especificados nos próximos parágrafos.
Primeiramente, foi feito um protótipo com a ajuda do professor orientador e
dos técnicos do laboratório da universidade. O mesmo foi feito com componentes
DIP (não eram SMD) e não foram realizados muitos estudos prévios para a
realização desse protótipo. Apenas foi feito um esquemático parcial de montagem, e
o mesmo foi sendo repetido para a placa possuir o tamanho desejado. Após a
conclusão do mesmo, começou a se realizar a construção do firmware, porém a
placa não respondia corretamente aos comandos. Diversos testes foram feitos e
descobriram muitos erros na montagem. Assim, após um período buscando
consertá-los, chegou-se à conclusão que a maneira mais eficiente de realizar o
projeto era fazendo uma placa desde o início, utilizando componentes melhores e
estudos mais aprofundados antes de qualquer montagem. A foto do protótipo pode
ser vista na figura 4. Este protótipo serviu apenas para estudos iniciais e depois não
foi mais utilizado, sendo substituído pela placa do projeto final.
14
Figura 4 – Parte frontal do primeiro protótipo montado
A parte inferior do protótipo pode ser vista na figura 5, onde é possível ver
com clareza o emaranhado de fios e componentes que se formou, devido a não
confecção de uma placa realizada com um layout reduzido.
Figura 5 – Parte traseira do primeiro protótipo montado
15
Com os erros da primeira montagem, o nível de conhecimento em cima do
projeto aumentou bastante. Foi estipulado que para um projeto de maior qualidade e
também que ocupasse um menor espaço, deveriam ser utilizados componentes
SMD (Surface Mounting Devices). Então foi escolhido cada componente, para que
se adequasse da melhor maneira possível aos objetivos do projeto.
Primeiramente, buscou-se um microcontrolador que atendesse as
necessidades do projeto, com um custo reduzido e de alta eficiência. Através de
buscas de informações com professores e também consultando o site da fabricante
(www.microchip.com), chegou-se à conclusão que o microcontrolador Microchip da
família PIC 18F14K50 era adequado para sua utilização no projeto, o qual possui um
tamanho razoável de memória, podendo ser armazenado todo o firmware, e também
possui a quantidade de saídas necessárias para a elaboração da placa
(MICROCHIP, 2010).
Necessitava-se criar um barramento de dados, o qual iria receber as
informações enviadas pelo microcontrolador, armazená-las e enviá-las para a saída,
quando fosse requisitado. Os latchs são os componentes que se adequam a esse
tipo de situação, assim o componente escolhido foi um latch Philips 74HC373, o qual
pode armazenar 1 byte de informação por vez (PHILIPS, 1993). Como foi estipulado
que o painel teria 27 colunas com 8 LEDs em cada uma, foram utilizados 27 latchs
no projeto, fazendo com que cada latch atendesse uma coluna de LEDs.
Como citado anteriormente, os latchs deveriam ser habilitados, quando
chegasse o momento de transferir os dados para a sua respectiva coluna, e também
os mesmos deveriam receber novas informações, de maneira que esta coluna fosse
sempre atualizada com novos dados. Componentes como os contadores realizam
esse tipo de função, podendo habilitar os latchs no momento correto. Através de
buscas feitas com fabricantes, escolheu-se o contador ST HCF4017B. Tendo em
vista que esse componente deveria enviar informações para 27 latchs foram
utilizados 3 contadores, pois cada um deles possui 10 saídas (ST, 2001).
A ligação serial entre o computador e a placa necessita de um conversor
serial, o escolhido foi o MAX232 da Maxim. Esse componente evita a utilização de
uma fonte de alimentação exclusiva para ele. Através de um circuito interno, pode
ser alimentado com os ±5V já existentes na placa (MAXIM, 2010).
Os LEDs são os componentes que serão exibidos diretamente para quem
visualizar o projeto. Assim foram escolhidos LEDs azuis para formar a parte visual
16
do painel. Esses componentes possuem uma baixa potência e apresentam um alto
brilho, dando um melhor visual à parte estética da placa, levando a mesma a ser
mais atrativa para o seu uso final. Foram utilizados 217 LEDs na montagem do
projeto. Ligados aos mesmos, foram colocados resistores de 100Ω, em mesma
quantidade.
Após a escolha dos componentes a serem utilizados, tendo como base o
projeto realizado anteriormente, o qual, apesar dos erros obtidos, trouxe uma boa
base para a realização do projeto final, foi criado o esquemático completo do
mesmo, com todos os componentes estudados pelos seus respectivos datasheets.
O programa utilizado foi o OrCAD, fabricado pela empresa Cadence
(http://www.cadence.com).
A figura 6 representa as conexões realizadas no microcontrolador, podendo
ser vistas as 8 saídas (D0 a D7), as quais enviam um bit cada uma para os latchs,
formando o byte completo de cada coluna. Também é possível ver a saída do sinal
de clock enviado aos contadores, fazendo com que os mesmos consigam habilitar
posteriormente os latchs, no momento correto.
Figura 6 – Conexões do microcontrolador
A representação das ligações feitas nos latchs é mostrada na figura 7, onde
as entradas D0 a D7 recebem os seus respectivos bits e, quando o latch tem seu
enable ativado, envia os dados pelas saídas Q0 a Q7 para os resistores e LEDs
ligados a ele. Dessa maneira, a coluna correspondente ao latch tem os LEDs
requeridos acesos. A figura mostra o exemplo de 2 latchs e suas respectivas
ligações, como citado anteriormente, o projeto possui 27 desses latchs.
17
Figura 7 – Exemplo das ligações dos latchs (no total são 27 latchs)
A imagem da figura 8 mostra as conexões realizadas no contador HCF4017B,
onde é possível observar a entrada do clock emitido pelo microcontrolador e as
saídas Q1 a Q9 enviadas para os enables dos latchs (como cada contador é ligado a
9 latchs, a saída Q0 não foi utilizada). Um contador é mostrado na figura, são
utilizados 3 contadores para o projeto total.
18
Figura 8 – Exemplo das ligações dos contadores (no total são 3 contadores)
As figuras 9, 10 e 11 mostram os conectores de alimentação, do DB9F e do
programador PICKit3, respectivamente. Esses conectores são utilizados para
realizar as ligações externas da placa, tanto para transferência de informações
quanto para a energização da mesma.
Figura 9 – Conector de alimentação
Figura 10 – Conector DB9F
19
Figura 11 – Conector do programador PICKit3
A placa tem por objetivo comunicar-se com o computador através da porta
serial, assim os dados podem ser repassados ao microcontrolador de forma mais
fácil ao usuário. A figura 12 apresenta as ligações feitas ao conversor serial
MAX232, onde podem ser vistas as ligações de transferência de dados com o
microcontrolador.
Figura 12 – Circuito do conversor serial
Após o esquemático estar completo (anexo C), foi possível realizar o layout
da placa. O layout foi criado, utilizando o software OrCAD, sendo que o fotolito foi
posteriormente impresso em local especializado para conseguir obter um maior nível
de qualidade e pode ser visto nas figuras 13 e 14, onde respectivamente mostram a
parte inferior do fotolito (componentes) e a parte superior (LEDs). O layout pode ser
visto no anexo D com uma maior qualidade.
21
Figura 14 – Lado superior do fotolito
Após o layout impresso, a placa foi confeccionada no laboratório da própria
universidade, e na mesma foi utilizada uma máscara de solda. O processo foi
realizado por técnicos do laboratório, e a placa confeccionada pode ser vista na
22
figura 15, a qual mostra a parte superior e inferior da placa, sem nenhum dos
componentes soldados.
Figura 15 – Placa sem componentes
23
Após a placa estar feita, os componentes foram soldados. Existiu muita
dificuldade no começo, devido à falta de experiência na soldagem de componentes
SMD, mas com algumas dicas do professor orientador e após algum tempo de
trabalho, isso foi tornando-se mais fácil, com o trabalho ficando com uma maior
qualidade.
Com o fim dessa etapa, o firmware começou a ser desenvolvido, para que a
placa pudesse começar a ser testada.
Conforme especificado detalhadamente acima, os materiais utilizados na
montagem foram:
Microcontrolador Microchip da família PIC 18F14K50;
Contador ST HCF4017B;
Latch Philips 74HC373;
LEDs azuis – encapsulamento 0805;
Resistores 100Ω;
Placa de circuito impresso;
Capacitor eletrolítico 100uF;
Conversor serial Maxim MAX232.
24
5 FIRMWARE
Com a placa montada, o firmware necessitava ser criado. Foi utilizada na
programação a linguagem C, que permite a construção de programas e aplicações
muito mais complexas do que seria possível fazer, utilizando Assembly. Também
pela eficiência da linguagem, a qual é a medida do grau de inteligência com que o
compilador traduz um código escrito na linguagem C para a linguagem utilizada na
máquina (PEREIRA, 2007). O firmware do projeto inicial que não havia funcionado
corretamente, foi utilizado como uma fonte de consulta, sendo melhorado de forma a
atender as necessidades do projeto. Utilizou-se o software MPLAB IDE para
escrever o código e assim programar o microcontrolador com o PICKit3, também da
Microchip. A figura 16 mostra uma foto da placa ligada ao programador.
Figura 16 – Programador PICKit3 conectado à placa
Foram feitas pesquisas e estudos em livros de programação e materiais
utilizados em outros anos do curso para aprimorar o uso da linguagem C, mas o
professor orientador também ajudou em algumas dúvidas surgidas no decorrer da
programação.
25
Os primeiros testes foram feitos apenas para acender todas as colunas e
depois apagá-las uma a uma. Dessa forma, foi possível a observação de falhas nas
ligações e começar a criar uma base para a programação.
Após a realização dos primeiros testes, foi estabelecida uma rotina capaz de
apagar completamente os LEDs, usada para o começo e o fim de cada trecho de
texto. Assim, existe a garantia de não existir “lixo” (LEDs acesos incorretamente),
quando se iniciar o funcionamento do painel. Essa rotina foi chamada de
„ZeraPainel‟, a qual primeiramente habilita todos os contadores e depois seta todos
os bits da coluna em „1‟ (apaga o LED), varrendo os latchs correspondentes aos
contadores, conforme pode ser visto pela representação feita na figura 17.
Figura 17 – Representação da rotina ‘ZeraPainel’
A segunda rotina feita foi a de criação de um barramento de dados, a qual vai
repassar as informações para os latchs. Assim esses podem acender os LEDs de
sua coluna, da forma correta. A rotina foi chamada de „CarregaBar‟, que atribui os
valores recebidos que correspondem à coluna dos LEDs, utilizando uma variável
“texto”, para que depois os LEDs corretos possam ser acesos. Essa rotina é
posteriormente utilizada para se conseguir o deslocamento das letras. A figura 18
representa esse procedimento.
26
Figura 18 – Representação da rotina ‘CarregaBar’
Com essa rotina criada, foi programada uma para gerar o clock. Esse sinal
será enviado aos contadores, os quais podem dessa maneira habilitar a saída de
cada latch pela qual é responsável no momento exato, possibilitando que os dados
estejam nas colunas que, juntas, formarão os caracteres. Foi atribuído o nome
„IncColuna‟ à essa rotina, que vai incrementando a variável „coluna‟ e faz o teste
para saber qual contador deve ser habilitado no momento (tendo em vista que cada
contador é responsável por 9 colunas de LEDs). O processo da rotina pode ser visto
na figura 19.
27
Figura 19 – Representação da rotina ‘IncColuna’
Com as rotinas principais criadas, era necessário criar os dados a serem
enviados, os quais mostrariam o real funcionamento do projeto todo. Assim, os
caracteres começaram a ser mapeados.
O mapeamento dos caracteres foi feito individualmente. O desenho de cada
caractere foi feito em um papel, dividindo os mesmos em colunas, e cada coluna em
8 pontos, representando cada LED. Com o desenho de cada um feito, transformou-
se cada coluna em um byte, relacionando cada bit com o estado (aceso ou apagado)
de cada LED ali representado. Foram criadas todas as letras do alfabeto de forma
maiúscula e depois repassadas como „constantes‟ para a linguagem C, cada um em
um vetor. O mapeamento de todos os caracteres pode ser visto no anexo A. A rotina
„LoadBuffer‟ “chama” o caractere requerido e faz a varredura do seu vetor, para
poder ser repassado ao barramento de dados. A figura 20 representa os passos
dessa rotina.
28
Figura 20 – Representação da rotina ‘LoadBuffer’
Tendo o mapeamento ficado pronto, cada letra foi testada e adaptada,
quando possuía algum erro ou dificuldade de leitura. Porém só era possível exibir
quatro letras no painel, então foi criada uma rotina capaz de locomover os
caracteres pela placa. Essa rotina utiliza a criação de um buffer, o qual armazena as
informações do que deve ser exibido em cada varredura da placa. Então a varredura
é realizada novamente e é acrescentada uma nova coluna de dados. Foi utilizado o
nome de „DeslocaColuna‟ e carrega o barramento conforme os ponteiros „Ptr_Text‟
(indica a posição do buffer do texto a ser exibido) e „Ptr_Placa‟ (indica a posição na
placa em que o texto deve ser exibido) vão sendo incrementados, depois utiliza um
cálculo da quantidade de repetições necessárias, para que a placa inteira tenha sido
deslocada. Dessa forma, existe a visualização do texto locomovendo-se sempre da
direita para a esquerda, sempre com as colunas sendo incrementadas
unitariamente. Uma maneira mais fácil de se visualizar os passos é através da figura
21.
29
Figura 21 – Representação da rotina ‘DeslocaColuna’
Com o deslocamento executado, foi possível a criação de textos maiores que
4 caracteres, possibilitando dessa maneira um uso mais eficiente da placa. Para
corrigir os problemas com diferença na velocidade do deslocamento no início e no
fim do painel, foram alterados os tempos de delay, de forma que a velocidade se
tornasse o mais uniforme possível.
A comunicação serial foi então desenvolvida, utilizando uma lógica de enviar
apenas um byte de início de pacote, os bytes com as informações de texto e um
byte de fim de pacote. No caso, cada byte referente ao texto equivale a um
caractere, o qual é representado em 5 colunas de LEDs. Quando o byte de fim de
pacote é recebido, os bytes de texto são carregados no buffer de texto que, por fim,
carrega o barramento de dados com as informações necessárias a serem exibidas.
O código encontra-se no anexo B, o mesmo está escrevendo o texto „PAINEL
LED‟. Após isso, ele apaga o painel e escreve „DEEL‟. Depois retorna ao início.
Pode-se visualizar, no decorrer do anexo, todas as etapas do código, apresentando
os „defines‟, o firmware feito e a inicialização dos registradores. Foram feitos vários
comentários durante o código, para melhor ser compreendido, além de, nos
parágrafos anteriores, as rotinas terem sido explicadas detalhadamente.
30
Para a gravação dos dados foi então utilizado:
Programador Microchip PICkit 3;
E para a criação do firmware foi utilizado o software:
MPLAB IDE
31
6 ANÁLISE DOS RESULTADOS
Em função do primeiro protótipo não ter funcionado de maneira correta, o
tempo gasto para a elaboração do mesmo atrapalhou um pouco o tempo total do
projeto, pois foi demorada a criação de um novo layout e também do agendamento
para a confecção da placa no laboratório. Dessa forma, o tempo encurtou-se e as
soluções para os problemas surgidos tiveram de ser rápidas.
Após a confecção, tiveram de ser soldadas todas as vias que atravessavam a
placa (em torno de 900 vias) e também existia a dificuldade inicial de se soldar
componentes SMD. Isso foi superado com a prática, fazendo com que esta tarefa
fosse cada vez sendo executada mais rápida e com mais precisão.
Depois que o firmware começou a ser testado, existiram muitos LEDs que não
acendiam no momento desejado. Assim foi necessário novamente fazer o teste em
praticamente todos os componentes, encontrando vários pontos com contatos ruins
que tiveram de ser refeitos, e também, no decorrer dos testes, alguns componentes
apresentaram problemas e tiveram que ser trocados.
Com os componentes testados e os problemas com o hardware resolvidos,
existiram problemas na programação do firmware, muitos deles de certa forma bem
simples, mas que prejudicavam o resultado final do funcionamento do painel. Esses
problemas foram encontrados e arrumados individualmente, de forma a fazer o
projeto funcionar da melhor maneira possível.
A placa pode ser vista na figura 22, podendo ser visualizados os LEDs que
formarão o painel visual, após estarem em funcionamento. Podem-se visualizar
alguns fios ligados em alguns lugares, formando jumpers. Estes fios foram utilizados
para consertar problemas de mau funcionamento nas vias ou trilhas que haviam sido
danificadas no processo de confecção ou manuseio da placa. Essa foi a melhor
solução encontrada, para que o painel funcionasse corretamente.
33
Após a solução dos principais problemas, o painel conseguiu executar a
exibição dos caracteres conforme tinham sido programados, passando a exibir o
texto de maneira correta. A figura 23 mostra uma imagem do painel em
funcionamento, com a palavra „LED‟ escrita. Pela foto, pode-se ver que realmente os
LEDs apresentam uma boa luminosidade, conforme tinha sido objetivado no início e
como a palavra estava deslocando-se, ela já se encontrava no meio do painel. Pode
ser observado o fato de que, nessa etapa, existiam ainda problemas com alguns
LEDs acesos incorretamente. Isto se leva ao fato de que, durante todo o processo
os erros foram arrumados em decorrência de seus aparecimentos. Todos os defeitos
que surgiram foram consertados no decorrer da elaboração do projeto.
Figura 23 – Placa em funcionamento
Após o painel estar ligado, foi medida a corrente necessária para que o
mesmo funcionasse corretamente. Dessa forma, encontrou-se que a corrente
máxima era de 2A. Como a placa funciona com uma entrada de 5V, pelo cálculo
relacionado potência, corrente e tensão (P=U*I), temos que a potência consumida é
de 10W (a qual foi medida com todos os LEDs acesos).
34
A função do deslocamento pode ser acompanhada nas figuras 24, 25 e 26.
Pode-se notar que as palavras “PAINEL LED” estão se locomovendo da direita para
a esquerda de maneira correta, permitindo que o texto completo possa ser
visualizado de forma clara.
Figura 24 – Deslocamento dos caracteres (parte 1)
Figura 25 – Deslocamento dos caracteres (parte 2)
Figura 26 – Deslocamento dos caracteres (parte 3)
Além dos resultados palpáveis apresentados, foi possível melhorar bastante o
conhecimento em linguagem C, a qual havia sido estudada durante a graduação,
porém não havia sido aplicada de forma tão eficiente. Com esse aprimoramento e
materiais utilizados no decorrer do processo, será possível desenvolver novos
projetos em diferentes tipos de áreas de atuação.
35
7 CONCLUSÕES
Desde o princípio, um dos principais objetivos era conseguir realizar o projeto
e montagem de um painel de LEDs o qual apresentasse um resultado satisfatório,
eficiente e, ao mesmo tempo, que o valor total do projeto fosse baixo. Esse objetivo
foi amplamente atingido, com a placa funcionando de maneira eficaz, e os custos
finais foram reduzidos.
Em relação ao hardware da placa, verificou-se a possibilidade de reduzir o
tamanho da mesma, o que não foi feito devido ao tempo, porém houve estudos que
mostraram que seria eficiente a redução física do painel, pois normalmente os
painéis encontrados para comercialização possuem uma proximidade maior entre os
LEDs e demais componentes, podendo apresentar, no mesmo tamanho utilizado
nesse projeto, um número maior de LEDs, obtendo uma melhor qualidade de
visualização.
Alguns dos problemas encontrados foram devido à maneira da confecção da
placa. Uma maneira mais adequada de realizar um projeto futuro seria fazer um
investimento mais elevado e confeccionar em lugar que utilizasse um processo
industrial, o qual já repassasse a placa com as vias que a atravessam, prontas
(metalização). Este ato pouparia grande tempo na montagem e também diminuiria
consideravelmente os erros encontrados no decorrer do processo.
Toda a elaboração do projeto exigiu um tempo alto de trabalho, devido a isso
e ao orçamento a que foi submetido o projeto, tendo como um dos principais
objetivos um custo reduzido, as escolhas feitas durante o mesmo mostraram-se
eficientes, atingindo, ao final, bons resultados e conseguindo atender às
necessidades previamente calculadas e também as que surgiram no decorrer do
projeto.
A implementação da comunicação via serial não foi concluída, porém já existe
um início do processo de firmware da mesma, e o hardware (conversor serial) já está
inserido na placa. Assim, após a conclusão do trabalho, espera-se conseguir fazer
essa comunicação eficiente e, dessa forma, aprimorar o projeto como um todo.
O trabalho como um todo aprimorou o conhecimento teórico e prático do
autor, pois, além dos estudos prévios e durante a realização dos mesmos, buscando
atingir os objetivos iniciais, os problemas que surgiram e a necessidade de encontrar
36
soluções o mais rápido possível, com certeza foi um fator que influenciou
positivamente o desenvolver do projeto e ainda mais o aprendizado do autor.
37
8 REFERÊNCIAS
BRAIN, Marshall. "HowStuffWorks - Como funcionam os
microcontroladores". Publicado em 01 de abril de 2000 (atualizado em 08 de
maio de 2008). Disponível em
http://eletronicos.hsw.uol.com.br/microcontroladores1.htm (acessado em 02 de
outubro de 2011).
CASTRO, F. C .C. Eletrônica Digital. PUCRS, 2002.
KHANH, Tran Quoc. LEDs: tecnologia para qualidade da iluminação e
eficiência energética. Revista eletricidade moderna, ed. 446, p. 58-67. Maio, 2011.
KOTLER , Philip.Administração de Marketing. São Paulo: Prentice Hall,
2000. 764 p.
MAXIM, MAX232 Datasheet. Disponível em http://www.maxim-ic.com. 2010.
MICROCHIP, PIC18F14K50 Datasheet. Disponível em
http://www.microchip.com. 2010.
PENTEADO, J. R. Whitaker. A técnica da comunicação humana. São
Paulo: Pioneira, 1991. 25.
PEREIRA, Fábio. Microcontroladores PIC - Programação em C. 7ª.
Edição. Editora Érica. 2007.
PHILIPS, 74HC373 Datasheet. Disponivel em
http://www.datasheetcatalog.com. 1993.
PIMENTA, José Luiz. LED: uma fonte promissora de luz. Revista Lume
Arquitetura, ed.23, p. 34-40. 2007.
38
SEDRA, A. S.; Smith, K. C. Microeletrônica. 5ª. Edição. Prentice Hall. 2007.
SILVA JÚNIOR, Vidal Pereira da. Microcontroladores. São Paulo: Érica,
1988.
SOUZA, David José de. Desbravando o PIC. 4ª. Edição. Editora Érica. 1999.
SOUZA, Vitor Amadeu. Programação em BASIC para o microcontrolador
PIC18F1220. Editora Érica. 2006.
ST, HCF4017B Datasheet. Disponivel em http://www.st.com. 2001.
TOCCI, Ronald J. Sistemas Digitais: princípios e aplicações. 7ª. Edição. .
Prentice Hall. 1998.
40
ANEXO A – MAPA DE CARACTERES
Caracteres Bits Coluna 1
Coluna 2
Coluna 3
Coluna 4
Coluna 5
A
Bit 0 1 1 1 1 1
Bit 1 1 1 0 1 1
Bit 2 1 0 1 0 1
Bit 3 0 1 1 1 0
Bit 4 0 0 0 0 0
Bit 5 0 1 1 1 0
Bit 6 0 1 1 1 0
Bit 7 0 1 1 1 0
B
Bit 0 1 1 1 1 1
Bit 1 0 0 0 0 1
Bit 2 0 1 1 1 0
Bit 3 0 1 1 1 0
Bit 4 0 0 0 0 1
Bit 5 0 1 1 1 0
Bit 6 0 1 1 1 0
Bit 7 0 0 0 0 1
C
Bit 0 1 1 1 1 1
Bit 1 1 0 0 0 0
Bit 2 0 1 1 1 1
Bit 3 0 1 1 1 1
Bit 4 0 1 1 1 1
Bit 5 0 1 1 1 1
Bit 6 0 1 1 1 1
Bit 7 1 0 0 0 0
D
Bit 0 1 1 1 1 1
Bit 1 0 0 0 1 1
Bit 2 0 1 1 0 1
Bit 3 0 1 1 1 0
Bit 4 0 1 1 1 0
Bit 5 0 1 1 1 0
Bit 6 0 1 1 0 1
Bit 7 0 0 0 1 1
E
Bit 0 1 1 1 1 1
Bit 1 0 0 0 0 0
Bit 2 0 1 1 1 1
Bit 3 0 1 1 1 1
Bit 4 0 0 0 0 0
Bit 5 0 1 1 1 1
Bit 6 0 1 1 1 1
Bit 7 0 0 0 0 0
41
Caracteres Bits Coluna 1
Coluna 2
Coluna 3
Coluna 4
Coluna 5
F
Bit 0 1 1 1 1 1
Bit 1 0 0 0 0 0
Bit 2 0 1 1 1 1
Bit 3 0 1 1 1 1
Bit 4 0 0 0 0 0
Bit 5 0 1 1 1 1
Bit 6 0 1 1 1 1
Bit 7 0 1 1 1 1
G
Bit 0 1 1 1 1 1
Bit 1 1 0 0 0 0
Bit 2 0 1 1 1 1
Bit 3 0 1 1 1 1
Bit 4 0 1 0 0 1
Bit 5 0 1 1 1 0
Bit 6 0 1 1 1 0
Bit 7 1 0 0 0 1
H
Bit 0 1 1 1 1 1
Bit 1 0 1 1 1 0
Bit 2 0 1 1 1 0
Bit 3 0 1 1 1 0
Bit 4 0 0 0 0 0
Bit 5 0 1 1 1 0
Bit 6 0 1 1 1 0
Bit 7 0 1 1 1 0
I
Bit 0 1 1 1 1 1
Bit 1 0 0 0 0 0
Bit 2 1 1 0 1 1
Bit 3 1 1 0 1 1
Bit 4 1 1 0 1 1
Bit 5 1 1 0 1 1
Bit 6 1 1 0 1 1
Bit 7 0 0 0 0 0
J
Bit 0 1 1 1 1 1
Bit 1 0 0 0 0 0
Bit 2 1 1 1 0 1
Bit 3 1 1 1 0 1
Bit 4 1 1 1 0 1
Bit 5 0 1 1 0 1
Bit 6 0 1 1 0 1
Bit 7 0 0 0 0 1
42
Caracteres Bits Coluna 1
Coluna 2
Coluna 3
Coluna 4
Coluna 5
K
Bit 0 1 1 1 1 1
Bit 1 0 1 1 1 0
Bit 2 0 1 1 0 1
Bit 3 0 1 0 1 1
Bit 4 0 0 1 1 1
Bit 5 0 1 0 1 1
Bit 6 0 1 1 0 1
Bit 7 0 1 1 1 0
L
Bit 0 1 1 1 1 1
Bit 1 0 1 1 1 1
Bit 2 0 1 1 1 1
Bit 3 0 1 1 1 1
Bit 4 0 1 1 1 1
Bit 5 0 1 1 1 1
Bit 6 0 1 1 1 1
Bit 7 0 0 0 0 0
M
Bit 0 1 1 1 1 1
Bit 1 0 1 1 1 0
Bit 2 0 0 1 0 0
Bit 3 0 1 0 1 0
Bit 4 0 1 1 1 0
Bit 5 0 1 1 1 0
Bit 6 0 1 1 1 0
Bit 7 0 1 1 1 0
N
Bit 0 1 1 1 1 1
Bit 1 0 1 1 1 0
Bit 2 0 0 1 1 0
Bit 3 0 1 0 1 0
Bit 4 0 1 0 1 0
Bit 5 0 1 0 1 0
Bit 6 0 1 1 0 0
Bit 7 0 1 1 1 0
O
Bit 0 1 1 1 1 1
Bit 1 1 0 0 0 1
Bit 2 0 1 1 1 0
Bit 3 0 1 1 1 0
Bit 4 0 1 1 1 0
Bit 5 0 1 1 1 0
Bit 6 0 1 1 1 0
Bit 7 1 0 0 0 1
43
Caracteres Bits Coluna 1
Coluna 2
Coluna 3
Coluna 4
Coluna 5
P
Bit 0 1 1 1 1 1
Bit 1 0 0 0 0 0
Bit 2 0 1 1 1 0
Bit 3 0 1 1 1 0
Bit 4 0 0 0 0 0
Bit 5 0 1 1 1 1
Bit 6 0 1 1 1 1
Bit 7 0 1 1 1 1
Q
Bit 0 1 1 1 1 1
Bit 1 0 0 0 0 1
Bit 2 0 1 1 0 1
Bit 3 0 1 1 0 1
Bit 4 0 1 1 0 1
Bit 5 0 1 0 0 1
Bit 6 0 0 0 0 1
Bit 7 1 1 1 1 0
R
Bit 0 1 1 1 1 1
Bit 1 0 0 0 0 1
Bit 2 0 1 1 1 0
Bit 3 0 1 1 1 0
Bit 4 0 0 0 0 1
Bit 5 0 1 0 1 1
Bit 6 0 1 1 0 1
Bit 7 0 1 1 1 0
S
Bit 0 1 1 1 1 1
Bit 1 0 0 0 0 0
Bit 2 0 1 1 1 1
Bit 3 0 1 1 1 1
Bit 4 0 0 0 0 0
Bit 5 1 1 1 1 0
Bit 6 1 1 1 1 0
Bit 7 0 0 0 0 0
T
Bit 0 1 1 1 1 1
Bit 1 0 0 0 0 0
Bit 2 1 1 0 1 1
Bit 3 1 1 0 1 1
Bit 4 1 1 0 1 1
Bit 5 1 1 0 1 1
Bit 6 1 1 0 1 1
Bit 7 1 1 0 1 1
44
Caracteres Bits Coluna 1
Coluna 2
Coluna 3
Coluna 4
Coluna 5
U
Bit 0 1 1 1 1 1
Bit 1 0 1 1 1 0
Bit 2 0 1 1 1 0
Bit 3 0 1 1 1 0
Bit 4 0 1 1 1 0
Bit 5 0 1 1 1 0
Bit 6 0 1 1 1 0
Bit 7 1 0 0 0 1
V
Bit 0 1 1 1 1 1
Bit 1 0 1 1 1 0
Bit 2 0 1 1 1 0
Bit 3 0 1 1 1 0
Bit 4 0 1 1 1 0
Bit 5 0 1 1 1 0
Bit 6 1 0 1 0 1
Bit 7 1 1 0 1 1
W
Bit 0 1 1 1 1 1
Bit 1 0 1 1 1 0
Bit 2 0 1 1 1 0
Bit 3 0 1 1 1 0
Bit 4 0 1 1 1 0
Bit 5 0 1 0 1 0
Bit 6 0 0 1 0 0
Bit 7 0 1 1 1 0
X
Bit 0 1 1 1 1 1
Bit 1 0 1 1 1 0
Bit 2 1 0 1 0 1
Bit 3 1 1 0 1 1
Bit 4 1 1 0 1 1
Bit 5 1 1 0 1 1
Bit 6 1 0 1 0 1
Bit 7 0 1 1 1 0
45
Caracteres Bits Coluna 1
Coluna 2
Coluna 3
Coluna 4
Coluna 5
Y
Bit 0 1 1 1 1 1
Bit 1 0 1 1 1 0
Bit 2 1 0 1 0 1
Bit 3 1 1 0 1 1
Bit 4 1 1 0 1 1
Bit 5 1 1 0 1 1
Bit 6 1 1 0 1 1
Bit 7 1 1 0 1 1
Z
Bit 0 1 1 1 1 1
Bit 1 0 0 0 0 0
Bit 2 1 1 1 1 0
Bit 3 1 1 1 0 1
Bit 4 0 0 0 0 0
Bit 5 1 0 1 1 1
Bit 6 0 1 1 1 1
Bit 7 0 0 0 0 0
46
ANEXO B – CÓDIGO COMPLETO DO FIRMWARE
/** D E C L A R A T I O N S **************************************************/
typedef enum FALSE, TRUE BOOL;
/** D E F I N I T I O N S ****************************************************/
#define clock LATCbits.LATC2
#define reset_cont1 LATBbits.LATB4
#define reset_cont2 LATCbits.LATC0
#define reset_cont3 LATCbits.LATC1
#define DB0 LATAbits.LATA5
#define DB1 LATAbits.LATA4
#define DB2 LATCbits.LATC5
#define DB3 LATCbits.LATC4
#define DB4 LATCbits.LATC3
#define DB5 LATCbits.LATC6
#define DB6 LATCbits.LATC7
#define DB7 LATBbits.LATB6
#define true 1
#define false 0
#define ZERO 0x00
#define espaco 0b11111111
47
/** I N C L U D E S **************************************************/
#include "p18f14k50.h"
#include "LED.h"
#include "delays.h"
#include "adc.h"
#include "usart.h"
#include "timers.h"
#include "math.h"
/** P R O T O T Y P E S *****************************************/
void DeslocaColuna(void);
extern void InicializaRegistradores(void);
void CarregaBar(int dados);
void LoadBuffer (char text);
void IncColuna (void);
void InicializaVariaveis(void);
void ZeraPainel(void);
void DELAY_US(int delay);
/** D E C L A R A T I O N S *******************************************/
rom const unsigned char char_A[]=0b11100000, 0b11010111, 0b10110111, 0b11010111,
0b11100000;
rom const unsigned char char_B[]=0b10000000, 0b10110110, 0b10110110, 0b10110110,
0b11001001;
rom const unsigned char char_C[]=0b11000001, 0b10111110, 0b10111110, 0b10111110,
0b10111110;
rom const unsigned char char_D[]=0b10000000, 0b10111110, 0b10111110, 0b11011101,
0b11100011;
rom const unsigned char char_E[]=0b10000000, 0b10110110, 0b10110110, 0b10110110,
0b10110110;
rom const unsigned char char_F[]=0b10000000, 0b10110111, 0b10110111, 0b10110111,
0b10110111;
rom const unsigned char char_G[]=0b11000001, 0b10111110, 0b10110110, 0b10110110,
0b10111001;
rom const unsigned char char_H[]=0b10000000, 0b11110111, 0b11110111, 0b11110111,
0b10000000;
48
rom const unsigned char char_I[]=0b10111110, 0b10111110, 0b10000000, 0b10111110,
0b10111110;
rom const unsigned char char_J[]=0b10111000, 0b10111110, 0b10111110, 0b10000000,
0b10111111;
rom const unsigned char char_K[]=0b10000000, 0b11110111, 0b11101011, 0b11011101,
0b10111110;
rom const unsigned char char_L[]=0b10000000, 0b11111110, 0b11111110, 0b11111110,
0b11111110;
rom const unsigned char char_M[]=0b10000000, 0b11011111, 0b11101111, 0b11011111,
0b10000000;
rom const unsigned char char_N[]=0b10000000, 0b11011111, 0b11100011, 0b11111101,
0b10000000;
rom const unsigned char char_O[]=0b11000001, 0b10111110, 0b10111110, 0b10111110,
0b11000001;
rom const unsigned char char_P[]=0b10000000, 0b10110111, 0b10110111, 0b10110111,
0b10000111;
rom const unsigned char char_Q[]=0b10000001, 0b10111101, 0b10111001, 0b10000001,
0B11111110;
rom const unsigned char char_R[]=0b10000000, 0b10110111, 0b10110011, 0b10110101,
0b11001110;
rom const unsigned char char_S[]=0b10000110, 0b10110110, 0b10110110, 0b10110110,
0b10110000;
rom const unsigned char char_T[]=0b10111111, 0b10111111, 0b10000000, 0b10111111,
0b10111111;
rom const unsigned char char_U[]=0b10000001, 0b11111110, 0b11111110, 0b11111110,
0b10000001;
rom const unsigned char char_V[]=0b10000011, 0b11111101, 0b11111110, 0b11111101,
0b10000011;
rom const unsigned char char_W[]=0b10000000, 0b11111101, 0b11111011, 0b11111101,
0b10000000;
rom const unsigned char char_X[]=0b10111110, 0b11011101, 0b11100011, 0b11011101,
0b10111110;
rom const unsigned char char_Y[]=0b10111111, 0b11011111, 0b11100000, 0b11011111,
0b10111111;
rom const unsigned char char_Z[]=0b10110100, 0b10110010, 0b10110110, 0b10100110,
0b10010110;
/** V A R I A B L E S *************************************************/
unsigned char Ptr_Text=0;
unsigned char Ptr_Placa=0;
49
unsigned char coluna = 0;
unsigned short int Num_Col = 0;
unsigned short int qtd_vezes;
unsigned char flag;
/** S T R U C T S and U N I O N S *************************************************/
union
volatile unsigned char Col;
volatile struct
unsigned bit0:1;
unsigned bit1:1;
unsigned bit2:1;
unsigned bit3:1;
unsigned bit4:1;
unsigned bit5:1;
unsigned bit6:1;
unsigned bit7:1;
led;
texto[253];
/** M A I N F U N C T I O N *************************************************/
void main (void)
int i=1;
InicializaRegistradores();
InicializaVariaveis();
INTCONbits.GIEH = 0; // disable all interrupts including low priority.
Delay10KTCYx(250);
ZeraPainel();
reset_cont1 = 1;
reset_cont2 = 1;
reset_cont3 = 1;
while(1)
50
ClrWdt();
DDelay10KTCYx(250);
Num_Col=0;
LoadBuffer('P');
LoadBuffer('A');
LoadBuffer('I');
LoadBuffer('N');
LoadBuffer('E');
LoadBuffer('L');
LoadBuffer(0);
LoadBuffer('L');
LoadBuffer('E');
LoadBuffer('D');
DeslocaColuna();
ZeraPainel();
Num_Col = 0;
LoadBuffer('D');
LoadBuffer('E');
LoadBuffer('E');
LoadBuffer('L');
DeslocaColuna();
ZeraPainel();
void LoadBuffer (char text)
int i;
switch (text)
case 0x00:
texto[Num_Col].Col = 0xFF;
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
case 0x41:
for (i=0;i<5;i++)
51
texto[Num_Col].Col = char_A[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
case 0x42:
for (i=0;i<5;i++)
texto[Num_Col].Col = char_B[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
case 0x43:
for (i=0;i<5;i++)
texto[Num_Col].Col = char_C[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
case 0x44:
for (i=0;i<5;i++)
texto[Num_Col].Col = char_D[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
case 0x45:
for (i=0;i<5;i++)
texto[Num_Col].Col = char_E[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
case 0x46:
52
for (i=0;i<5;i++)
texto[Num_Col].Col = char_F[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
case 0x47:
for (i=0;i<5;i++)
texto[Num_Col].Col = char_G[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
case 0x48:
for (i=0;i<5;i++)
texto[Num_Col].Col = char_H[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
case 0x49:
for (i=0;i<5;i++)
texto[Num_Col].Col = char_I[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
case 0x4A:
for (i=0;i<5;i++)
texto[Num_Col].Col = char_J[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
case 0x4B:
53
for (i=0;i<5;i++)
texto[Num_Col].Col = char_K[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
case 0x4C:
for (i=0;i<5;i++)
texto[Num_Col].Col = char_L[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
case 0x4D:
for (i=0;i<5;i++)
texto[Num_Col].Col = char_M[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
case 0x4E:
for (i=0;i<5;i++)
texto[Num_Col].Col = char_N[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;case 0x4F:
for (i=0;i<5;i++)
texto[Num_Col].Col = char_O[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
case 0x50:
54
for (i=0;i<5;i++)
texto[Num_Col].Col = char_P[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
case 0x51:
for (i=0;i<5;i++)
texto[Num_Col].Col = char_Q[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
case 0x52:
for (i=0;i<5;i++)
texto[Num_Col].Col = char_R[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
case 0x53:
for (i=0;i<5;i++)
texto[Num_Col].Col = char_S[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
case 0x54:
for (i=0;i<5;i++)
texto[Num_Col].Col = char_T[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
case 0x55:
55
for (i=0;i<5;i++)
texto[Num_Col].Col = char_U[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
case 0x56:
for (i=0;i<5;i++)
texto[Num_Col].Col = char_V[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
case 0x57:
for (i=0;i<5;i++)
texto[Num_Col].Col = char_W[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
case 0x58:
for (i=0;i<5;i++)
texto[Num_Col].Col = char_X[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
case 0x59:
for (i=0;i<5;i++)
texto[Num_Col].Col = char_Y[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
case 0x5A:
56
for (i=0;i<5;i++)
texto[Num_Col].Col = char_Z[i];
Num_Col++;
texto[Num_Col].Col = 0xFF;
Num_Col++;
break;
void IncColuna (void)
if (coluna == 1) //Primeira Coluna?
reset_cont1 = 0; //Habilita Contador 1
else if (coluna == 10) //Primeira coluna do contador 2?
reset_cont1 = 1; //Desabilita Contador 1
reset_cont2 = 0; //habilita contador 2
else if (coluna ==19) //Primeira Coluna do Contador 3?
reset_cont2 = 1; //Desabilita Contador 2
reset_cont3 = 0; //Habilita Contador 1
clock = 1; //Incrementa contagem
DELAY_US (1000); //com borda de subida
clock = 0;
DELAY_US (800);
coluna++;
if (coluna == 29) //Se contagem chega ao fim
reset_cont3 = 1; //Desabilita contador 3
coluna = 0; //Reinicia contagem de Coluna
57
void InicializaVariaveis(void)
unsigned char i;
ClrWdt();
clock = 0; // saída do clock p/ os 4017 que é sensivel a borda de subida.
DB0 = 1; // setar o barramento de dados para
DB1 = 1; //apagar os LEDs (os LEDs tem lógica inversa)
DB2 = 1;
DB3 = 1;
DB4 = 1;
DB5 = 1;
DB6 = 1;
DB7 = 1;
// reset_cont = 1 --> reseta o 4017. reset_cont = 0 --> habilita o 4017
reset_cont1 = 1; // reseto contador 1
reset_cont2 = 1; // reseto contador 2
reset_cont3 = 1; // reseto contador 3
ZeraPainel();
void ZeraPainel(void)
unsigned char i;
reset_cont1 = 0; //Habilita todos os contadores
reset_cont2 = 0; //Habilita todos os contadores
reset_cont3 = 0; //Habilita todos os contadores
DB0 = 1; // setar o barramento de dados para apagar
DB1 = 1; // os LEDs (os LEDs tem lógica inversa)
DB2 = 1;
DB3 = 1;
DB4 = 1;
DB5 = 1;
DB6 = 1;
DB7 = 1;
for(i = 0; i < 9; i++)
clock = 1;
58
DELAY_US (250);
clock = 0;
DELAY_US (250);
flag = 0;
void DeslocaColuna(void)
unsigned long int j;
unsigned long int aux;
reset_cont1 = 1;
reset_cont2 = 1;
reset_cont3 = 1;
Ptr_Placa = 0;
Ptr_Text = 0;
aux = Num_Col + 28;
qtd_vezes= 528 +28*Num_Col;//(aux*(aux/2)+aux/2);
for (j=0;j<qtd_vezes;j++)
if (Ptr_Text==Ptr_Placa || coluna == 28) //fim do texto a ser exibido
// até o momento
IncColuna(); //Ou tamanho da placa atingido
CarregaBar(0);
Ptr_Text=0;
Ptr_Placa++;
reset_cont1 = 1;
reset_cont2 = 1;
reset_cont3 = 1;
coluna = 0;
else if (Ptr_Placa-Ptr_Text<Num_Col)
IncColuna();
CarregaBar(Ptr_Placa-Ptr_Text);
Ptr_Text++;
else //Fim do texto
IncColuna(); //Desloca texto até o fim apagando o painel
DB0 = 1;
59
DB1 = 1;
DB2 = 1;
DB3 = 1;
DB4 = 1;
DB5 = 1;
DB6 = 1;
DB7 = 1;
Ptr_Text++;
void CarregaBar (int dados)
DB0 = texto[dados].led.bit7;
DB1 = texto[dados].led.bit6;
DB2 = texto[dados].led.bit5;
DB3 = texto[dados].led.bit4;
DB4 = texto[dados].led.bit3;
DB5 = texto[dados].led.bit2;
DB6 = texto[dados].led.bit1;
DB7 = texto[dados].led.bit0;
void DELAY_US(int delay)
do
ClrWdt();
while(delay-- != 1);
60
#include "p18f14k50.h"
#include "LED.h"
#include "timers.h"
#include "usart.h"
#include "pwm.h"
#include "delays.h"
/*** Device configuration registers ***/
/* CONFIG1L
* CPUDIV = NOCLKDIV No CPU System Clock divide
* USBDIV = OFF USB Clock comes directly from the OSC1/OSC2 oscillator
block; no divide
*/
#pragma config CPUDIV = NOCLKDIV, USBDIV = OFF
/* CONFIG1H
* FOSC = IRC Internal RC oscillator
* PLLEN = OFF PLL is under software control
* PCLKEN = OFF Primary clock is under software control
* FCMEN = OFF Fail-Safe Clock Monitor disabled
* IESO = OFF Oscillator Switchover mode disabled
*/
#pragma config FOSC = IRC, PLLEN = OFF, PCLKEN = OFF, FCMEN = OFF, IESO = OFF
/* CONFIG2L
* PWRTEN = ON Power-up Timer Enable bit: PWRT enabled
* BOREN = ON Brown-out Reset enabled in hardware and software
* BORV = 30 VBOR set to 3.0 V nominal
*/
#pragma config PWRTEN = ON, BOREN = ON, BORV = 30
/* CONFIG2H
* WDTEN = OFF WDT is controlled by SWDTEN bit of the WDTCON register
* WDTPS = 4096 Watchdog Timer Postscale Select bits: 1:4096
*/
#pragma config WDTEN = OFF, WDTPS = 4096
/* CONFIG3H
* MCLRE = OFF MCLR pin is disabled, RE3 input pin is enabled
61
* HFOFST = ON HF-INTOSC starts clocking the CPU without waiting for the oscillator to stablize
*/
#pragma config MCLRE = OFF, HFOFST = ON
/* CONFIG4L
* STVREN = ON Stack full/underflow will cause Reset
* LVP = OFF Single-Supply ICSP disabled. This turns off Low-Voltage-Programming, and
frees the PGM pin to be
used as the RB5 I/O port pin. (LVP mode is not used by the
PICkit 2 programmer.)
* BBSIZ = OFF 1kW boot block size: 1 kW boot block size for
PIC18F14K50/PIC18LF14K50
* XINST = OFF Instruction set extension and Indexed Addressing mode disabled (Legacy
mode)
*/
#pragma config STVREN = ON, LVP = OFF, BBSIZ = OFF, XINST = OFF
/* CONFIG5L
* CP0 = OFF Block 0 (000800-001FFFh) not code-protected
* CP1 = OFF Block 1 (002000-003FFFh) not code-protected
*/
#pragma config CP0 = OFF, CP1 = OFF
/* CONFIG5H
* CPB = OFF Boot block (000000-0007FFh) not code-protected
* CPD = OFF Data EEPROM not code-protected
*/
#pragma config CPB = OFF, CPD = OFF
/* CONFIG6L
* WRT0 = OFF Block 0 (000800-001FFFh) not write-protected
* WRT1 = OFF Block 1 (002000-003FFFh) not write-protected
*/
#pragma config WRT0 = OFF, WRT1 = OFF
/* CONFIG6H
* WRTB = OFF Boot block (000000-0007FFh) not write-protected
* WRTC = OFF Configuration registers (300000-3000FFh) not write-protected
* WRTD = OFF Data EEPROM not write-protected
*/
62
#pragma config WRTB = OFF, WRTC = OFF, WRTD = OFF
/* CONFIG7L
* EBTR0 = OFF Block 0 (000800-001FFFh) not protected from table reads executed in other
blocks
* EBTR1 = OFF Block 1 (002000-003FFFh) not protected from table reads executed in other
blocks
*/
#pragma config EBTR0 = OFF, EBTR1 = OFF
/* CONFIG7H
* EBTRB = OFF Boot block (000000-0007FFh) not protected from table reads executed in other
blocks
*/
#pragma config EBTRB = OFF
// Peripheral initialization function
void InicializaRegistradores(void)
//----------------------------------------------------------------
//Initialize OSCILLATOR CONTROL
// bit 7 IDLEN: Idle Enable bit: 0 = Device enters Sleep mode on SLEEP instruction
// bit 6-4 IRCF<2:0>: Internal Oscillator Frequency Select bits: 111 = 16 MHz (HFINTOSC
drives clock directly)
// bit 1-0 SCS<1:0>: System Clock Select bits: 00 = Primary clock (determined by
CONFIG1H[FOSC<3:0>])
OSCCON = 0b01110000;
// bit 2 PRI_SD: Primary Oscillator Drive Circuit shutdown bit: 0 = Oscillator drive circuit off
(zero power)
// bit 1 HFIOFL: HFINTOSC Frequency Locked bit: 0 = HFINTOSC has not yet locked
OSCCON2 = 0b00000000;
// bit 7 INTSRC: Internal Oscillator Low-Frequency Source Select bit: 0 = 31 kHz device clock
derived directly from LFINTOSC internal oscillator
// bit 6 PLLEN: Frequency Multiplier PLL for HFINTOSC Enable bit: 0 = PLL disabled
// bit 5-0 TUN<5:0>: Frequency Tuning bits: 000000 = Oscillator module is running at the
factory calibrated frequency
OSCTUNE = 0b00000000;
//----------------------------------------------------------------
63
//Initialize PORTA
PORTA = 0x00; // clearing output data latches
LATA = 0x00;
ANSEL = 0b00000000; // PORTA are digital
TRISA = 0b00000000; // PORTA bits RA<7:0> are all outputs(0)
//----------------------------------------------------------------
//Initialize PORTB
PORTB = 0x00; // clearing output data latches
LATB = 0x00;
TRISB = 0b00000000; // PORTB are outputs
INTCON2bits.RABPU = 1; // disable PORTA and PORTB internal pullups
INTCONbits.INT0IF = 0; // clear RB0 INT
INTCONbits.INT0IE = 0; // disable RB0 INT
INTCON2bits.INTEDG0 = 0; // interrupt on falling edge
INTCON2bits.RABIP = 0; // RABIP: RA and RB Port Change Interrupt
Priority bit: 0 = Low priority
//----------------------------------------------------------------
//Initialize PORTC
PORTC = 0x00; // clearing output data latches
LATC = 0x00;
TRISC = 0b00000000; // PORTC bits RC<7:0> are all outputs (0)
//----------------------------------------------------------------
//Initialize TIMER0 //
OpenTimer0( TIMER_INT_OFF & // Interrupt disabled
T0_8BIT & // 8-bit mode
T0_SOURCE_INT & // Internal clock source (TOSC)
T0_PS_1_64 ); // 1:64 prescale
CloseTimer0(); // disable Timer0
INTCON2bits.TMR0IP = 1; // TMR0IP: TMR0 Overflow Interrupt Priority
bit: 1 = high priority
//----------------------------------------------------------------
//Initialize TIMER1 //
OpenTimer1( TIMER_INT_OFF & // Interrupt disabled
T1_8BIT_RW & // 8-bit mode
T1_SOURCE_INT & // Internal clock source (TOSC)
T1_PS_1_1 & // 1:1 prescale
T1_OSC1EN_OFF & // Disable Timer1 oscillator
T1_SYNC_EXT_OFF ); // Don‟t sync external clock input
CloseTimer1(); // Disable Timer1
64
IPR1bits.TMR1IP = 1; // TMR1IP: TMR1 Overflow Interrupt Priority bit: 1 =
high priority
//----------------------------------------------------------------
//Initialize TIMER2 //
OpenTimer2( TIMER_INT_OFF & // Interrupt desabled: PIE1bits.TMR2IE = 0; //
TMR2IE: TMR2 to PR2 Match Interrupt Enable bit: 0 = Disables the TMR2 to PR2 match interrupt
T2_PS_1_1 & // 1:1 prescale
T2_POST_1_1 ); // 1:1 postscale
CloseTimer2(); // Disable Timer2
PR2 = 0b11111111; // Period register set to 0xFF
IPR1bits.TMR2IP = 1; // TMR2IP: TMR2 Overflow Interrupt Priority bit: 0 =
low priority
//----------------------------------------------------------------
//Initialize TIMER3 //
OpenTimer3( TIMER_INT_OFF & // Interrupt disabled
T3_16BIT_RW & // 16-bit mode
T3_SOURCE_INT & // Internal clock source (TOSC)
T3_PS_1_8 & // 1:8 prescale
T3_SYNC_EXT_OFF ); // Don‟t sync external clock input
CloseTimer3(); // Disable Timer3
IPR2bits.TMR3IP = 0; // TMR3IP: TMR3 Overflow Interrupt Priority bit: 0 =
low priority
//----------------------------------------------------------------
// Initialize ADC (A2D Converter Code)
// bit 5-2 CHS<3:0>: Analog Channel Select bits: 0000 = AN0
// bit 1 GO/DONE: A/D Conversion Status bit: 0 = A/D conversion completed/not in progress
(A2D status is idle)
// bit 0 ADON: ADC Enable bit: 0 = ADC is disabled and consumes no operating current
ADCON0 = 0b00000000;
// bit 5 VCFG1: Negative Voltage Reference select bit: 0 = Negative voltage reference
supplied internally by VSS
// bit 4 VCFG0: Positive Voltage Reference select bit: 0 = Positive voltage reference supplied
internally by VDD
ADCON1 = 0b00000000;
// bit 7 ADFM: A/D Conversion Result Format Select bit: 1 = Right justified
// bit 5-3 ACQT<2:0>: A/D Acquisition time select bits: 101 = 12 TAD
// bit 2-0 ADCS<2:0>: A/D Conversion Clock Select bits: 110 = FOSC/64
ADCON2 = 0b10101110;
65
PIE1bits.ADIE = 0; // ADIE: A/D Converter Interrupt Enable bit: 0
= Disables the A/D interrupt
IPR1bits.ADIP = 1; // ADIP: A/D Converter Interrupt Priority bit: 0
= low priority
//----------------------------------------------------------------
// Initialize USART
/* OpenUSART( USART_TX_INT_OFF & // Transmit interrupt OFF
USART_RX_INT_OFF & // Receive interrupt OFF
USART_ASYNCH_MODE & // Asynchronous Mode
USART_EIGHT_BIT & // 8-bit transmit/receive
USART_CONT_RX & // Continuous reception
USART_BRGH_LOW, // Low baud rate: 8-bit/Asynchronous
25 ); // BOUD RATE = 9600 (FOSC/[64 (n+1)])
where n=25
IPR1bits.RCIP = 0; // IPR1:RCIP: EUSART Receive
Interrupt Priority bit 0 = low priority
IPR1bits.TXIP = 0; // IPR1:TXIP: EUSART Transmit
Interrupt Priority bit 0 = low priority
*/
TXSTA = 0b10101000;
RCSTA = 0b10000000;
BAUDCON = 0b00010000;
SPBRG = 25;
//----------------------------------------------------------------
// Set up global interrupts
RCONbits.IPEN = 1; // Enable priority levels on interrupts
INTCONbits.GIEL = 1; // Low priority interrupts enabled
INTCONbits.GIEH = 1; // enabled all interrupts including low priority.
//----------------------------------------------------------------
66
// Interrupt service routines (ISR)
#include "p18f14k50.h"
#include "LED.h"
#include "usart.h"
#include "delays.h"
#include "timers.h"
//prototype declaration
void high_interrupt(void);
void low_interrupt (void);
struct
int m10Seconds;
char Seconds;
char Minutes;
SYS_CLOCK;
struct
int m10Seconds;
int Seconds;
int Minutes;
int Hours;
TIMER;
// High priority interrupt vector
#pragma code high_vector=0x08
void high_vector(void)
_asm
goto high_interrupt //jump to high priority interrupt routine
_endasm
//----------------------------------------------------------------------------
// High priority interrupt routine
#pragma code
#pragma interrupt high_interrupt
67
void high_interrupt(void)
if((INTCONbits.TMR0IE)&&(INTCONbits.TMR0IF))
INTCONbits.TMR0IF = 0; // clear event flag
if((PIE1bits.RCIE)&&(PIR1bits.RCIF))
// RX USART
PIR1bits.RCIF = 0; // clear event flag
if((INTCONbits.INT0IE) && (INTCONbits.INT0IF))
// Interrupção
em INT0(RB0)
INTCONbits.INT0IF = 0; // clear event flag
if((PIE1bits.TMR1IE)&&(PIR1bits.TMR1IF))
// Timer 1
PIR1bits.TMR1IF=0; // clear event flag
if((PIE1bits.TMR2IE)&&(PIR1bits.TMR2IF))
// Timer 2
PIR1bits.TMR2IF=0; // clear event flag
SYS_CLOCK.m10Seconds++;
TIMER.m10Seconds++;
if(SYS_CLOCK.m10Seconds > 99)
SYS_CLOCK.m10Seconds = 0;
SYS_CLOCK.Seconds++;
TIMER.Seconds++;
if(SYS_CLOCK.Seconds > 59)
SYS_CLOCK.Seconds = 0;
SYS_CLOCK.Minutes++;
TIMER.Minutes++;
if(SYS_CLOCK.Minutes > 59)
SYS_CLOCK.Minutes = 0;
TIMER.Hours++;
68
if((PIE2bits.TMR3IE) && (PIR2bits.TMR3IF))
// Timer 3
PIR2bits.TMR3IF = 0; // clear event flag
//----------------------------------------------------------------------------
// Low priority interrupt vector
#pragma code low_vector=0x18
void low_vector (void)
_asm
GOTO low_interrupt //jump to low priority interrupt routine
_endasm
#pragma code
#pragma interruptlow low_interrupt
void low_interrupt (void)
if((PIE2bits.TMR3IE) && (PIR2bits.TMR3IF))
PIR2bits.TMR3IF = 0; // clear event flag
/***** USART Receive(RX) Code *****/
if((PIE1bits.RCIE)&&(PIR1bits.RCIF))
PIR1bits.RCIF = 0;
/***** A2D Converter Code *****/
if((PIE1bits.ADIE)&&(PIR1bits.ADIF))
PIR1bits.ADIF = 0; // clear event flag
69
/***** Timer 0 Code *****/
if((INTCONbits.TMR0IE)&&(INTCONbits.TMR0IF))
INTCONbits.TMR0IF = 0; // clear event flag
/***** Timer 1 Code *****/
if((PIE1bits.TMR1IE)&&(PIR1bits.TMR1IF))
PIR1bits.TMR1IF = 0; // clear event flag
73
Figura A4 – Esquemático Conectores de Alimentação e DB9
Figura A5 – Esquemático Conectores do PICKit3 e USB
Figura A6 – Esquemático dos Contadores HCF4017B
Figura A7 – Esquemático do PIC18F14K50 e do MAX3232
Recommended