Escolar Documentos
Profissional Documentos
Cultura Documentos
br
PIC
Introduo programao
de microcontroladores
www.pictronics.com.br
Contedo
1- Introduo PIC geral
2 - Introduo a programao
3 - Acender e apagar Led (delay_chaves) e Display 7 seguimentos
4 - Display LCD
5 - RS232
6 Conversor AD
7 - Interrupo Flag's
8 PWM
9 - EEPROM interna
10 - I2C
Programas utilizados:
MPLAB www.microchip.com
PICC-CCS Lite www.ccsinfo.com
Proteus v7.7 www.labcenter.co.uk
Introduo:
Diferena entre Microprocessador e Microcontrolador
Os microcontroladores, surgidos em torno de dez anos aps o surgimento dos primeiros
microprocessadores, foram uma adaptao da indstria de eletrnica digital para atender
as necessidades do mercado. Essa necessidade se dava pela dificuldade em termos de
custos e complexidade de qualquer circuito digital em sistemas embarcados que
precisasse de um processamento de dados.
Um microprocessador um circuito muito complexo, em forma de circuito integrado,
que pode conter entre alguns milhares (Z80) a 7 milhes de transistores (Pentium II).
Estes transistores internos constituem os mais diversos circuitos lgicos: como
contadores, registradores, decodificadores, e centenas de outros. Estes circuitos lgicos
so dispostos de maneira complexa, dando ao microprocessador a capacidade de
executar operaes lgicas, aritmticas, e de controle. Porm, apesar da sua grande
capacidade de processamento, os microprocessadores so desprovidos de dispositivos
essenciais para o funcionamento de um sistema.
Por exemplo, para se fazer uma simples circuito de controle de um elevador seriam
necessrios um microprocessador, memria ROM para o programa, memoria RAM para
os dados, de uma porta paralela para dar sada aos acionamentos, de uma outra porta pra
receber os sinais digitais dos sensores, de uma porta serial para fazermos as
configuraes e rodarmos os diagnsticos, de um conversor AD para ler o sensor de
carga que informa o peso total das pessoas que entram no elevador, de um temporizador
para medir o tempo que a porta deve ficar aberta, dentre outros. Com essa extensa lista,
chegamos a um circuito cujo diagrama de blocos mostrado na Figura 1.
RISC e CISC
Na sua essncia, uma mquina RISC oferece um nmero muito reduzido de instrues,
desde uma a poucas dezenas, e cada instruo apenas realiza uma ao muito simples.
Se este conjunto satisfizer o critrio de ser genrico, isto , permitir programar qualquer
algoritmo, ento temos de reconhecer a grande vantagem desta abordagem: a sua
simplicidade facilita a construo hardware da arquitetura do microcomtrolador.
Nomeadamente, a Unidade de Controle da CPU fica mais simples e, portanto, menor,
onde ocupa menor rea na pastilha ('chip') do material semicondutor (Silcio,
habitualmente) sobre o qual so implantados os circuitos digitais que realizam os
componentes do controlador. Ficando a Unidade de Controle menor, mais espao livre
fica na CPU, que pode ser aproveitado para outras unidades que aumentem o ritmo de
execues do CPU, por exemplo, um maior nmero de registadores de dados, uma
memria interna ao CPU, etc.
Uma mquina CISC segue uma filosofia oposta, procurando suportar o mais
diretamente possvel os mecanismos das instrues da linguagem de alto nvel. A sua
principal desvantagem que a Unidade de Controle fica mais complexa, dada a
variedade e complexidade das instrues. Para alm do mencionado aspecto de
aumentar o espao ocupado pelos circuitos, isto tambm dificulta as otimizaes das
micro-aes que a Unidade de Controle deve realizar, para obter execues mais rpidas
das instrues. Por exemplo, no modelo CISC, dada a grande variedade de instrues,
estas tm formatos variveis e as suas representaes em bits variam, por exemplo,
desde 1 at 6 bytes, equivalente aos seus tipos.
Observaes importantes:
A letra F (PIC16F877) identifica que o microcontrolador em questo utiliza a tecnologia
FLASH, ou seja, pode ser regravado. Alguns modelos (que utilizam a letra C no nome,
como o PIC16C877) s podem ser gravados uma nica vez e so mais baratos.
Outros modelos da famlia 16 (como o PIC16F870, PIC16F628, PIC16F84, ....)
possuem variaes em termos de recursos (com mais ou com menos pinos de I/Os,
entradas analgicas, memria ROM, memria RAM, etc...), mas todos podem ser
programados com a mesma linguagem.
Modelos da famlia 18 so mais rpidos e um pouco mais caros, continuando a ser de 8
bits.
Modelos da famlia 24 so de 16 bits, e indicados para aplicaes que exijam mais
poder de processamento.
Os microcontroladores PIC so indicados para aplicaes mais simples, que no
necessitem de grande volume de dados manipulados, e que no necessitem
processamento em tempo real de alto desempenho.
Quando transferimos um programa para o microcontrolador, este deve estar em
linguagem de mquina (ARQUIVO HEX), e ser armazenado na memria ROM do
microcontrolador. Esta memria no ser apagada at que outro programa seja enviado,
mesmo que a alimentao de energia eltrica seja desativada.
Requisitos de Hardware
Opcionais:
Introduo programao
Fluxograma:
Os fluxogramas so ferramentas que auxiliam na programao e na codificao de
programas. Na realidade so elementos grficos utilizados para estabelecer a sequencia
de operaes necessrias para o cumprimento de determinada tarefa e,
consequentemente, a resoluo de um problema.
Variveis de dados
Varivel uma representao simblica para elementos pertencentes a um determinado
conjunto. As variveis so armazenadas na memria do microcontrolador e podem
assumir qualquer valor dentro do conjunto de valores possveis.
De fato, as variveis ficam localizadas na memria do equipamento, no em qualquer
tipo de memria, mas na chamada memria RAM. Isto significa que num
microcontrolador, boa parte da memria ocupada por variveis, definidas pelo
programa em execuo.
As variveis so classificadas segundo o tipo de dado que ser armazenado e podem ser:
numricas, caractere, alfanumricas e lgicas.
Variveis e tipos de dados
A linguagem C disponibiliza ao programador uma gama de tipos de dados. A
implementao C da CCS possibilita o uso de quase todos os tipos de dados disponveis
em C padro ANSI.
Tamanho em bits
8
8
32
0
Intervalo
0 a 255
0 a 255
3.4E-38 a 3.4E+38
nenhum valor
Descrio
Caractere
Inteiro
Ponto flutuante
vazio
Modificadores de tipo
Alm dos tipos de dados vistos, podemos utilizar comandos especiais da linguagem C
para modificar os tipos bsicos, de forma a obter outros tipos de dados.
Esses comandos especiais so chamados de modificadores de tipo e so os seguintes:
signed, unsigned, short e long.
O modificador signed pode ser utilizado para modificar um tipo base de dados de forma
que ele possa representar tanto nmeros positivos quanto negativos.
Note que devido ao fato de utilizar um bit para representao do sinal, a magnitude
absoluta da representao do tipo modificado ser metade da magnitude do tipo no
modificado.
Assim, um tipo de dados signed int pode representar valores de -128 a +127 em vez de
0 a 255.
O modificador unsigned define um tipo de dado sem sinal, o que o padro do
compilador da CCS. Note que o padro ANSI especifica que os tipos padro de dados
da linguagem C signed.
J o modificador short utilizado para definir uma varivel de tamanho menor que o do
tipo modificado, ou seja, uma verso reduzida do tipo especificado. Assim, se
especificarmos uma varivel como sendo do tipo short int, ela ser uma verso
reduzida de int, o que no caso do compilador CCS cria uma varivel de apenas 1 bit de
tamanho (o que chamado de flag ou sinalizador).
Finalmente, temos o modificador long, utilizado para ampliar a magnitude da
representao do tipo especificado. Desta forma, um tipo de dado long int ter um
tamanho de 16 bits, ou seja, ir ocupar duas posies de memria RAM do PIC e ter
magnitude de 0 a 65535.
Outros tipos de dados especficos do compilador CCS C
int1: especifica valores de 1 bit (equivalente ao short int padro);
boolean: especifica valores booleanos de bit (equivalente ao short int e int1);
int8: especifica valores de 8 bits;
byte: especifica valores de 8 bits;
int16: especifica valores de 16 bits;
int32: especifica valores de 32 bits.
A seguir, temos uma tabela com todos os tipos de dados disponveis por padro no
compilador CCS:
Operadores
A linguagem C possui uma gama de operadores, sendo possivelmente uma das
linguagens com maior numero de operadores disponvel atualmente.
Esta caracterstica e um dos pontos positivos da linguagem, j que C agrega aos
operadores comumente encontrados nas linguagens de alto nvel, os operadores
encontrados frequentemente em linguagens de baixo nvel como o Assembly.
Podemos classificar os operadores da linguagem C em sete categorias principais:
atribuio, aritmticos, relacionais, lgicos, lgicos bit a bit, de memoria e outros.
Atribuio
A primeira categoria de operadores e tambm a mais utilizada. Em C, o operador de
atribuio "=" e utilizado para atribuir um determinado valor a uma varivel. Um
exemplo de atribuio:
x = 10;
y = x;
Podemos verificar no programa anterior duas operaes de atribuio: na primeira foi
atribudo o valor 10 a varivel "x", na segunda, foi atribudo o valor de "x" (que e 10) a
varivel "y". Conclui-se ento que ao final do programa, "y" ser igual a 10.
Repare que a atribuio e sempre avaliada da direita para a esquerda no e possvel
realizar uma atribuio no sentido inverso.
Aritmticos
So utilizados para determinar ao compilador que efetue determinada operao
matemtica em relao a um ou mais dados:
Operador
+
*
/
%
++
--
Ao
Adio
Subtrao
Multiplicao
Diviso
Resto de diviso inteira
Incremento
Decremento
Tabela de operadores
Os operadores de adio, subtrao, multiplicao e diviso dispensam comentrios.
O operador % e utilizado para retornar o resto de uma operao de diviso inteira.
Vejamos um exemplo:
5 / 2 = 2,5 em uma diviso real, ou 5 / 2 = 2, em uma diviso inteira, sendo o
resto igual a 1.
Assim, o resultado de 5 / 2 2 e o resultado de 5%2 e igual a 1.
Os operadores de incremento e decremento so utilizados para somar 1 (incremento) ou
subtrair 1 (decremento) de uma varivel.
A forma geral para utilizao destes dois ltimos operadores :
variavel++; ou variavel--;
Ou ainda por meio de uma atribuio:
variavel_1 = variavel_2 ++; ou variavel_1 = variavel_2 --;
Observe que em ambos os casos, a atribuio ocorre da seguinte forma: o valor da
varivel "variavel_2" e armazenado em varivel_1 e apos isso o contedo de
"variave_2" incrementado ou decrementado.
No entanto, em C e tambm possvel escrever:
variavel_1 = ++ variavel_2; ou variavel_1 = -- variavel_2;
Nestes casos, a operao de Incremento/decremento realizada antes da atribuio
propriamente dita.
Vejamos um exemplo:
int x, y, z;
x = 0;
y = x ++;
z = ++ x;
Neste caso, aps a execuo dos trs comandos, o valor da varivel x ser igual a 2, o
valor da varivel y ser igual a 0 e o valor da varivel z ser igual a 2.
Observao importante: No e possvel utilizar os operadores de incremento ou
decremento com variveis ou tipos de dados complexos, tais como os tipos ponto
flutuante.
Note que ha uma diferena clara entre escrever "y = x + 1" e "y = ++x":
Ambas produziro o mesmo resultado em y, no entanto, no primeiro caso, somente a
varivel "y", alvo da atribuio, alterada. J no segundo caso, tanto "y", como "x" so
alteradas!
Relacionais
So utilizados em testes condicionais para determinar a relao existente entre os dados:
Operador
>
>=
<
<=
==
!=
Ao
Maior que
Maior ou igual a
Menor que
Menor ou igual a
Igual a
Diferente de
Ao
AND (E)
OR (OU)
NOT (NAO)
Ao
AND (E)
OR (OU)
XOR (OU exclusivo)
NOT (complemento de um)
Deslocamento a direita
Deslocamento a esquerda
Ao
Operador ternrio condicional
Separador de expresses
Separador de estruturas
Ponteiro de elemento de estrutura
Operador de Modelagem de dado
Retorna o tamanho da varivel
Tabela: Outros operadores
Exemplos:
int liga_led(void)
{
output_high (pin_a0); // ativao do pino 0 da porta A
}
int desliga_led(void)
{
output_low (pin_a0); // deslisa o pino 0 da porta A
}
main()
{
while (true)
(input (pin_b0) == 1) ? liga_led() : desliga led();
}
Associao de operadores
Para facilitar a vida do programador, a linguagem C inclui ainda outra caracterstica que
a abreviao de operadores em atribuies e funciona da seguinte forma:
Forma
reduzida
x += y
x -= y
x *= y
Ordem
Maior
Menor
Forma
expandida
x=x+y
x=x-y
x=x*y
Operador
( ) [ ] ->
! ~ ++ -- .
(tipo) * & sizeof
* / %
+ << >>
<<= >>=
== !=
&
^
|
&&
||
?
= += -= *= /=
,
Declaraes de controle
Comando if
De maneira geral, o comando if (ou "se" em portugus) e utilizado para executar um
comando ou bloco de comandos no caso de uma determinada condio ser avaliada
como verdadeira. Opcionalmente, e tambm possvel executar outro comando ou bloco
de comandos no caso da condio seja avaliada como falsa.
A forma geral do comando if :
if (condio)
comandoA;
{ else comandoB; }
Outra forma:
if (condio)
{
comandoA1;
comandoA2;
...
} else
{
comandoB1;
comandoB2;
...
}
Exemplo de cdigo:
#include <p16f877.h>
#use delay(clock=4000000)
#fuses INTRC, NOWDT, PUT, NOMCLR, NOLVP, NOBROWNOUT
int x;
main()
{
while (true)
{
x = input_a();
output_b (0);
if (x==0) output_high (pin_b0); else
if (x==1) output_high (pin_b1); else
if (x==2) output_high (pin_b2); else
if (x==4) output_high (pin_b3); else
output_high (pin_b4);
}
}
Comando Switch
Em alguns casos, como na comparao de uma determinada varivel a diversos valores
diferentes, o comando if pode tornar-se um pouco confuso ou pouco eficiente.
A declarao switch permite a realizao de comparaes sucessivas como a anterior,
de uma forma muito mais elegante, clara e eficiente. Vejamos ento o formato geral da
declarao switch:
switch (varivel)
{
case constante1:
comandoA;
...
break;
case constante2:
comandoB;
...
break;
...
...
default: // a diretiva default pode ou no estar presente
comandoZ;
...
}
Exemplo de cdigo:
#include <16f877.h>
#use delay(clock=4000000)
#fuses HS, NOWDT, PUT, NOBROWNOUT, NOLVP
main()
{
while (true)
{
output port_b(0);
switch (input_a())
{
case 0:
output_high (pin_b0);
break;
case 1:
output_high (pin_b1);
break;
case 2:
output_high (pin_b2);
break;
case 3:
output_high (pin_b3);
break;
default:
output_high (pin_b4);
}
}
}
Lao For
O lao for uma das mais comuns estruturas de repetio, sendo a verso c considerada
uma das mais poderosas e flexveis dentre todas as linguagens de programao.
O lao for dado por:
for (inicializao; condio; incremento) comando;
ou,
for (inicializao; condio; incremento)
{
//bloco de comandos
comando1;
comando2;
...
}
Cada uma das trs sees do comando for possui uma funo distinta, conforme se
segue:
Inicializao: esta seo conter uma expresso vlida utilizada malmente para
inicializao da varivel de controle do lao for
Condio: esta seo pode conter a condio a ser avaliada Para decidir pela
continuidade ou no do lao de repetio. Enquanto a condio for avaliada como
verdadeira, o lao for permanecera em execuo.
Incremento: esta seo pode conter uma ou mais declaraes para incremento da
varivel de controle do lao.
Exemplo de cdigo:
#include <16F628.h>
#fuses INTRC_IO, NOWDT, PUT, NOBROWNOUT, NOMCLR, NOLVP
#use delay(clock=4000000)
#use rs232(baud=19200,parity=N,xmit=PIN_B2,rcv=PIN_ B1,bits=8)
main()
{
int conta;
for (conta=0; conta<=10; conta++) printf (%u\r\n, conta);
}
Lao While
Outro tipo de lao disponvel na linguagem o comando while e que possui a seguinte
forma geral:
while (condio) comando;
ou ainda:
while (condio)
{
comandol;
comando2;
}
Break e Continue no Comando While
Tambm e possvel utilizar as clausulas break e continue com o comando while e for.
Elas possuem a mesma funo para os comandos while e for.
Vejamos um exemplo do funcionamento de break e continue com o comando while:
Exemplo de cdigo
#include <16F628.h>
#use delay(clock=4000000)
#fuses HS,NOWDT,PUT,NOBROWNOUT,NOMCLR,NOLVP
#use rs232(baud=19200,parity=N,xmit=PIN_B2,rcv=PIN_B1)
main()
{
port_b_pull-ups (true);
int x=0;
while (x<30)
// enquanto x for menor que 30
{
// se o pino RB3 for igual a 0 sai do 1ao
if (!input(pin_b3)) break;
x++;
if (!(x%2)) continue;
// se o resto da diviso de x por 2 for 0
// ento termina o ciclo atual
Printf (%u\n\r, x);
// imprime o valor da varivel x
}
}
Lao Do-While
O ltimo tipo de estrutura de repetio disponvel na linguagem C o comando do (em
portugus "faca").
O comando do e utilizado juntamente com o comando while para criar uma estrutura de
repetio com funcionamento ligeiramente diferente do while e for tradicionais.
De fato, a diferena entre a estrutura while tradicional e a estrutura do-while que esta
ultima realiza a avaliao da condio de teste no final de cada ciclo de iterao do lao
de repetio, ao contrario do que j estudamos sobre o while, o qual realiza o teste no
inicio de cada ciclo.
A forma geral da estrutura Do-While :
do comando while (condio);
ou,
do
{
comandoA;
comandoB;
...
} while (condio);
Constantes binrias, hexadecimais e octais
Valor
Base numrica
99
Decimal
099
Octal
0x99
Hexadecimal
0b10011001
Binrio
Formatos aceitos de nmeros pelo compilador PICC-CCS
Funo Printf
A funo prinff e utilizada para possibilitar a sada de dados na linguagem C. A sada de
dados e direcionada para o dispositivo padro de sada, que nos computadores
normalmente o monitor de vdeo. No caso dos PICs, o dispositivo de sada
eventualmente disponvel a sada serial.
Assim, a funo printf uma excelente forma de transmitir dados serialmente do PIC
para outro dispositivo externo, como, por exemplo, um terminal de vdeo ou um
microcomputador.
O formato geral da funo printf e:
printf ( argumento(s) );
Caractere
Constante Octal yyy
Constante hexadecimal yyy
Nulo (null)
Campainha (BEL)
Retrocesso (backspace)
Tabulao horizontal
Linha nova (line feed)
Tabulao vertical
Avano de formulrio
Retorno de carro (Return)
Aspas
Apstrofo
Barra invertida \
Configurao do PIC
No incio da programao do PIC devemos configurar o PIC para comear a programar
as tarefas do PIC, essas configuraes dependem de PIC para PIC e as principais se
seguem.
Diretivas Fuses de configurao
Fuses so diretivas para configurao inicial de diversos parmetros de um PIC, essas
configuraes variam de PIC para PIC e devem ser consultadas no Datasheet de cada
PIC para correta configurao, tambm temos a descrio da configurao dos Fuses na
referncia de linguagem do compilador PICC em ingls.
LP
XT
HS
RC
NOWDT
WDT
NOPUT
PUT
PROTECT
PROTECT_5%
PROTECT_50%
NOPROTECT
NOBROWNOUT
BROWNOUT
LVP
NOLVP
CPD
NOCPD
WRT
NOWRT
DEBUG
NODEBUG
LP
XT
HS
EC_IO
INTRC_IO
RC
INTRC
RC_IO
WDT
NOWDT
PUT
NOPUT
NOMCLR
MCLR
BROWNOUT
NOBROWNOUT
LVP
NOLVP
CPD
NOCPD
PROTECT
NOPROTECT
Diretivas #use
#use delay
Informa ao compilador a velocidade do clock do sistema.
Sintaxe: #use delay (clock = valor)
Esta diretiva necessria para a utilizao das funes de atraso de tempo (delay_ms ou
delay_us) e tambm para as rotinas de comunicao serial.
#use satandard_io
Seleciona o modo padro de entrada e sada.
Sintaxe: #use standard_io (porta)
Onde: porta pode ser uma porta de sada, exemplo:
#use standard_io (B)
#use fast_io
Seleciona o modo rpido de entrada e sada.
Neste modo o compilador no ir inserir nenhuma instruo para controle dos
registradores TRIS do dispositivo, produzindo um cdigo mais rpido e eficiente,
porm, devemos alterar o registrador TRIS pelo comando set_tris (x) no incio do
programa.
Exemplo: #use fast_io (B)
#use fixed_io
Seleciona o modo fixo de entrada e sada.
Sintaxe: #use fixed_io (porta_outputs = pino, pino, ...)
No modo fixo o compilador ir inserir cdigo de configurao dos registradores TRIS a
cada utilizao dos pinos especificados. Note que o registrador TRIS programado com
a configurao selecionada na diretiva e no pelo tipo de funo executado.
Exemplo: #use fixed_io (B = pin_b0, pin_b1)
#use i2c
Habilita o uso da biblioteca interna de comunicao I2C.
Sintaxe: #use i2c (opes)
Exemplo:
#use i2c(Master,Slow,sda=PIN_C4,scl=PIN_C3)
Opo
MASTER
SLAVE
SCL = pino
SDA = pino
ADDRESS = nn
FAST
SLOW
RESTART_WDT
FORCE_HW
Descrio
Seta o modo mestre
Seta o modo escravo
Especifica qual o pino de clock I2C
Especifica qual o pino de dados I2C
Especifica o endereo do dispositivo em modo escravo
Utiliza a especificao de alta velocidade I2C
Utiliza a especificao de baixa velocidade I2C
Reinicia o watchdog enquanto aguarda dados na funo
I2C_READ
Fora a utilizao do hardware interno (SSP ou MSSP) do PIC
#use rs232
Ativa o suporte a comunicao RS232
Sintaxe: #use rs232 (opes)
Opes
BAUD = valor
XMIT = pino
RCV = pino
RESTART_WDT
INVERT
PARITY = x
BITS = x
FLOAT_HIGH
ERRORS
BRGH10K
ENABLE = pino
STREAM = identificador
Descrio
Especifica a velocidade de comunicao serial.
Especifica o pino de transmisso de dados.
Especifica o pino de recepo de dados.
Determina qual a funo getc() reset o watchdog enquanto
aguarda a chegada de um caractere.
Inverte a polaridade dos pinos de TX/RX. No pode ser
utilizada com o hardware interno.
Seleciona a paridade (x pode ser: N (sem paridade), E
(paridade par) ou O (paridade mpar)).
Seleciona o nmero de bits de dados (5 a 9 para o modo
por software e, 8 e 9 para o modo hardware).
A sada no vai a nvel lgico 1. Utilizado com sadas em
coletor aberto.
Solicita ao compilador que armazene os erros de recepo
na varivel RS232_ERRORS, resetando os flags de erro
quando eles ocorrerem.
Permite a utilizao das velocidades disponveis com o bit
BRGH em 1 em chips
que tenham bugs nesta
configurao do hardware.
Especifica um pino para atuar como sada de habilitao
durante uma transmisso. Utilizado no protocolo RS485.
Associa a interface RS232 a um identificador de stream de
dados. Os streams de dados so utilizados em algumas
funes internas do compilador.
output_A (valor)
output_B (valor)
output_C (valor)
output_D (valor)
Exemplo:
Output_B (0x25); // Escreve o valor 0x25 no port B
Output_toggle()
Inverte o valor do pino especificado.
Sintaxe: output_toggle (pino)
Exemplo:
Output_toggle (pin_b4); // Inverte o nvel lgico do pino pin_b4
Input()
L o estado lgico de um pino do PIC.
Sintaxe: res = input(pino)
valor = input_A ()
valor = input_B ()
valor = input_C ()
valor = input_D ()
set_tris_A ( valor )
set_tris_B ( valor )
set_tris_C ( valor )
set_tris_D ( valor )
Exemplos de cdigos
/* RS232.h
* Arquivo de Comunicao Serial RS232
*/
#include <16F877A.h>
#device adc=8
#FUSES NOWDT
//No Watch Dog Timer
#FUSES XT
//Crystal osc <= 4mhz for PCM/PCH , 3mhz to 10 mhz for PCD
#FUSES NOPUT
//No Power Up Timer
#FUSES NOPROTECT
//Code not protected from reading
#FUSES NODEBUG
//No Debug mode for ICD
#FUSES NOBROWNOUT //No brownout reset
#FUSES NOLVP
//No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD
//No EE protection
#FUSES NOWRT
//Program memory not write protected
#use delay(clock=4000000)
#use rs232(baud=19200,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)
// Fim do arquivo RS232.h
{
case 'a':
printf ("Letra A\n\r");
break;
case 'b':
printf ("Letra B\n\r");
break;
default:
printf ("comando nao existe...\n\r");
break;
}
}
}
// Fim do arquivo
/* Display 7 segmentos
* Arquivo 7seg.h
*/
#include <16F877A.h>
#device adc=8 // Configurao do ADC
#FUSES NOWDT
//No Watch Dog Timer
#FUSES XT
//Crystal osc <= 4mhz for PCM/PCH , 3mhz to 10 mhz for PCD
#FUSES NOPUT
//No Power Up Timer
#FUSES NOPROTECT //Code not protected from reading
#FUSES NODEBUG
//No Debug mode for ICD
#FUSES NOBROWNOUT //No brownout reset
#FUSES NOLVP
//No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD
//No EE protection
#FUSES NOWRT
//Program memory not write protected
// Configura Clock
#use delay(clock=4000000)
// Configura RS232
#use rs232(baud=19200,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=5)
// Fim do arquivo 7seg.h
/* Arquivo 7seg.c
* Display de 7 segmentos */
#include "7seg.h"
byte const digito[] = { 0b10111111, // 0 Define cada segmento
0b10000110, // 1 dos valores mostrados
0b11011011, // 2 no display de LEDs
0b11001111, // 3
0b11100110, // 4
0b11101101, // 5
0b11111101, // 6
0b10000111, // 7
0b11111111, // 8
0b11100111};// 9
void main() // Funo principal
{
setup_adc_ports(NO_ANALOGS); // Configura analgicos
setup_adc(ADC_OFF); // ADC desligado
setup_psp(PSP_DISABLED); // PSP desligado
setup_spi(SPI_SS_DISABLED); // SPI delsigado
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1); // Configura Timer 0
setup_timer_1(T1_DISABLED);// Configura Timer 1
setup_timer_2(T2_DISABLED,0,1);// Configura Timer 2
while (true)
{
output_b(0);
switch (input_a()) // Testa a porta A
{
case 0:
output_b (digito[0]);
//printf ("%u\n\r", digito[0]);
break;
case 1:
output_b (digito[1]);
printf ("%u\n\r", digito[1]);
break;
case 2:
output_b (digito[2]);
printf ("%u\n\r", digito[2]);
break;
case 3:
output_b (digito[3]);
printf ("%u\n\r", digito[3]);
break;
case 4:
output_b (digito[4]);
printf ("%u\n\r", digito[4]);
break;
case 5:
output_b (digito[5]);
printf ("%u\n\r", digito[5]);
break;
case 6:
output_b (digito[6]);
printf ("%u\n\r", digito[6]);
break;
case 7:
output_b (digito[7]);
printf ("%u\n\r", digito[7]);
break;
case 8:
output_b (digito[8]);
printf ("%u\n\r", digito[8]);
break;
case 9:
output_b (digito[9]);
printf ("%u\n\r", digito[9]);
break;
case 10:
output_b (digito[0]);
printf ("%u\n\r", digito[0]);
break;
}
}
}
// Fim do arquivo 7seg.c
/* Arquivo mainT0.h
* Trabalhando com Timer 0 e interrupo */
#include <16F877A.h>
#device adc=8
#FUSES NOWDT //No Watch Dog Timer
#FUSES HS
//High speed Osc (> 4mhz for PCM/PCH) (>10mhz for PCD)
#FUSES NOPUT //No Power Up Timer
#FUSES NOPROTECT //Code not protected from reading
#FUSES NODEBUG //No Debug mode for ICD
#FUSES NOBROWNOUT//No brownout reset
#FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD //No EE protection
#FUSES NOWRT //Program memory not write protected
#use delay(clock=20000000)
// Fim do arquivo mainT0.h
/* Arquivo mainT0.c
* Trabalhando com Timer0 e interrupo para pisca de 1 segundo */
#include "mainT0.h"
#define led pin_b0
#int_TIMER0 // Tratamento de interrupo
void TIMER0_isr(void)
{
static int conta;
// reinicia o timer 0 em 131 mais a contagem que j passou
set_timer0(131 + get_timer0());
conta++;
if (conta == 125) // se j ocorreram 125 interrupes
{
conta = 0;
output_toggle (led); // inverte o estado do led
}
}
void main()
{
setup_adc_ports(NO_ANALOGS);
setup_adc(ADC_OFF);
setup_psp(PSP_DISABLED);
setup_spi(SPI_SS_DISABLED);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_64);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);
setup_comparator(NC_NC_NC_NC);
setup_vref(FALSE);
// habilita interrupes
enable_interrupts(INT_TIMER0);
enable_interrupts(GLOBAL);
set_timer0(131);
while (true);
}
// Fim do arquivo mainT0.c
// Arquivo ADC.h
#include <16F877A.h>
#device adc=10 // ADC em 10bits
#FUSES NOWDT //No Watch Dog Timer
#FUSES HS
//High speed Osc (> 4mhz for PCM/PCH) (>10mhz for PCD)
#FUSES NOPUT //No Power Up Timer
#FUSES NOPROTECT //Code not protected from reading
#FUSES NODEBUG //No Debug mode for ICD
#FUSES NOBROWNOUT//No brownout reset
#FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD //No EE protection
#FUSES NOWRT //Program memory not write protected
#use delay(clock=20000000)
#use rs232(baud=19200,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=5)
// Fim do arquivo ADC.h
// Arquivo ADC.C
// Converso Analgico Digital
#include "adc.h"
#include "mod_lcd.c" // Biblioteca do LCD deve estar junto do arquivo principal
void main()
{
long int valor; // variavel de 16 bits
int32 val32;
// variavel de 32 bits
setup_adc_ports(AN0_AN1_AN3); // Configura ADC para 3 canais
setup_adc(ADC_CLOCK_INTERNAL);// ADC clock interno
setup_psp(PSP_DISABLED);
setup_spi(SPI_SS_DISABLED);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);
setup_comparator(NC_NC_NC_NC);
setup_vref(FALSE);
lcd_ini();
// inicializa o LCD
set_adc_channel(0); // seleciona o canal 0 do ADC
while (true)
{
lcd_escreve ('\f'); // apaga o display
// O escalonamento realizado da seguinte forma:
// resultado = (5000 * valor lido) / 1023
// Para facilitar os clculos, somamos um ao
// valor lido:
// resultado = (5000 * (valor + 1)) / 1024
// simplificando:
// resultado = ((valor + 1) * 4) + ((valor + 1) * 113) / 128
// Repare que necessrio converter a segunda parte da
// equao para 32 bits para que o compilador efetue o
// clculo corretamente
valor = read_adc(); // efetua a converso A/D
// Se o valor > 0, soma 1 ao valor lido
if (valor) valor += 1;
val32 = valor * 4 + ((int32)valor * 113) / 128;
// imprime o valor da tenso no display
// 5000 = 5,000 Volts ou 5000 milivolts
printf (lcd_escreve,"Tensao = %lu mV", val32);
// se a tecla enter for pressionada
if (kbhit()) if (getc() == 13)
{
// imprime os resultados na serial
printf ("Tensao = %lu miliVolts\r\n",val32);
printf ("Valor = %lu\r\n",valor);
}
delay_ms (250); // aguarda 250 ms
}
}
// Fim do arquivo ADC.c
// Arquivo LCD.h
// Tratamento de LCD alfanumrico
#include <16F877A.h>
#device adc=8
#FUSES NOWDT //No Watch Dog Timer
#FUSES HS
//High speed Osc (> 4mhz for PCM/PCH) (>10mhz for PCD)
#FUSES NOPUT //No Power Up Timer
#FUSES NOPROTECT //Code not protected from reading
#FUSES NODEBUG //No Debug mode for ICD
#FUSES NOBROWNOUT//No brownout reset
#FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD //No EE protection
#FUSES NOWRT //Program memory not write protected
#use delay(clock=20000000)
#use rs232(baud=19200,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=5)
//Fim do arquivo LCD.h
// Arquivo LCD.c
// Tratamento de LCD
// arquivo mod_lcd.c deve estar no mesmo diretrio do arquivo principal
#include "LCD.h"
#include "mod_lcd.c"
void main()
{
setup_adc_ports(NO_ANALOGS);
setup_adc(ADC_OFF);
setup_psp(PSP_DISABLED);
setup_spi(SPI_SS_DISABLED);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);
setup_comparator(NC_NC_NC_NC);
setup_vref(FALSE);
lcd_ini(); // Inicializa o LCD
lcd_escreve ('\f'); // limpa o display
// Funo lcd_escreve
//lcd_escreve ("Curso de PIC");
// Imprime menssagem no LCD
printf (lcd_escreve, "Curso de PIC");
int conta = 0; // Variavel de contagem
while (true)
{
lcd_pos_xy (1, 2); // Pasiciona cursor no LCD
printf (lcd_escreve, "Conta: %3u.", conta);
if (conta != 100)
conta++;
else
conta = 0;
delay_ms (100);
}
}
/* Funes importantes da biblioteca mod_lcd
lcd_ini()
// inicializa LCD
lcd_pos_xy( byte x, byte y)
// posio de texto x, y
lcd_escreve( char c)
// funo de escrita no LCD
*/
// Fim do arquivo LCD.c
Assistente de
novos projetos
Inicialmente o assistente pede para salvarmos o projeto. Dica: como o compilador gera
muitos arquivos interessante que guardemos cada projeto novo em uma pasta
separada, assim certificamos que cada arquivo (.hex) seja facilmente encontrado para
gravao.
Pasta
destino
Nome do
Projeto
Boto Salvar
Guias de
configurao
Nome do Projeto
Selecione o PIC
Frequncia de
funcionamento
do PIC
Configurao
dos Fuses
Programa exemplo
Assistente de
Projeto
Bem-vindo!
Qual PIC?
Selecione o
PIC
Compilador
Nome do Projeto
Foi
encontrado?
Salvar na
pasta?
Buscar
compilador
Detalhes do
novo projeto
Se j existir um arquivo
adicione ao projeto, seno,
devemos criar um novo.
Boto compilar
Barra de ferramentas do
gravador
Caixa de comunicao do
gravador mostrando que est
pronto para prxima operao!
Arquivo fonte, no caso
em linguagem C
Para inserir os
componentes
Selecione o
componente, clicando
duas vezes com o
boto esquerdo.
Insira os componentes e
faa as ligaes, o
hardware depende do
software!
Arquivo
fonte do PIC
Frequncia
do PIC
Configurao do
Terminal Serial Virtual
Altere os
elementos como
se fosse real
Bibliografia e referncias: