Apostila_de_Programação_de_PICs_em_C_e_Proteus

Prévia do material em texto

Introdução à programação de microcontroladores – www.pictronics.com.br 
 
 
 
 
 
 
 
 
 
 
 
 
 
Nelson Camilo de Almeida 
Jan/2011 
PIC 
Introdução à programação 
de microcontroladores – 
www.pictronics.com.br 
 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
 
 
Conteúdo 
 
1- Introdução PIC geral 
2 - Introdução a programação 
3 - Acender e apagar Led (delay_chaves) e Display 7 seguimentos 
4 - Display LCD 
5 - RS232 
6 – Conversor AD 
7 - Interrupção 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 
Introdução: 
Diferença entre Microprocessador e Microcontrolador 
Os microcontroladores, surgidos em torno de dez anos após o surgimento dos primeiros 
microprocessadores, foram uma adaptação da indústria de eletrônica 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 milhões de transistores (Pentium II). 
Estes transistores internos constituem os mais diversos circuitos lógicos: como 
contadores, registradores, decodificadores, e centenas de outros. Estes circuitos lógicos 
são dispostos de maneira complexa, dando ao microprocessador a capacidade de 
executar operações lógicas, aritméticas, e de controle. Porém, apesar da sua grande 
capacidade de processamento, os microprocessadores são desprovidos de dispositivos 
essenciais para o funcionamento de um sistema. 
Por exemplo, para se fazer uma simples circuito de controle de um elevador seriam 
necessários um microprocessador, memória ROM para o programa, memoria RAM para 
os dados, de uma porta paralela para dar saída aos acionamentos, de uma outra porta pra 
receber os sinais digitais dos sensores, de uma porta serial para fazermos as 
configurações e rodarmos os diagnósticos, 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. 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
 
 
Figura 1: Diagrama em blocos do circuito para o elevador. 
Para a realização desse circuito, precisaríamos de uma placa controladora de tamanho 
razoável e com muitos CI´s. Desta forma o circuito seria caro e perderia confiabilidade 
devido à grande quantidade de componentes, o que seria fatal para qualquer indústria 
que deseja ser competitiva. Além disso, haveria um processamento demasiadamente 
sofisticado para o problema proposto. 
Desse problema é que surgiram os Microcontroladores, que englobam em um único 
circuito integrado grande parte dos periféricos listados no exemplo acima. Em um 
microcontrolador, as memórias RAM e ROM, conversor AD, temporizadores, 
controladores serial e paralelo e a CPU em sí são todas integrados em um bloco. Por 
serem compostos apenas de uma peça, eles tem muito maior confiabilidade, são mais 
baratos, consomem menos energia, têm a fase de projeto reduzida, além de terem a 
manutenção facilitada. Ou seja, são muitas as vantagens em relação ao uso de um 
microprocessador com circuito. 
Afora isso, como não será feito processamento sofisticado, sua CPU não precisa ter uma 
grande capacidade de processamento, mas deve oferecer um conjunto de instruções 
simples, que gere programas pequenos e de rápida execução, ou seja, as instruções 
devem ser pequenas e velozes. É preciso ainda oferecer uma forma simples de se 
interfacear com outros periféricos que venham a ser adicionados. 
Levando em conta tudo que foi dito, chegamos ao diagrama em blocos da figura 2, onde 
se apresenta a típica arquitetura de um microcontrolador. É claro que, de acordo com a 
finalidade do microcontrolador, é possível integrar mais recursos e tal possibilidade foi 
representada pelos blocos rotulados com "etc". 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
 
Figura 2: Exemplo de arquitetura de um Microcontrolador. 
 
RISC e CISC 
Na sua essência, uma máquina RISC oferece um número muito reduzido de instruções, 
desde uma a poucas dezenas, e cada instrução apenas realiza uma ação muito simples. 
Se este conjunto satisfizer o critério de ser genérico, isto é, permitir programar qualquer 
algoritmo, então temos de reconhecer a grande vantagem desta abordagem: a sua 
simplicidade facilita a construção 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 (Silício, 
habitualmente) sobre o qual são implantados os circuitos digitais que realizam os 
componentes do controlador. Ficando a Unidade de Controle menor, mais espaço livre 
fica na CPU, que pode ser aproveitado para outras unidades que aumentem o ritmo de 
execuções do CPU, por exemplo, um maior número de registadores de dados, uma 
memória interna ao CPU, etc. 
Uma máquina CISC segue uma filosofia oposta, procurando suportar o mais 
diretamente possível os mecanismos das instruções da linguagem de alto nível. A sua 
principal desvantagem é que a Unidade de Controle fica mais complexa, dada a 
variedade e complexidade das instruções. Para além do mencionado aspecto de 
aumentar o espaço ocupado pelos circuitos, isto também dificulta as otimizações das 
micro-ações que a Unidade de Controle deve realizar, para obter execuções mais rápidas 
das instruções. Por exemplo, no modelo CISC, dada a grande variedade de instruções, 
estas têm formatos variáveis e as suas representações em bits variam, por exemplo, 
desde 1 até 6 bytes, equivalente aos seus tipos. 
 
Observações importantes: 
 
A letra F (PIC16F877) identifica que o microcontrolador em questão 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 são mais baratos. 
 
Outros modelos da família 16 (como o PIC16F870, PIC16F628, PIC16F84, ....) 
possuem variações em termos de recursos (com mais ou com menos pinos de I/Os, 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
entradas analógicas, memória ROM, memória RAM, etc...), mas todos podem ser 
programados com a mesma linguagem. 
 
Modelos da família 18 são mais rápidos e um pouco mais caros, continuando a ser de 8 
bits. 
 
Modelos da família 24 são de 16 bits, e indicados para aplicações que exijam mais 
poder de processamento. 
 
Os microcontroladores PIC são indicados para aplicações mais simples, que não 
necessitem de grande volume de dados manipulados, e que não necessitem 
processamento em tempo real de alto desempenho. 
 
Quando transferimos um programa para o microcontrolador, este deve estar em 
linguagem de máquina (ARQUIVO HEX), e será armazenado na memória ROM do 
microcontrolador. Esta memória não será apagada até que outro programa seja enviado, 
mesmo que a alimentação de energia elétrica seja desativada. 
 
 
Requisitos de Hardware 
 
 
 
 
 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
Opcionais: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Introdução à programação 
 
Fluxograma: 
 
Os fluxogramas são ferramentas que auxiliam na programação e na codificação de 
programas. Na realidade são elementos gráficos utilizados para estabelecer a sequencia 
de operações necessárias para o cumprimento de determinada tarefa e, 
consequentemente, a resoluçãode um problema. 
 
Variáveis de dados 
 
Variável é uma representação simbólica para elementos pertencentes a um determinado 
conjunto. As variáveis são armazenadas na memória do microcontrolador e podem 
assumir qualquer valor dentro do conjunto de valores possíveis. 
De fato, as variáveis ficam localizadas na memória do equipamento, não em qualquer 
tipo de memória, mas na chamada memória RAM. Isto significa que num 
microcontrolador, boa parte da memória é ocupada por variáveis, definidas pelo 
programa em execução. 
As variáveis são classificadas segundo o tipo de dado que será armazenado e podem ser: 
numéricas, caractere, alfanuméricas e lógicas. 
 
Variáveis e tipos de dados 
 
A linguagem C disponibiliza ao programador uma gama de tipos de dados. A 
implementação C da CCS possibilita o uso de quase todos os tipos de dados disponíveis 
em C padrão ANSI. 
 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
Veja os tipos de dados básicos disponíveis: 
 
Tipo Tamanho em bits Intervalo Descrição 
char 8 0 a 255 Caractere 
int 8 0 a 255 Inteiro 
float 32 3.4E-38 a 3.4E+38 Ponto flutuante 
void 0 nenhum valor vazio 
 
Modificadores de tipo 
 
Além dos tipos de dados vistos, podemos utilizar comandos especiais da linguagem C 
para modificar os tipos básicos, de forma a obter outros tipos de dados. 
Esses comandos especiais são chamados de modificadores de tipo e são 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 números positivos quanto negativos. 
Note que devido ao fato de utilizar um bit para representação do sinal, a magnitude 
absoluta da representação do tipo modificado será metade da magnitude do tipo não 
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 padrão do 
compilador da CCS. Note que o padrão ANSI especifica que os tipos padrão de dados 
da linguagem C é signed. 
Já o modificador short é utilizado para definir uma variável de tamanho menor que o do 
tipo modificado, ou seja, uma versão reduzida do tipo especificado. Assim, se 
especificarmos uma variável como sendo do tipo short int, ela será uma versão 
reduzida de int , o que no caso do compilador CCS cria uma variável de apenas 1 bit de 
tamanho (o que é chamado de flag ou sinalizador). 
Finalmente, temos o modificador long, utilizado para ampliar a magnitude da 
representação do tipo especificado. Desta forma, um tipo de dado long int terá um 
tamanho de 16 bits, ou seja, irá ocupar duas posições de memória RAM do PIC e terá 
magnitude de 0 a 65535. 
 
Outros tipos de dados específicos do compilador CCS C 
• int1: especifica valores de 1 bit (equivalente ao short int padrão); 
• 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 disponíveis por padrão no 
compilador CCS: 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
 
 
Operadores 
 
