Sistemas de Informações Visuais Utilizando Painel com LEDS

Universidade Estadual de Londrina

LUIZ CARLOS MARTINS JÚNIOR

SISTEMAS DE INFORMAÇÕES VISUAIS UTILIZANDO

PAINEL COM LEDS

Londrina

2011



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



PAINEL COM LEDS

LONDRINA

2011

iii

UNIVERSIDADE ESTADUAL DE LONDRINA

CURSO DE GRADUAÇÃO EM ENGENHARIA ELÉTRICA


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.


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

v

“Se eu vi mais longe, foi por estar em pé sobre ombros de gigantes”

Isaac Newton

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 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.

http://www.cadence.com/

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.

20

Figura 13 – Lado inferior do fotolito

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.

32

Figura 22 – Placa com os componentes soldados

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)



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.

39

ANEXOS

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


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


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


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


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


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 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++;


Num_Col++;

break;

case 0x41:

for (i=0;i<5;i++)

51

texto[Num_Col].Col = char_A[i];

Num_Col++;


Num_Col++;

break;

case 0x42:

for (i=0;i<5;i++)

texto[Num_Col].Col = char_B[i];

Num_Col++;


Num_Col++;

break;

case 0x43:

for (i=0;i<5;i++)

texto[Num_Col].Col = char_C[i];

Num_Col++;


Num_Col++;

break;

case 0x44:

for (i=0;i<5;i++)

texto[Num_Col].Col = char_D[i];

Num_Col++;


Num_Col++;

break;

case 0x45:

for (i=0;i<5;i++)

texto[Num_Col].Col = char_E[i];

Num_Col++;


Num_Col++;

break;

case 0x46:

52

for (i=0;i<5;i++)

texto[Num_Col].Col = char_F[i];

Num_Col++;


Num_Col++;

break;

case 0x47:

for (i=0;i<5;i++)

texto[Num_Col].Col = char_G[i];

Num_Col++;


Num_Col++;

break;

case 0x48:

for (i=0;i<5;i++)

texto[Num_Col].Col = char_H[i];

Num_Col++;


Num_Col++;

break;

case 0x49:

for (i=0;i<5;i++)

texto[Num_Col].Col = char_I[i];

Num_Col++;


Num_Col++;

break;

case 0x4A:

for (i=0;i<5;i++)

texto[Num_Col].Col = char_J[i];

Num_Col++;


Num_Col++;

break;

case 0x4B:

53

for (i=0;i<5;i++)

texto[Num_Col].Col = char_K[i];

Num_Col++;


Num_Col++;

break;

case 0x4C:

for (i=0;i<5;i++)

texto[Num_Col].Col = char_L[i];

Num_Col++;


Num_Col++;

break;

case 0x4D:

for (i=0;i<5;i++)

texto[Num_Col].Col = char_M[i];

Num_Col++;


Num_Col++;

break;

case 0x4E:

for (i=0;i<5;i++)

texto[Num_Col].Col = char_N[i];

Num_Col++;


Num_Col++;

break;case 0x4F:

for (i=0;i<5;i++)

texto[Num_Col].Col = char_O[i];

Num_Col++;


Num_Col++;

break;

case 0x50:

54

for (i=0;i<5;i++)

texto[Num_Col].Col = char_P[i];

Num_Col++;


Num_Col++;

break;

case 0x51:

for (i=0;i<5;i++)

texto[Num_Col].Col = char_Q[i];

Num_Col++;


Num_Col++;

break;

case 0x52:

for (i=0;i<5;i++)

texto[Num_Col].Col = char_R[i];

Num_Col++;


Num_Col++;

break;

case 0x53:

for (i=0;i<5;i++)

texto[Num_Col].Col = char_S[i];

Num_Col++;


Num_Col++;

break;

case 0x54:

for (i=0;i<5;i++)

texto[Num_Col].Col = char_T[i];

Num_Col++;


Num_Col++;

break;

case 0x55:

55

for (i=0;i<5;i++)

texto[Num_Col].Col = char_U[i];

Num_Col++;


Num_Col++;

break;

case 0x56:

for (i=0;i<5;i++)

texto[Num_Col].Col = char_V[i];

Num_Col++;


Num_Col++;

break;

case 0x57:

for (i=0;i<5;i++)

texto[Num_Col].Col = char_W[i];

Num_Col++;


Num_Col++;

break;

case 0x58:

for (i=0;i<5;i++)

texto[Num_Col].Col = char_X[i];

Num_Col++;


Num_Col++;

break;

case 0x59:

for (i=0;i<5;i++)

texto[Num_Col].Col = char_Y[i];

Num_Col++;


Num_Col++;

break;

case 0x5A:

56

for (i=0;i<5;i++)

texto[Num_Col].Col = char_Z[i];

Num_Col++;


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



ZeraPainel();

void ZeraPainel(void)

unsigned char i;

reset_cont1 = 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;








void DELAY_US(int delay)

do

ClrWdt();

while(delay-- != 1);

60


#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

//----------------------------------------------------------------



T1_8BIT_RW & // 8-bit mode


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

//----------------------------------------------------------------


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_POST_1_1 ); // 1:1 postscale


PR2 = 0b11111111; // Period register set to 0xFF


low priority

//----------------------------------------------------------------



T3_16BIT_RW & // 16-bit mode



T3_SYNC_EXT_OFF ); // Don‟t sync external clock input



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 "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


// 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))


/***** 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 *****/



70

ANEXO C – Esquemático completo do circuito

Figura A1 – Esquemático Latches 1 a 9 e LEDs

71


72


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

74

ANEXO D – Fotolitos

Figura A8 – Layout da placa

Documents

Sistemas de Informações Visuais Utilizando Painel com LEDS