A linguagem C possui uma gama de operadores, sendo possivelmente uma das 
linguagens com maior numero de operadores disponível atualmente. 
Esta característica e um dos pontos positivos da linguagem, já que C agrega aos 
operadores comumente encontrados nas linguagens de alto nível, os operadores 
encontrados frequentemente em linguagens de baixo nível como o Assembly. 
 
Podemos classificar os operadores da linguagem C em sete categorias principais: 
atribuição, aritméticos, relacionais, lógicos, lógicos bit a bit, de memoria e outros. 
 
Atribuição 
 
A primeira categoria de operadores e também a mais utilizada. Em C, o operador de 
atribuição "=" e utilizado para atribuir um determinado valor a uma variável. Um 
exemplo de atribuição: 
 
x = 10; 
y = x; 
 
Podemos verificar no programa anterior duas operações de atribuição: na primeira foi 
atribuído o valor 10 a variável "x", na segunda, foi atribuído o valor de "x" (que e 10) a 
variável "y". Conclui-se então que ao final do programa, "y" será igual a 10. 
 
Repare que a atribuição e sempre avaliada da direita para a esquerda é não e possível 
realizar uma atribuição no sentido inverso. 
 
 
 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
Aritméticos 
 
São utilizados para determinar ao compilador que efetue determinada operação 
matemática em relação a um ou mais dados: 
 
Operador Ação 
+ Adição 
- Subtração 
* Multiplicação 
/ Divisão 
% Resto de divisão inteira 
++ Incremento 
-- Decremento 
 
Tabela de operadores 
 
Os operadores de adição, subtração, multiplicação e divisão dispensam comentários. 
 
O operador % e utilizado para retornar o resto de uma operação de divisão inteira. 
Vejamos um exemplo: 
 
5 / 2 = 2,5 em uma divisão real, ou 5 / 2 = 2, em uma divisão 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 são utilizados para somar 1 (incremento) ou 
subtrair 1 (decremento) de uma variável. 
 
A forma geral para utilização destes dois últimos operadores é: 
 
variavel++; ou variavel--; 
 
Ou ainda por meio de uma atribuição: 
 
variavel_1 = variavel_2 ++; ou variavel_1 = variavel_2 --; 
 
Observe que em ambos os casos, a atribuição ocorre da seguinte forma: o valor da 
variável "variavel_2" e armazenado em variável_1 e apos isso o conteúdo de 
"variave_2" é incrementado ou decrementado. 
 
No entanto, em C e também possível escrever: 
 
variavel_1 = ++ variavel_2; ou variavel_1 = -- variavel_2; 
 
Nestes casos, a operação de Incremento/decremento é realizada antes da atribuição 
propriamente dita. 
 
 
 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
Vejamos um exemplo: 
 
int x, y, z; 
x = 0; 
y = x ++; 
z = ++ x; 
 
Neste caso, após a execução dos três comandos, o valor da variável “x” será igual a 2, o 
valor da variável “y” será igual a 0 e o valor da variável z será igual a 2. 
 
Observação importante: Não e possível utilizar os operadores de incremento ou 
decremento com variáveis ou tipos de dados complexos, tais como os tipos ponto 
flutuante. 
 
Note que ha uma diferença clara entre escrever "y = x + 1" e "y = ++x": 
 
Ambas produzirão o mesmo resultado em “y”, no entanto, no primeiro caso, somente a 
variável "y", alvo da atribuição, é alterada. Já no segundo caso, tanto "y", como "x" são 
alteradas! 
 
Relacionais 
 
São utilizados em testes condicionais para determinar a relação existente entre os dados: 
 
Operador Ação 
> Maior que 
>= Maior ou igual a 
< Menor que 
<= Menor ou igual a 
== Igual a 
!= Diferente de 
 
Tabela de operadores relacionais 
 
Não ha muito que falar sobre estes operadores, já que o seu funcionamento e idêntico ao 
que todos estudamos na disciplina de matemática e que utilizamos no nosso dia-a-dia. 
 
Lógicos Booleanos 
 
Os operadores lógicos ou booleanos são utilizados para realizar conjunções, disjunções 
ou negações entre elementos em um teste condicional. Os operadores 1ogicos somente 
podem resultar em um dos valores: verdadeiro ou falso. 
 
Operador Ação 
&& AND (E) 
|| OR (OU) 
! NOT (NAO) 
 
Tabela de operadores lógicos 
 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
Os operadores relacionais são elementos de suma importância na construção de testes 
condicionais. Com esses operadores podemos relacionar diversas condições diferentes 
em um mesmo teste logico. 
 
Vejamos um exemplo: 
 
int x, y; 
x = 10; 
if (x > 5 && x < 20) y = x; 
 
Como podemos verificar a variável "y" somente será igual ao valor da variável "x" se o 
valor de "x" for maior que 5 e "x" for menor que 20. O que nos leva a concluir que ao 
final da execuçãodo programa "y" será igual a 10. 
 
Lógicos Bit a Bit 
 
Os operadores 1ogicos bit a bit são utilizados para realizar operações logicas entre 
elementos ou variáveis. No entanto, ao contrario dos operadores lógicos simples, os 
operadores lógicos bit a bit podem resultar em um valor da mesma magnitude dos 
elementos operados. 
 
Operador Ação 
& AND (E) 
| OR (OU) 
^ XOR (OU exclusivo) 
~ NOT (complemento de um) 
>> Deslocamento a direita 
<< Deslocamento a esquerda 
 
Tabela: Operadores lógicos bit-a-bit 
 
Outros Operadores 
 
Além dos operadores anteriormente citados, podemos encontrar ainda outros operadores 
não tão conhecidos em C: 
 
Operador Ação 
? Operador ternário condicional 
, Separador de expressões 
. Separador de estruturas 
-> Ponteiro de elemento de estrutura 
(tipo) Operador de Modelagem de dado 
sizeof Retorna o tamanho da variável 
 
Tabela: Outros operadores 
 
 
 
 
 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
Exemplos: 
 
int liga_led(void) 
{ 
output_high (pin_a0); // ativação 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(); 
} 
 
 
Associação de operadores 
 
Para facilitar a vida do programador, a linguagem C inclui ainda outra característica que 
é a abreviação de operadores em atribuições e funciona da seguinte forma: 
 
Forma 
reduzida 
Forma 
expandida 
x += y x = x + y 
x -= y x = x - y 
x *= y x = x * y 
 
 
Ordem Operador 
Maior ( ) [ ] -> 
 ! ~ ++ -- . 
(tipo) * & sizeof 
 * / % 
 + - 
 << >> 
 <<= >>= 
 == != 
 & 
 ^ 
 | 
 && 
 || 
 ? 
 = += -= *= /= 
Menor , 
 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
Declarações de controle 
 
Comando if 
 
De maneira geral, o comando if (ou "se" em português) e utilizado para executar um 
comando ou bloco de comandos no caso de uma determinada condição ser avaliada 
como verdadeira. Opcionalmente, e também possível executar outro comando ou bloco 
de comandos no caso da condição seja avaliada como falsa. 
 
A forma geral do comando if é: 
 
if (condição) 
comandoA; 
{ else comandoB; } 
 
Outra forma: 
 
if (condição) 
{ 
comandoA1; 
comandoA2; 
. . . 
} else 
{ 
comandoB1; 
comandoB2; 
. . . 
} 
 
Exemplo de código: 
 
#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); 
 } 
} 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
Comando Switch 
 
Em alguns casos, como na comparação de uma determinada variável a diversos valores 
diferentes, o comando if pode tornar-se um pouco confuso ou pouco eficiente. 
 
A declaração switch permite a realização de comparações sucessivas como a anterior, 
de uma forma muito mais elegante, clara e eficiente. Vejamos então o formato geral da 
declaração switch: 
 
switch (variável) 
{ 
case constante1: 
comandoA; 
 ... 
break; 
case constante2: 
comandoB; 
... 
break; 
 ... 
 ... 
default: // a diretiva default pode ou não estar presente 
comandoZ; 
... 
} 
 
Exemplo de código: 
 
#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); 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
break; 
 default: 
 output_high (pin_b4); 
 } 
 } 
} 
 
Laço For 
 
O laço for é uma das mais comuns estruturas de repetição, sendo a versão c considerada 
uma das mais poderosas e flexíveis dentre todas as linguagens de programação. 
O laço for é dado por: 
 
 for (inicialização; condição; incremento) comando; 
 
 ou, 
 
 for (inicialização; condição; incremento) 
{ 
 //bloco de comandos 
 comando1; 
 comando2; 
 ... 
 } 
 
Cada uma das três seções do comando for possui uma função distinta, conforme se 
segue: 
 
Inicialização: esta seção conterá uma expressão válida utilizada malmente para 
inicialização da variável de controle do laço for 
 
Condição: esta seção pode conter a condição a ser avaliada Para decidir pela 
continuidade ou não do laço de repetição. Enquanto a condição for avaliada como 
verdadeira, o laço for permanecera em execução. 
 
Incremento: esta seção pode conter uma ou mais declarações para incremento da 
variável de controle do laço. 
 
Exemplo de código: 
 
#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); 
} 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
 
Laço While 
 
Outro tipo de laço disponível na linguagem é o comando while e que possui a seguinte 
forma geral: 
 
while (condição) comando; 
 
ou ainda: 
 
while (condição) 
{ 
comandol; 
comando2; 
 … 
} 
 
Break e Continue no Comando While 
 
Também e possível utilizar as clausulas break e continue com o comando while e for. 
Elas possuem a mesma função para os comandos while e for. 
 
Vejamos um exemplo do funcionamento de break e continue com o comando while: 
 
Exemplo de código 
 
#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); // habilita pull-ups internos 
int x=0; // declara a variável x como inteira de 8 bits 
//e a inicializa com 0 
 
while (x<30) // enquanto x for menor que 30 
{ 
// se o pino RB3 for igual a 0 sai do 1aço 
if (!input(pin_b3)) break; 
x++; 
if (!(x%2)) continue; // se o resto da divisão de x por 2 for 0 
 // então termina o ciclo atual 
Printf (“%u\n\r”, x); // imprime o valor da variável x 
 } 
} 
 
 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
Laço Do-While 
 
O último tipo de estrutura de repetição disponível na linguagem C é o comando do (em 
português "faca"). 
 
O comando do e utilizado juntamente com o comando while para criar uma estrutura de 
repetição com funcionamento ligeiramente diferente do while e for tradicionais. 
 
De fato, a diferença entre a estrutura while tradicional e a estrutura do-while é que esta 
ultima realiza a avaliação da condição de teste no final de cada ciclo de iteração do laço 
de repetição, 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 (condição); 
 
ou, 
 
do 
{ 
comandoA; 
comandoB; 
... 
} while (condição); 
 
Constantes binárias, hexadecimais e octais 
 
Valor Base numérica 
99 Decimal 
099 Octal 
0x99 Hexadecimal 
0b10011001 Binário 
Formatos aceitos de números pelo compilador PICC-CCS 
 
Função Printf 
 
A função prinff e utilizada para possibilitar a saída de dados na linguagem C. A saída de 
dados e direcionada para o dispositivo padrão de saída, que nos computadores é 
normalmente o monitor de vídeo. No caso dos PICs, o dispositivo de saída 
eventualmente disponível é a saída serial. 
 
Assim, a função printf é uma excelente forma de transmitir dados serialmente do PIC 
para outro dispositivo externo, como, por exemplo, um terminal de vídeo ou um 
microcomputador. 
 
O formato geral da função printf e: 
 
printf ( argumento(s) ); 
 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
Estes argumentos utilizam o código da barra invertidaque se segue: 
 
Código Caractere 
 YYY Constante Octal yyy 
\xyyy Constante hexadecimal yyy 
 \0 Nulo (null) 
 \a Campainha (BEL) 
 \b Retrocesso (backspace) 
 \t Tabulação horizontal 
 \n Linha nova (line feed) 
 \v Tabulação vertical 
 \f Avanço de formulário 
 \r Retorno de carro (Return) 
 \” Aspas 
 \’ Apóstrofo 
 \\ Barra invertida “\” 
 
 
Configuração do PIC 
 
No início da programação do PIC devemos configurar o PIC para começar a programar 
as tarefas do PIC, essas configurações dependem de PIC para PIC e as principais se 
seguem. 
 
Diretivas Fuses de configuração 
 
Fuses são diretivas para configuração inicial de diversos parâmetros de um PIC, essas 
configurações variam de PIC para PIC e devem ser consultadas no Datasheet de cada 
PIC para correta configuração, também temos a descrição da configuração dos Fuses na 
referência de linguagem do compilador PICC em inglês. 
 
 
#FUSES para o PIC16F877 
LP Oscilador de baixa potencia < 200 khz 
XT Cristal oscilador <= 4mhz 
HS Oscilador de Alta Velocidade (> 4mhz) 
RC Resistor/Capacitor Oscilador com CLKOUT (saída de clock) 
NOWDT Watch Dog Timer desabilitado 
WDT Watch Dog Timer habilitado 
NOPUT Power Up Timer desabilitado 
PUT Power Up Timer habilitado 
PROTECT Código protegido de leitura 
PROTECT_5% Protejer 5% da ROM 
PROTECT_50% Protejer 50% da ROM 
NOPROTECT Código não protegido de leitura 
NOBROWNOUT Brownout reset desabilitado 
BROWNOUT Reset quando brownout detectado 
LVP Low Voltage Programming on B3(PIC16) or B5(PIC18) 
Programação em baixa voltagem 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
NOLVP Desabilita Low Voltage Programming, B3(PIC16) ou B5(PIC18) 
usado para I/O 
CPD Código protegido da EEPROM de dados 
NOCPD Proteção da EEPROM desabilitada 
WRT Proteção de escrita da memória de programa 
NOWRT Proteção de escrita da memória de programa desabilitada 
DEBUG Debug mode para uso com ICD 
NODEBUG Debug mode para uso com ICD desabilitado 
 
 
Fuses para o PIC16F628A 
LP Oscilador de baixa potencia < 200 khz 
XT Cristal oscilador <= 4mhz 
HS Oscilador de Alta Velocidade (> 4mhz) 
EC_IO Clock externo 
INTRC_IO Oscilador Interno RC, sem CLKOUT (RA6 I/O) 
RC Oscilador Resistor/Capacitor com CLKOUT 
INTRC Oscilador Interno RC 
RC_IO Oscilador Resistor/Capacitor RA6 I/O 
WDT Watch Dog Timer (Proteção contra travamento) 
NOWDT Desabilita Watch Dog Timer 
PUT Power Up Timer habilitado 
NOPUT Power Up Timer desabilitado 
NOMCLR Master Clear (RA5) usado como entrada digital 
MCLR Master Clear (RA5) usado como Reset do PIC 
BROWNOUT Reset quando brownout detectado 
NOBROWNOUT Brownout reset desabilitado 
LVP Low Voltage Programming on B3(PIC16) or B5(PIC18) 
Programação em baixa voltagem 
NOLVP Desabilita Low Voltage Programming, B3(PIC16) ou B5(PIC18) 
usado para I/O 
CPD Código protegido da EEPROM de dados 
NOCPD Proteção da EEPROM desabilitada 
PROTECT Código protegido de leitura 
NOPROTECT Código não protegido de leitura 
 
 
Diretivas #use 
 
#use delay 
 
Informa ao compilador a velocidade do clock do sistema. 
 
Sintaxe: #use delay (clock = valor) 
 
Esta diretiva é necessária para a utilização das funções de atraso de tempo (delay_ms ou 
delay_us) e também para as rotinas de comunicação serial. 
 
 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
 
#use satandard_io 
 
Seleciona o modo padrão de entrada e saída. 
 
Sintaxe: #use standard_io (porta) 
 
Onde: porta pode ser uma porta de saída, exemplo: 
 
#use standard_io (B) 
 
#use fast_io 
 
Seleciona o modo rápido de entrada e saída. 
 
Neste modo o compilador não irá inserir nenhuma instrução para controle dos 
registradores TRIS do dispositivo, produzindo um código mais rápido e eficiente, 
porém, devemos alterar o registrador TRIS pelo comando set_tris (x) no início do 
programa. 
 
Exemplo: #use fast_io (B) 
 
#use fixed_io 
 
Seleciona o modo fixo de entrada e saída. 
 
Sintaxe: #use fixed_io (porta_outputs = pino, pino, ...) 
 
No modo fixo o compilador irá inserir código de configuração dos registradores TRIS a 
cada utilização dos pinos especificados. Note que o registrador TRIS é programado com 
a configuração selecionada na diretiva e não pelo tipo de função executado. 
 
Exemplo: #use fixed_io (B = pin_b0, pin_b1) 
 
#use i2c 
 
Habilita o uso da biblioteca interna de comunicação I2C. 
 
Sintaxe: #use i2c (opções) 
 
Exemplo: 
 
#use i2c(Master,Slow,sda=PIN_C4,scl=PIN_C3) 
 
 
 
 
 
 
 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
 
Opção Descrição 
MASTER Seta o modo mestre 
SLAVE Seta o modo escravo 
SCL = pino Especifica qual o pino de clock I2C 
SDA = pino Especifica qual o pino de dados I2C 
ADDRESS = nn Especifica o endereço do dispositivo em modo escravo 
FAST Utiliza a especificação de alta velocidade I2C 
SLOW Utiliza a especificação de baixa velocidade I2C 
RESTART_WDT Reinicia o watchdog enquanto aguarda dados na função 
I2C_READ 
FORCE_HW Força a utilização do hardware interno (SSP ou MSSP) do PIC 
 
 
 
#use rs232 
 
Ativa o suporte a comunicação RS232 
 
Sintaxe: #use rs232 (opções) 
 
Opções Descrição 
BAUD = valor Especifica a velocidade de comunicação serial. 
XMIT = pino Especifica o pino de transmissão de dados. 
RCV = pino Especifica o pino de recepção de dados. 
RESTART_WDT Determina qual a função getc() reset o watchdog enquanto 
aguarda a chegada de um caractere. 
INVERT Inverte a polaridade dos pinos de TX/RX. Não pode ser 
utilizada com o hardware interno. 
PARITY = x Seleciona a paridade (x pode ser: N (sem paridade), E 
(paridade par) ou O (paridade ímpar)). 
BITS = x Seleciona o número de bits de dados (5 a 9 para o modo 
por software e, 8 e 9 para o modo hardware). 
FLOAT_HIGH A saída não vai a nível lógico 1. Utilizado com saídas em 
coletor aberto. 
ERRORS Solicita ao compilador que armazene os erros de recepção 
na variável RS232_ERRORS, resetando os flags de erro 
quando eles ocorrerem. 
BRGH10K Permite a utilização das velocidades disponíveis com o bit 
BRGH em 1 em chips que tenham bugs nesta 
configuração do hardware. 
ENABLE = pino Especifica um pino para atuar como saída de habilitação 
durante uma transmissão. Utilizado no protocolo RS485. 
STREAM = identificador Associa a interface RS232 a um identificador de stream de 
dados. Os streams de dados são utilizados em algumas 
funções internas do compilador. 
 
 
 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
 
Funções de entrada e saída 
 
Output_low() 
 
Coloca o pino especificado em nível lógico 0. 
 
Sintaxe: output_low (pino) 
 
Exemplo: 
 
Output_low (pin_b0); // coloca pin_b0 em nível lógico 0. 
 
Output_high() 
 
Coloca o pino especificado em nível lógico 1. 
 
Sintaxe: output_high (pino) 
 
Exemplo: 
 
Output_high (pin_c1); // coloca pin_c1 em nível lógico 1. 
 
Output_X() 
 
Escreve um byte complete emu ma determinada porta do PIC. 
 
Sintaxe: 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 nível lógico do pino pin_b4 
 
Input() 
 
Lê o estado lógico de um pino do PIC. 
 
Sintaxe: res = input(pino) 
 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
 
Onde: res é o estado do pino 
 pino é um pino do PIC 
 
Exemplo: 
 shot int x; 
 x = input (pin_a0); // Lê o estado do pino A0 
 
Input_X() 
 
Lê um byte complete de uma porta do PIC. 
 
Sintaxe: valor = input_A () 
 valor = input_B () 
 valor = input_C () 
 valor = input_D () 
 
Onde: valor é uma variável de 8 bits. 
 
Exemplo: 
 int x; 
 x = input_b(); // Lê o estado da porta B 
 
Set_tris_X() 
 
Configura a direção dos pinos de uma porta do PIC. 
 
Sintaxe: set_tris_A ( valor ) 
 set_tris_B ( valor ) 
 set_tris_C ( valor ) 
 set_tris_D ( valor )Onde: valor é uma variável inteira de 8 bits. 
 
Note que o uso desta diretiva é desnecessária com as diretiva #use standard_io e #use 
fixed_io, já que nestes modos de IO o compilador configura automaticamente a 
direção dos pinos. 
 
Exemplo: 
 set_tris_b (0b00001111); 
 // Configura os pinos B0 a B3 como entradas e B4 a B7 como saídas 
 
 
 
 
 
 
 
 
 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
 
Exemplos de códigos 
 
/* RS232.h 
 * Arquivo de Comunicação 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 
 
 
 
/* Arquivo RS232.c de Comunicação Serial RS232 */ 
#include "RS232.h" 
 
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); 
 
 char c; 
 
 printf ("Digite A ou B!\n\r"); 
 
 while (true) 
 { 
 c = getc(); 
 switch (c) 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
 { 
 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 // Configuração 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 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
 0b10000111, // 7 
 0b11111111, // 8 
 0b11100111};// 9 
 
void main() // Função principal 
{ 
 setup_adc_ports(NO_ANALOGS); // Configura analógicos 
 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]); 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
 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 interrupção */ 
#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 interrupção para pisca de 1 segundo */ 
#include "mainT0.h" 
#define led pin_b0 
 
#int_TIMER0 // Tratamento de interrupção 
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 interrupções 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
 { 
 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 interrupções 
 enable_interrupts(INT_TIMER0); 
 enable_interrupts(GLOBAL); 
 
 set_timer0(131); // inicia o timer 0 em 131 (256 - 125) para 
 // dividir por 125 
 while (true); // espera interrupção 
} 
// 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 
// Conversão Analógico Digital 
#include "adc.h" 
#include "mod_lcd.c" // Biblioteca do LCD deve estar junto do arquivo principal 
Introdução à programação de microcontroladores– www.pictronics.com.br 
 
 
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 cálculos, somamos um ao 
 // valor lido: 
 // resultado = (5000 * (valor + 1)) / 1024 
 // simplificando: 
 // resultado = ((valor + 1) * 4) + ((valor + 1) * 113) / 128 
 // Repare que é necessário converter a segunda parte da 
 // equação para 32 bits para que o compilador efetue o 
 // cálculo corretamente 
 valor = read_adc(); // efetua a conversão 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 tensão 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 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
 
// Arquivo LCD.h 
// Tratamento de LCD alfanumérico 
#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 diretório 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 
 
 // Função lcd_escreve 
 //lcd_escreve ("Curso de PIC"); 
 
 // Imprime menssagem no LCD 
 printf (lcd_escreve, "Curso de PIC"); 
 
 int conta = 0; // Variavel de contagem 
 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
 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); 
 } 
} 
 
/* Funções importantes da biblioteca mod_lcd 
 
lcd_ini() // inicializa LCD 
lcd_pos_xy( byte x, byte y) // posição de texto x, y 
lcd_escreve( char c) // função de escrita no LCD 
*/ 
 
// Fim do arquivo LCD.c 
 
 
Configuração de novos projetos no ambiente PICC-CCS 
 
 
Assistente de 
novos projetos 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
 
 
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 
gravação. 
 
 
 
Em seguida, encontramos as telas de configuração do Projeto que vamos desenvolver, 
seguem diversas telas de configuração de cada periférico do PIC. 
 
Botão Salvar 
Nome do 
Projeto 
Pasta 
destino 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
 
 
 
No MPLab temos algumas configurações: 
 
 
 
 
 
 
Nome do Projeto 
Frequência de 
funcionamento 
do PIC 
Guias de 
configuração 
Configuração 
dos Fuses 
Selecione o PIC 
Programa exemplo 
Assistente de 
Projeto 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
Bem-vindo! Qual PIC? 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Selecione o 
PIC 
Compilador 
Foi 
encontrado? 
Buscar 
compilador 
Nome do Projeto 
Salvar na 
pasta? 
Se já existir um arquivo 
adicione ao projeto, senão, 
devemos criar um novo. 
Detalhes do 
novo projeto 
Selecione o Programador, no caso MPLab ICD2 
 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
 
 
 
 
 
Dentro do ambiente MPLab, o programador já grava no PIC o arquivo .hex, se for 
utilizado outro gravador externo, devemos carregar o arquivo .hex para ser gravado, este 
arquivo está junto com os arquivos gerados na criação do projeto, por isso a necessidade 
de gravarmos cada projeto em uma pasta separada. 
 
Utilizando o Proteus para simular nossos projetos 
 
Abrimos o Proteus (ISIS) e inserimos os componentes: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Barra de ferramentas do 
gravador 
Caixa de comunicação do 
gravador mostrando que está 
pronto para próxima operação! 
Arquivo fonte, no caso 
em linguagem C 
Botão compilar 
Para inserir os 
componentes 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Selecione o 
componente, clicando 
duas vezes com o 
botão esquerdo. 
Insira os componentes e 
faça as ligações, o 
hardware depende do 
software! 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Tudo configurado, vamos simular! 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Arquivo 
fonte do PIC 
Frequência 
do PIC 
Configuração do 
Terminal Serial Virtual 
Clique para simular 
Altere os 
elementos como 
se fosse real 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
 
 
 
Se o componente sumiu, clique para vê-lo novamente. 
 
 
 
 
Glossário de termos relacionados a microcontroladores PIC 
 
PORT : Agrupamento de pinos. Ex : PORT A : Pinos RA0 a RA5. PORT B : Pinos 
RB0 a RB7. 
PWM : Modulação por largura de pulso. Permite simular uma saída analógica através 
de pulsos digitais rápidos e de tamanho regulável. 
ADC : Conversor digital / analógico. 
ICSP : In-Circuit Serial Programming (Programação Serial In-Circuit) Recurso de 
programação serial embutida, permitindo que um gravador seja construído com custo 
relativamente baixo. 
RAM : Memória de acesso aleatório, volátil e de alta velocidade de acesso. 
ROM : Memória de programa, gravada quando se transfere o programa para o 
microcontrolador. 
EEPROM : Memória fixa que pode ser gravada e apagada em tempo de execução. 
SERIAL : Dispositivo de comunicação onde um bit é enviado de cada vez. 
I2C : Padrão de comunicação serial desenvolvido pela PHILIPS. 
SPI : Serial Peripheral Interface – Interface periférica serial : Padrão de comunicação 
serial que usa 4 fios. 
 
 
 
 
Introdução à programação de microcontroladores – www.pictronics.com.br 
 
 
Bibliografia e referências: 
 
• PEREIRA, Fábio, PIC Programação em C, EditoraÉrica, 3ª Ed. 
• PEREIRA, Fábio, Microcontroladores PIC Técnicas Avançadas, Editora Érica, 6ª Ed.