Aprenda Linguagem C Básico para Microcontroladores - v1

Aprenda Linguagem C Básico
para Microcontroladores PIC

de 8 bits
Antonio Ramirez Hidalgo

Departamento de Engenharia Elétrica - DEL
Universidade Federal de Sergipe - UFS
Sergipe - Brasil
Aprenda Linguagem C Básico para Microcontroladores PIC de 8 bits Prof. Antonio Ramirez Hidalgo
OBJETIVOS
Aprender a programar em linguagem C os Microcontroladores (uC) PIC, para isso
usaremos um microcontrolador mid-range o PIC16F8XX o qual não será estudado
exaustivamente já que o foco é a linguagem de programação.
Usar-se-á o compilador mikroC PRO for PIC a versão free que tem capacidade de
processar até 2K palavras de programa e o software PROTEUS (ISIS) para a simulação
dos circuitos.
Este minicurso é direcionado para os estudantes, técnicos, hobbistas, pessoas
com pouco conhecimento de programação, engenheiros ou professores, que
necessitam aprender a programar em Linguagem C para desenvolver projetos
microcontrolados.
Montaremos pequenos sistemas utilizando o software PROTEUS. Este software é
poderoso para simular vários tipos de microcontroladores com muita precisão, além
de ter vários instrumentos e componentes virtuais que servirão para fazer as
verificações necessárias dos projetos implementados.
A teoria sempre será acompanhada de uma parte prática, já que se tem
pesquisado que esta é a melhor maneira de aprender a programar em alguma
linguagem. “Programar se aprende programando”
Página 2 de 63
Sumário
CAPÍTULO 1. MICROCONTROLADOR PIC16F887 ........................................................................... 8

1. Características básicas do PIC16F887.................................................................................... 8
1.1. Alimentação de um PIC16F887 ........................................................................................ 10
1.2. Portas de entrada/saída. .................................................................................................. 10
CAPÍTULO 2. PERIFÉRICOS BÁSICOS ........................................................................................... 14
2.1. Diodo Led ......................................................................................................................... 14
2.2. Chaves e Teclas (Switches and push buttons) .................................................................. 15
2.3. Entradas digitais com optoacoplador .............................................................................. 17
2.4. Display de sete segmentos ............................................................................................... 18
2.5. Controle com relés ........................................................................................................... 19
2.6. Buzzer ............................................................................................................................... 21
CAPÍTULO 3. PRINCIPIOS BÁSICOS DO PROTEUS ........................................................................ 22
3.1. Montagem de circuitos com PROTEUS VSM .................................................................... 22
3.2. Desenhando o Circuito ..................................................................................................... 23
3.3. Edição das propriedades dos objetos .............................................................................. 27
3.4. Simulação do Projeto ....................................................................................................... 29
3.5. Exercícios de Simulação com Proteus .............................................................................. 30
CAPÍTULO 4. Compilador MIKRO C PRO para PIC ....................................................................... 31
4.1. Instalação do mikroC PRO for PIC .................................................................................... 31
4.2. IDE do Compilador mikroC PRO for PIC............................................................................ 31
CAPÍTULO 5. Programando em Linguagem C .............................................................................. 39
5.1. Princípios de Programação............................................................................................... 39
5.2. Elementos Lexicos do mikroC........................................................................................... 40
5.3. Tipos de Dados ................................................................................................................. 45
5.4. Operadores Aritméticos ................................................................................................... 47
5.5. Operadores de Atribuição ................................................................................................ 47
5.6. Operadores Relacionais.................................................................................................... 48
5.7. Operadores Lógicos .......................................................................................................... 48
5.8. Operadores Lógicos Bit a Bit (BITWISE)............................................................................ 49
5.9. Controle de Fluxo ............................................................................................................. 52
5.9.1. Instruções if ............................................................................................................... 52
5.9.2. Instruções if-else ....................................................................................................... 53
Página 3 de 63
5.9.3. Instruções if-else-if .................................................................................................... 53

5.9.4. Instruções switch - case ............................................................................................ 54
5.10. Instruções de Repetição ................................................................................................. 56
5.10.1. Instrução while ........................................................................................................ 56
5.10.2. Instrução do - while ................................................................................................. 57
5.10.3. Instrução for ............................................................................................................ 58
5.11. Funções .......................................................................................................................... 59
5.11.1 Funções Prototipo ........................................................................................................ 61
5.11.2 Funções void................................................................................................................. 61
5.11.3 Passando Parâmetros para as Funções ........................................................................ 62
5.11.4 Passando Arrays para as Funções ................................................................................ 62
Página 4 de 63
Lista de Figuras
Figura 1. Pinos do microcontrolador PIC16F887 e encapsulado DIP-40 ....................................... 9
Figura 2. Diagrama em blocos do microcontrolador PIC16F887 .................................................. 9
Figura 3. Circuito de alimentação do microcontrolador PIC16F887. Este também pode ser
alimentado na faixa de 2 a 5,5 V ................................................................................................. 10
Figura 4. Pinos do microcontrolador PIC16F887 ........................................................................ 13
Figura 5. Diferentes modelos de diodos LEDs............................................................................ 14
Figura 6. Partes do diodo LED e como polarizar este.................................................................. 14
Figura 7. Formas de conectar um LED a um microcontrolador .................................................. 15
Figura 8. Barra de 10 LEDs........................................................................................................... 15
Figura 9. Chaves e Teclas............................................................................................................. 15
Figura 10. Níveis de tensão ideais de uma chave e uma tecla. ................................................... 16
Figura 11. Trepidação em uma chave ........................................................................................ 16
Figura 12. Controle de uma entrada com um optoacoplador 4N25 ........................................... 17
Figura 13. Display de sete segmentos ........................................................................................ 18
Figura 14. Conexão do display de sete segmentos como microcontrolador .............................. 18
Figura 15. Conexão do relé a dispositivos de potência ............................................................... 19
Figura 16. Governo de uma carga potência com relé ................................................................. 20
Figura 17. Driver ULN2003 e governo de vários relés ................................................................. 20
Figura 18. Controle de pequenas cargas com relé de láminas encapsulado em DIL .................. 21
Figura 19. Buzzer Com Oscilador Interno, pode ser com 5V, 3V ou outros. ............................... 21
Figura 20. Conexão do Buzzer a um microcontrolador............................................................... 21
Figura 21. Ambiente ISIS do PROTEUS ........................................................................................ 22
Figura 22. Janela Pick Devices ..................................................................................................... 23
Figura 23. Janela com os componentes necessários para o projeto. ......................................... 24
Figura 24. Mostrando os botões de rotacionar e reflexão (espelhar). ....................................... 25
Figura 25. Opções de copiar, mover ou rotacionar/espelhar ..................................................... 25
Figura 26. Esquema elétrico de um sistema com microcontrolador .......................................... 26
Figura 27. Janela Edit Component de um resistor ...................................................................... 27
Figura 28. Janela da Fonte de Alimentação ................................................................................ 28
Figura 29. Janela de Propriedades para um microcontrolador .................................................. 29
Figura 30. Botões de controle para simulação ........................................................................... 29
Figura 31. Simulação de um circuito com microcontrolador. ..................................................... 30
Figura 32. IDE do mikroC PRO for PIC e sua diferentes partes. .................................................. 32
Figura 33. Project Manager e opções ......................................................................................... 32
Figura 34. Janela Code Explorer .................................................................................................. 33
Figura 35. Janela Project Settings ............................................................................................... 33
Figura 36. Janela Library Manager .............................................................................................. 34
Figura 37. Icones usados no Simulador....................................................................................... 37
Figura 38. Janela Watch Values .................................................................................................. 38
Figura 39. Keywords do compilador mikroC ............................................................................... 41
Figura 51. Circuito no Proteus a ser usado nos exemplos de variáveis. ..................................... 46
Figura 52. Circuito no Proteus a ser usado nos exemplos de operadores. ................................. 50
Página 5 de 63
Página 6 de 63
Lista de Tabelas
Tabela 1. Pinos do microcontrolador PIC16F887 ........................................................................ 11
Tabela 2. Combinação dos bits IRCF................................................Erro! Indicador não definido.
Tabela 3. Operações lógicas da Álgebra de Boole ...................................................................... 39
Tabela 4. Sequencias de Escape.................................................................................................. 44
Tabela 5. Tipos de Dados ............................................................................................................ 45
Tabela 6. Modificadores dos tipos de dados .............................................................................. 45
Tabela 7. Operadores Aritméticos .............................................................................................. 47
Tabela 8. Operadores de atribuição composta........................................................................... 47
Tabela 9. Operadores Relacionais............................................................................................... 48
Tabela 10. Operador Lógica AND ................................................................................................ 48
Tabela 11. Operador Lógica OR .................................................................................................. 49
Tabela 12. Operador Lógica NOT ................................................................................................ 49
Tabela 13. Operadores Lógicos Bit a Bit (Bitwise) ...................................................................... 49
Tabela 14. Prioridade e Associatividade de Operadores ............................................................ 50
Página 7 de 63
CAPÍTULO 1. MICROCONTROLADOR PIC16F887
Neste capítulo se apresenta uma revisão sucinta do microcontrolador PIC16F887,

mais informação poderá ser encontrada na folha de dados (datasheet) deste no site da
microchip.
Este modelo de microcontrolador é um dos mais poderosos da família PIC16F
(mid-range), sabendo as características deste se poderá trabalhar com os outros
membros da família PIC16F já que as arquiteturas destes são muito parecidas,
diferenciando somente na quantidade de módulos que tem cada um.
1. Características básicas do PIC16F887

 Arquitetura RISC
o Somente 35 instruções para aprender
o Todas as instruções em um único ciclo, exceto os desvios.
 Freqüência de operação de 0 a 20 MHz
 Oscilador interno de precisão
o Calibração de Fábrica
o Software seleciona a faixa de freqüência de 8 MHz a 31KHz
 Fonte de alimentação de 2,0 – 5,5 V
o Consumo: 220 uA (2,0 V, 4MHz), 11 uA (2,0 V, 32 KHz), 50 nA (modo parado)
 Economia de energia no modo Sleep
 Brown – out Reset (BOR) com opção de controle de software
 35 pinos de entrada/saída
o Alta corrente de fonte e dreno (source/sink) para excitação direta de leds.
o Resistor de pull-up programável individualmente ou por software.
o Interrupção – liga – muda – pino
 8 K de memória ROM em tecnologia FLASH
o Chip pode ser reprogramado até 100000 vezes
 Opção de programação serial no Circuito.
o O chip pode ser programado em um ambiente embarcado sem tirar este da
placa impressa.
 256 bytes de memória EEPROM
o Os dados podem ser escritos mais de 1000000 vezes.
 368 bytes de memória RAM
 Conversor A/D:
o 14 canais
o 10 bits de resolução
 3 temporizadores/contadores (timers/counters) independentes
 Temporizador Watch – dog
 Módulo comparador Analógico com:
o Dois comparadores analógicos
o Referência de voltagem fixa (0,6 V)
o Tensão de referência programável no chip (on - chip)
 Controle de saída PWM
 Módulo USART Estendido
Página 8 de 63
o Suporta RS-485, RS-232 e LIN2.0

o Detecta o Auto-Baud
 Porta Serial Síncrona Master (Master Synchronous Serial Port - MSSP)
Figura 1. Pinos do microcontrolador PIC16F887 e encapsulado DIP-40
Figura 2. Diagrama em blocos do microcontrolador PIC16F887
Página 9 de 63
1.1. Alimentação de um PIC16F887
Normalmente o microcontrolador PIC16F887 alimenta-se com 5 V aplicados

entre os pinos VDD e VSS que são respectivamente, a alimentação e a terra do chip. A
Figura 3 descreve um circuito de alimentação que obtém os 5 V a partir de uma tensão
de 12 V e de aproximadamente 1 ampere. Este circuito é baseado no popular
regulador de tensão 7805. O capacitor de 100 uF reduz consideravelmente a
ondulação da tensão de entrada que finalmente o regulador 7805 se encarrega de
estabilizar aos 5 V de alimentação do resto do circuito.
Figura 3. Circuito de alimentação do microcontrolador PIC16F887. Este também pode

ser alimentado na faixa de 2 a 5,5 V
1.2. Portas de entrada/saída.
O microcontrolador comunica-se com o mundo exterior através das portas.

Muitos dos pinos do PIC16F887 são multifuncionais como se viu na Figura 1. Por
exemplo, o quinto pino do microcontrolador RA3/AN3/Vref+/C1IN+ indica que este
tem as seguintes funções:
 RA3 Porta A terceira entrada/saída digital
 AN3 Terceira entrada analógica
 Vref+ Tensão de referência positiva
 C1IN+ Comparador C1 entrada positiva
Tal funcionalidade do pino é muito útil já que isto faz o encapsulamento mais
compacto sem afetar sua operação. Estas várias funções dos pinos não podem ser
usadas simultaneamente, mas podem ser mudadas em algum ponto da operação.
Os pinos são capazes de entregar níveis TTL (0 até 5 V) quando a tensão de
alimentação aplicada em VDD é 5 V.
A máxima capacidade de corrente de cada um deles é:
Página 10 de 63
 25 mA, quando o pino está no nível baixo, ou seja, quando consome corrente
(modo sink). Mas, a máxima corrente neste mesmo modo para cada porta A, B,
C, D e E é de 200 mA.
 25 mA, quando o pino está no nível alto, ou seja, quando fornece corrente
(modo source). Mas, a máxima corrente neste mesmo modo para cada porta A,
B, C, D e E é de 200 mA.
A tabela 1 mostra os pinos do PIC16F887.
Tabela 1. Pinos do microcontrolador PIC16F887
Página 11 de 63
Página 12 de 63
Figura 4. Pinos do microcontrolador PIC16F887
Página 13 de 63
CAPÍTULO 2. PERIFÉRICOS BÁSICOS
Apesar do fato de que o microcontrolador é um produto de tecnologia moderna,

é inútil se não estiver ligado a alguns componentes adicionais. Simplificando, o
aparecimento de tensões nos pinos do microcontrolador não significa nada se não for
utilizado para a realização de determinadas operações, tais como transformar algo on
/ off, deslocando, ou exibindo etc. Neste capitulo cobrimos alguns dos componentes
mais usados na pratica.
2.1. Diodo Led
O diodo LED é um dispositivo que permite comprobar o funcionamento dos

circuitos mediante a emissão de luz. É barato e fácil de conectar à saída de um
microcontrolador.
Figura 5. Diferentes modelos de diodos LEDs.
O LED se polariza diretamente com uma tensão entre 1,2 e 2,2 V, segundo o
modelo, e só precisa de 2 a 30 mA para ser ligado.
Figura 6. Partes do diodo LED e como polarizar este.
O microcontrolador PIC é capaz de governar diretamente os diodos LEDs de duas

formas distintas:
1) Conectando o catodo do diodo à saída do uC e o anodo ao positivo da alimentação
através de um resistor limitador. Neste caso o LED se ilumina com um nível baixo de
saída (0 lógico).
2) Conectando o anodo do diodo à saída do uC através de um resistor limitador e o
catodo a terra. Neste caso, o LED se ilumina com um nível alto de saída (1 lógico).
Página 14 de 63
O resistor limita o valor da corrente a um valor adequado para iluminar o LED.

Deve ter um valor entre 220 e 330 Ω. Na Figura 7 se for escolhido 330 Ω, este limita a
corrente a um valor de uns 10 mA que proporciona uma luminosidade suficiente para
a maioria das aplicações. Se quizer que o LED emita mais luz, pode baixar o valor do
resistor para 220 Ω.
Figura 7. Formas de conectar um LED a um microcontrolador
Os LEDs também podem ser encontrados encapsulados em barras de 8 ou 10

LEDs como se mostra na Figura 8.
a) Parte interna b) Aspecto Físico

Figura 8. Barra de 10 LEDs
2.2. Chaves e Teclas (Switches and push buttons)
Estes dispositivos permitem introduzir um nível lógico “0” ou “1” quando se

encontram “fechados” ou “abertos”.
Figura 9. Chaves e Teclas
Página 15 de 63
A leitura do estado das chaves e teclas é muito simples, estes dispositivos são
conectados entre uma entrada e terra, como se mostra na Figura 10 e se força à
entrada a um nível lógico alto mediante um resistor de pull up de 10 KΩ.
Figura 10. Níveis de tensão ideais de uma chave e uma tecla.

Enquanto o dispositivo está aberto, a entrada mantém uma tensão de 5 V que
corresponde a um nível lógico “1”. Quando se fecha, a entrada passa a valer 0 V
correspondente ao nível lógico “0”.
A trepidação de contacto (contact bounce) é um problema comum com chaves
mecânicas. Quando o contacto passa de um estado de fechado a aberto ou vice-versa
o momentum e elasticidade produzem uma trepidação. O resultado é uma rápida
corrente elétrica pulsada ao invés de uma limpa transição de um nível lógico para
outro. Na Figura 11 mostramos a trepidação em uma chave (mesma coisa para tecla).
Figura 11. Trepidação em uma chave
Esta situação causa problemas em alguns circuitos analógicos e digitais que respondem
rápido suficientes e mal interpretam os pulsos on/off como um trem de dados. Em
outras palavras, o processo total não é muito longo (uns poucos micro – ou
milisegundos), mas longos suficientes para serem registrados pelo microcontrolador.
Quando somente uma tecla é usada para um contador os erros acontecem em quase
100% dos casos. Uma forma de solucionar este problema é usar software da seguinte
forma: quando o programa testa o estado lógico de um pino de entrada e detecta uma
mudança, a checagem poderia ser feita mais uma vez depois de certo atraso (aprox. 30
ms). A verificação da mudança significa que uma chave ou tecla tem mudado sua
posição. As vantagens de tal solução são claras: esta é livre dessa situação e pode ser
aplicada a contactos com qualidade inferior.
Página 16 de 63
2.3. Entradas digitais com optoacoplador
Em alguns projetos é necessário utilizar sinais de entrada de alta tensão ou sinais

relacionados com a tensão da rede elétrica. Estas tensões não podem ser aplicadas
diretamente ao microcontrolador e é necessário isolar eletricamente o circuito usando
um optoacoplador como o mostrado na Figura 12.
Figura 12. Controle de uma entrada com um optoacoplador 4N25
O 4N25 é um optoacoplador popular, dentro do encapsulamento DIL-6 está um led e

um fototransistor. O funcionamento deste é o seguinte:
1) Quando se aplica uma tensão VIN, circula uma corrente pelo LED do optoacoplador
emitindo um feixe de luz que incide sobre o transistor e o satura. Neste caso à entrada
do microcontrolador aplica-se um nível baixo.
2) Quando não se aplica tensão alguma ao LED este fica desligado e o transistor fica na
região de corte (ou aberto). Na entrada do microcontrolador se aplica um nível alto
igual que quando está aberta a chave.
A tensão direta nos extremos do LED do 4N25 quando conduz é de 1,2 V e para
que ilumine tem que circular uma corrente de 5 mA. O resistor em série com o LED
deve permitir que circule esta corrente, assim, por exemplo, para uma tensão VIN de
24 V se liga um resistor com um valor comercial de 4K7 (ou melhor, de 3K9) já que:
RIN = (VIN – 1,2) / 5mA = (24V – 1,2V) / 5mA = 4,56 K
O LED suporta uma tensão máxima inversa de 3 v. Para aplicações em corrente

alternada tem que conectar em paralelo com o LED um diodo de proteção em inverso
ou, melhor, utilizar um optoacoplador que já o tenha integrado como o H11A1.
Pode verificarse que os dois circuitos na Figura 12 estão eletricamente isolados. A
única comunicação entre ambos é a luz que emite o LED.
Página 17 de 63
2.4. Display de sete segmentos

O display de 7 segmentos é um periférico digital de saída que se utiliza para
representar valores numéricos, como se mostra na Figura 13.
Figura 13. Display de sete segmentos
Cada display tem sete segmentos e um ponto decimal, todos eles são diodos LEDs.
Estes diodos podem estar em duas configurações possíveis, segundo os pinos que
tenham ligados: anodo comum ou catodo comum. Os segmentos dos displays se
controlam diretamente por algum pino de alguma porta do microcontrolador e
segundo o tipo de display a conexão ao microcontrolador muda como se mostra na
Figura 14.
Figura 14. Conexão do display de sete segmentos como microcontrolador
Página 18 de 63
2.5. Controle com relés
Um relé é um interruptor elétrico que abre e fecha sob o controle de outro

circuito elétrico. Este é, portanto, ligado aos pinos de saída do microcontrolador e
usado para ativar / desativar dispositivos de potência como motores, transformadores,
aquecedores, lâmpadas, etc.
É importante advertir que estes circuitos trabalham com a rede elétrica.
Qualquer erro, além de ocasionar danos sérios no circuito, pode provocar lesões
pessoais, por isso tem que ser muito cuidadoso durante a montagem e revisar este
com bastante paciência. Tenha especial cuidado em isolar bem todas aquelas
conexões ou cabos cujo contato com a pele humana possa produzir descargas
elétricas, sem esquecer também da parte metálica dos componentes de potência.
Estes dispositivos são quase sempre colocados fora da placa de componentes
sensíveis. Existem vários tipos de relés e todos funcionam da mesma maneira.
Quando a corrente flui através da bobina, o relé é operado por um eletroímã
para abrir ou fechar um ou mais conjuntos de contatos. Similar aos acopladores
ópticos, não há nenhuma conexão galvânica (contato elétrico) entre as entradas do
relé e a saída.
Relés normalmente requerem alta tensão e corrente elevada para iniciar a
operação, mas há também aqueles em miniatura que podem ser ativadas por baixa
corrente fornecida directamente a partir de um pino do microcontrolador.
Figura 15. Conexão do relé a dispositivos de potência

A fim de evitar a auto-indução de alta tensão, causada por uma parada brusca do
fluxo de corrente através da bobina, um diodo em polarização invertida é ligado em
paralelo com a bobina. O objetivo deste diodo é "cortar" o pico de tensão.
Outra implementação de circuito é apresentado na Figura 16, utilizando um par de
transistores na configuração darlington.
Página 19 de 63
Figura 16. Governo de uma carga potência com relé
Quando a saída do microcontrolador (µC) fornece um nível alto à base do

darlington, passa a condução e ativa o relé que, ao fechar seus contatos, pode
controlar uma potência maior na carga. Este circuito também isola elétricamente a
carga do µC. O valor da potência a controlar depende dos contatos do relé e varia
muito segundo o modelo, ainda que quase todos possam suportar mais de 5 Amp.
Para controlar certo número de relés a partir do mesmo µC, se pode utilizar um
circuito integrado especializado tal como o ULN2003, Figura 17. Este chip dispõe de
sete circuitos inversores internos com circuitos darlington, que suportam uma tensão
máxima de 50 V e podem alimentar cargas de até 500 mA, internamente também tem
os indispensáveis diodos de proteção.
Figura 17. Driver ULN2003 e governo de vários relés
Página 20 de 63
Para cargas de até 10 W é melhor utilizar relés de láminas encapsulados em DIL,

que precisam de uma menor intensidade de corrente para ativação, ainda que seus
contatos não permitam ativar cargas grandes. A Figura 18 mostra um exemplo de
aplicação onde só é necessário um transistor para controlar o relé. Normalmente estes
relés incorporam dentro da capsula o diodo de proteção, para os modelos que não
tem é necessário conectar um no circuito.
Figura 18. Controle de pequenas cargas com relé de láminas encapsulado em DIL
2.6. Buzzer
Em muitos projetos é necessário indicar mediante um sinal audível a ocorrência

de um evento, para isso normalmente se utiliza um buzzer como mostra a Figura 19.
Figura 19. Buzzer Com Oscilador Interno, pode ser com 5V, 3V ou outros.
O buzzer funciona com tensões entre 3 e 16 V e seu consumo não supera os 10 mA,
pelo que pode ser alimentado diretamente pela saída de um microcontrolador, como
indica a Figura 20.
Buzzer emite som
com saída a nível
baixo
Buzzer emite som

com saída a nível
alto
Figura 20. Conexão do Buzzer a um microcontrolador

Página 21 de 63
CAPÍTULO 3. PRINCIPIOS BÁSICOS DO PROTEUS
PROTEUS é uma ferramenta de software que permite a simulação de circuitos

eletrônicos com microcontroladores. Este software permite realizar de forma virtual as
práticas de laboratório sem ter que “queimar” alguns componentes.
3.1. Montagem de circuitos com PROTEUS VSM
Figura 21. Ambiente ISIS do PROTEUS
ISIS é o ambiente de trabalho do PROTEUS. Aqui se projetam, desenham e simulam os

circuitos.
A gente não vai descrever cada elemento desta janela. Você mesmo pode ir
conhecendo estes colocando o cursor do mouse sobre eles. Proteus mostra uma
pequena descrição do elemento sinalizado quando pressiona a tecla F1.
Chama-se objetos aos diversos elementos que podem estar presentes na folha de
projeto. Segundo a categoria presente na barra de ferramentas, podemos nomear
assim:
Página 22 de 63
Components. Representam todos os cmponentes eletrônicos presentes em um

circuito, como os LEDs, capacitores, microcontroladores, etc.
Virtual Instruments. Oferece os instrumentos de medição como o Osciloscópio,
voltímetro, frequencimetro, etc.
Generator. Para produzir ondas quadradas, senoidais, de relógio, etc.
Simulation Graphs. Para visualizar os resultados da simulação em gráficos, no

estilo dos programas como Electronic Workbench ou Cadence Orcad.
Inter-sheet Terminal. Nos permitirá colocar os terminais de entrada, saída,
assim como as fontes de alimentação.
ETC, ETC, ETC,....
O painel da parte esquerda do ambiente ISIS que na Figura 21 se vê com o título de

DEVICES e com os botões de P e L chama-se Object Selector. O Object Selector
eventualmente mudará de nome e mostrará os elementos ou formas da categoria
selecionada atualmente (Components, Virtual Instruments, etc).
3.2. Desenhando o Circuito
Para acrescentar um objeto à folha de desenho primeiro se estabelece a categoria do

objeto. Por exemplo, para comezar a colocar os componentes eletrônicos do circuito
devemos selecionar o ícone Components da barra de
ferramentas.
Com isso, a janela Object Selector se converte em Device
Selector. Na figura do lado aparece vazio porque ainda não
temos selecionado nenhum componente. Assim clicamos o
botão P ou simplesmente pressionamos a tecla “P”. Em
qualquer caso veremos a janela Pick Devices.
Figura 22. Janela Pick Devices
Na caixa de texto Keywords se escreve o componente procurado. Notar que o

Proteus tem um motor de busca e não é necessário escrever o nome completo de uma
parte. A medida que vai se escrevendo, Proteus vai mostrando todos os elementos
Página 23 de 63
coincidentes. Neste circuito precisaremos de PIC16F84A, resistor, capacitor, botão

(push buttom), LEDs e cristal. As fontes de alimentação se procuram em outro lado.
Quando está localizado o componente damos um duplo click para enviar este ao
Device Selector. Assim podemos ir colocando os dispositivos que faltam. Quando
acabemos com esta parte fechamos esta janela clicando em Cancel ou pressionando
ESC no teclado.
Agora o painel Object Selector contém os diversos dispositivos que formaram
nosso circuito. Selecionamos um a um e logo colocamos estes no esquemático com um
click esquerdo.
Figura 23. Janela com os componentes necessários para o projeto.
Os símbolos de terra e alimentação que estão na Figura 23 não se encontram nas

bibliotecas dos dispositivos eletrônicos. Podem ser encontrados no Object Selector
depois de encontrar a categoría Inter-sheet Terminal, identificada com o icone na
barra de ferramentas. De ali tambén podemos obter os terminais de entrada INPUT e
saída OUTPUT, muito úteis para conectar elementos sem a necessidade de unir estes
diretamente com os fios.
Página 24 de 63
Como os objetos não sempre se apresentarão na posição

desejada conheçamos algumas formas de mudá-las.
Um objeto fica selecionado por um click esquerdo do mouse.

Então aprecerá na cor vermelha (por default). Se tira a seleção
de um objeto fazendo outro click sobre alguma parte vazia da
folha de projeto. Para editar a posição de um elemento
selecionar este e abrir seu menu (click botão direito do mouse)
ali se encontram diversas opções disponíveis. Alternativamente podem ser usados
outros atalhos, por exemplo:
 Para mover um objeto, seleciona este e depois arrastar este com o botão
esquerdo até o lugar desejado.
 Para rotacionar um objeto, seleciona este e logo pressiona a tecla ‘+’ ou ‘-’ do
teclado numérico até conseguir a orientação desejada. Outra forma de fazer isso
é aplicando os botões de rotação ao objeto selecionado. A rotação só é possível
em ângulos retos.
 Para refletir um objeto, sobre seu eixo horizontal ou vertical, seleciona este e
utiliza os botões de reflexão como mostra a Figura 24.
Figura 24. Mostrando os botões de rotacionar e reflexão (espelhar).
A seleção de um grupo de objetos se consegue agrupando estes em um retângulo

desenhado com o botão esquerdo. Depois pressionando o botão direito do mouse
mostrará as opções de edição do grupo como copiar, mover ou rotacionar/espelhar.
Estas opções também estão presentes na barra de ferramentas. A forma mais fácil de
mover um grupo de objetos selecionados é arrastá-lo com o botão esquerdo
pressionado.
Figura 25. Opções de copiar, mover ou rotacionar/espelhar
Muitas vezes depois da edição dos objetos ainda ficam restos ou marcas do desenho
sobre o esquemático, então para refrescar de forma rápida todo o diagrama se pode
pressionar a tecla R (Redesenho).
Os fios para a interconexão dos elementos do circuito não estão em uma categoria em
especial, estes se colocam diretamente aproveitando a forma de lápis do cursor e as
Página 25 de 63
marcas de snap (esses pequenos □) que aparecem ao aproximar o lápis a algum

terminal.
Figura 26. Esquema elétrico de um sistema com microcontrolador
Os elementos da Figura 26 são os seguintes:

PIC16F84A. Provavelmente o PIC que se mostra no esquemático não é igual ao que
você tem em seu Proteus, o importante é que tenha essa nomenclatura e tenha o
mesmo modelo, o resto é só questão de apariência. A ausência dos pinos GND e VDD
no esquemático se deve ao fato de que na simulação estes não são levados em
consideração. De fato, o Proteus assume que, como a maioria dos dispositivos digitais,
o PIC trabalhará com a alimentação de 0 e 5 V.
LED. Existem vários tipos de diodos LED disponíveis. Neste caso buscaremos os LEDs
animados (os que acendem). Como está é uma simulação as cores não tem
importância.
RESISTOR. Quando escrevemos resistor no requadro Keywords aparece uma lista com
muitos tipos, desde os modelos genéricos até os resistores comerciais.
CERAMIC22P. De igual maneira que os resistores existem muitos modelos de
capacitores disponíveis. Desta vez se procurou o capacitor de 22pF. Estes são os que
estabilizam o circuito oscilador do XTAL. Para a simulação com microcontroladores
Página 26 de 63
este circuito não tem maior efeito, já que a freuência de operação do PIC se coloca no
mesmo PIC, motivo pelo qual o circuito do XTAL ficaria de enfeite. Às vezes, é ignorado
para aliviar a carga do projeto e melhorar a velocidade de simulação.
DISC100N16V. Este é um capacitor para desacoplar de 100nF. No ambiente ISIS não
tem ruído nem interferência este capacitor também é decorativo.
CRYSTAL. Como se falou anteriormente, no Proteus a freqüência de trabalho do PIC é
estabelecida no mesmo PIC ficando a presencia do cristal como inecessária.
BUTTON. Este são os famosos “push button” que não faltam em algum projeto.
3.3. Edição das propriedades dos objetos

Uma das grandes vantagens das simulações é que podem mudar os elementos
do projeto ou seus valores com muita facilidade. Para editar as propriedades de um
objeto tem que clicar duas vezes o botão esquerdo do mouse. Assim aparece a janela
de propriedades a qual mudará de acordo com o objeto tratado. Por exemplo, se
queremos mudar o valor de um resistor, só haveria que modificar o parâmetro
Resistance na sua janela Edit Component.
Figura 27. Janela Edit Component de um resistor
A fonte de alimentação POWER tem um valor de 5V por default, ainda que não
se veja no esquemático. Se você quizer ver o VDD ou VCC pode abrir a janela de
propriedades e escolher uma opção do combobox. O combobox não oferece tensões
ordinárias. Se precisássemos as teríamos que escrever a mão. Por exemplo, para uma
fonte de 12 V se escreve +12V ao lado da String. A V não faz falta, mas o sinal ao
começo é imprescindível, além disso, não se devem deixar espaços em branco.
Página 27 de 63
Figura 28. Janela da Fonte de Alimentação
A edição das propriedades do PIC pode passar por mudar muitos parâmetros.
Neste momento só veremos os dois que realmente interessam na grande maioria dos
projetos. O programa do PIC e sua freqüência de operação.
 Program File é o campo onde carrega o programa do microcontrolador. Este
pode ser o conhecido arquivo *.HEX (o mesmo que utilizamos para gravar o
microcontrolador) ou um arquivo de depuração (*.COF ou similar), que para
propósitos de simulação e depuração resulta mais ilustrativo.
 Para carregar um arquivo dar um click ao ícone que aparece ao lado e no diálogo
Select File Name que aparecerá busca e seleciona o arquivo em questão.
 Processor Clock Frequency. No caso dos PIC16 é a freqüência do XTAL usado pelo
PIC, mas para os PIC18 não necessariamente é assim.
Página 28 de 63
Figura 29. Janela de Propriedades para um microcontrolador
3.4. Simulação do Projeto
Vamos a utilizar os seguintes botões de controle:
Figura 30. Botões de controle para simulação
 Play (F12). Inicia a simulação.

 Step (Ctrl + F12). Iniciar/Reiniciar o debugging, se houver algum
microcontrolador no projeto. Para o debugging (a depuração) se precisa algo a
mais que o arquivo *.HEX.
 Pause (Pause). Pausar a simulação.
 Stop (Shift + Pause). Deter a simulação.
Com o circuito minimamente montado e com o programa do PIC (*.COF, *.HEX ou

outro) carregado, rodar a simulação pressionando o botão Play e deveria se ver como
mostra a Figura 31.
Página 29 de 63
Figura 31. Simulação de um circuito com microcontrolador.
3.5. Exercícios de Simulação com Proteus
Página 30 de 63
CAPÍTULO 4. Compilador MIKRO C PRO para PIC
A primeira coisa que precisamos para escrever um programa para o

microcontrolador é um programa para o PC o qual entenda a linguagem de
programação a ser usada, neste caso C, e forneça uma janela para escrever o
programa. O software deve “conhecer” a arquitetura do microcontrolador em uso.
Neste caso, você necessita um compilador para linguagem C.
Não existe um compilador para ser usado para um único microcontrolador como
não há um compilador para ser usado para todos os microcontroladores. Nós
utilizaremos o compilador mikroC PRO for PIC e como o nome sugere no compilador
se escreverá programas para microcontroladores PIC na linguagem C. Este tem toda a
informação da arquitetura interna destes microcontroladores, a operação de circuitos
em particular, conjunto de instruções, nomes de registradores, pinos, etc. Quando
você ativa o compilador, a próxima coisa a ser feita é selecionar um “chip” da lista , a
frequência de operação e claro a escrever o programa em C.
4.1. Instalação do mikroC PRO for PIC
Para fazer a instalação vamos a seguir os seguintes passos:
1. Carregar o compilador no site da

(http://www.mikroe.com/mikroc/pic/)
2. Ir para ícone de download carregar o arquivo do compilador,
este tem uma licença demonstrativa completamente funcional de 2K palavras
de programa o qual é suficiente para aplicações simples.
3. Descompactar o arquivo do compilador e clicar duas vezes no arquivo
descompactado e siga as instruções do programa. Quando aparecer a
mensagem de instalação dos drivers do programador pode dizer que não já que
a gente não terá o programador deles a menos que você compre este e então
terá que instalar esses drivers.
Agora já está pronto para usar o compilador.
4.2. IDE do Compilador mikroC PRO for PIC

A tela principal do compilador é a mostrada na Figura 32.
Infelizmente, uma descrição detalhada de todas as opções deste compilador tomaria

muito de nosso tempo, portanto pularemos esta parte.
Na verdade, nós descreveremos somente o processo de escrever um programa em

linguagem C, checaremos o simulador também como carregar a memória do
microcontrolador. Mais informação consultar o help [F1].
Página 31 de 63
Project Settings Menu Toolbar Code Editor Project Manager
Routine List Code Explorer Error Window Library Manager
Figura 32. IDE do mikroC PRO for PIC e sua diferentes partes.
PROJECT MANAGER
Um programa escrito no compilador mikroC não é um documento separado, mas parte

de um projeto o qual inclui código Hex, código em assembler, cabeçalhos e outros
arquivos. Alguns deles são criados durante a operação do compilador, enquanto que
outros são importados desde outros programas. A janela Project Manager o habilita a
manusear todos eles. É suficiente clicar o botão direito do mouse em alguma pasta e
selecionar a opção que necessita para seu projeto.
Figura 33. Project Manager e opções
Página 32 de 63
CODE EXPLORER
A janela Code Explorer nos habilita a facilmente localizar funções e procedimentos

dentro de programas longos. Por exemplo, se você procura uma função usada no
programa, então clica duas vezes no nome da função nesta janela e o cursor
automaticamente se posicionará no ponto apropriado do programa.
Figura 34. Janela Code Explorer
PROJECT SETTINGS (CONFIGURAÇÕES DO PROJETO)
Para que o compilador opere adequadamente é necessário fornecer a este com

informação básica sobre o microcontrolador que vai ser usado também com a
informação que se espera depois do processo de compilação.
Device – Quando você seleciona um microcontrolador para ser usado, o compilador

automaticamente sabe qual arquivo de definição contém todos os registradores SFR
(Special Function Register), seus endereços na memória e similares.
Oscillator – Esta opção é usada para selecionar a velocidade de operação do

microcontrolador. Com esta informação o compilador faz mudanças na palavra de
configuração. A velocidade de operação é configurada para habilitar o oscilador
interno do microcontrolador a operar com um cristal de quarzo selecionado.
Figura 35. Janela Project Settings
Build Type – Release: quando selecionado “release” depois que o processo de

compilação está completo, o compilador não tem influência sobre a execução do
programa. Para os propósitos de “debugging”, um software simulador pode ser usado.
Página 33 de 63
Build Type – ICD Debug: Quando o processo de compilação está completo e o

microcontrolador programado, o compilador permanece conectado ao
microcontrolador e ainda pode afetar sua operação. A conexão é estabelecida via
programador o qual é conectado ao PC via cabo USB. Um software fazendo todo isto é
chamado de ICD (In Circuit Debugger). Este habilita ao programa ser executado passo a
passo e fornece acesso ao conteúdo atual de todos os registradores do
microcontrolador. Simulação não é realizada, seu conteúdo é literalmente lido no
verdadeiro microcontrolador controlando o dispositivo verdadeiro.
CODE EDITOR
O Code Editor (Editor de Código) é uma parte central da janela do compilador usado
para escrever programas. Um grande número de opções usado para configurar suas
funções e leiaute podem ser encontradas no menu Tools/Options [F12].
LIBRARY MANAGER
Uma das opções mais úteis deste programa é o Library Manager “Gerenciador de
Biblioteca” e certamente merece a nossa atenção.
A principal vantagem de uma linguagem de alto nível tal como C é que este é capaz de
usar o conhecimento e trbalho de outras pessoas. As funções das bibliotecas são o
melhor exemplo disto. Se você necessita uma função para executar uma certa tarefa
enquanto escreve um programa, você deve procurar por esta dentro de alguma
biblioteca que está integrada no compilador e usar esta. Se alguma biblioteca é
“checada”, suas funções serão automaticamente reconhecidas durante o processo de
compilação tal que não é necessário usar o comando #include.
Figura 36. Janela Library Manager
Página 34 de 63
BIBLIOTECAS STANDARD ANSI C
Bibliotecas Standard ANSI C incluem a funções padrão da linguagem C:
B IB LIOTECA DESCRI Ç ÃO
ANSI C Ctype Library Principalmente usado para teste ou conversão de dados
ANSI C Math Library Usado para operações matemáticas de ponto flutuante
ANSI C Stdlib Library Contém funções da biblioteca padrão
ANSI C String Library Usado para executar operações de manipulação de memória e string
MISCELANEA DE BIBLIOTECAS
Na miscelanea de bibliotecas contém algumas funções de propósito gerais as quais não

estão incluídas nas bibliotecas padrão ANSI C:
B IB LIOTECA DESCRI Ç ÃO
Button Library Usado para o desenvolvimento em um projeto
Conversion Library Usado para conversão de tipo de dados
Sprint Library Usado para facilitar a formatação de dados
PrintOut Library Usado para facilidade de formatação de dados e impressão
Time Library Usado para calculo do tempo (formato de tempo UNIX)
Trigonometry
Usado para a implementação de funções fundamentais de trigonometria
Library
Setjmp Library Usado para pulos no programa
BIBLIOTECAS ESPECIFICAS DE HARDWARE
As bibliotecas especificas de Hardware incluem funções usadas para controlar a

operação de vários módulos de hardware:
Página 35 de 63
B IB LIOTECA DESCRIÇ ÃO
ADC Library Used for A/D converter operation
CAN Library Used for operation with CAN module
Used for operation with external CAN module (MCP2515 or

CANSPI Library
MCP2510)
Compact Flash Library Used for operation with Compact Flash memory cards
EEPROM Library Used for operation with built-in EEPROM memory
EthernetPIC18FxxJ60
Used for operation with built-in Ethernet module
Library
Flash Memory Library Used for operation with built-in Flash memory
Used for operation with graphic LCD module with 128x64

Graphic Lcd Library
resolution
I2C Library Used for operation with built-in serial communication module I2C
Keypad Library Used for operation with keyboard (4x4 push buttons)
Lcd Library Used for operation with LCD display (2x16 characters)
Manchester Code Library Used for communication using Manchester code
Multi Media Card Library Used for operation with multimedia MMC flash cards
Used for operation with circuits using One Wire serial

One Wire Library
communication
Port Expander Library Used for operation with port expander MCP23S17
PS/2 Library Used for operation with standard keyboard PS/2
PWM Library Used for operation with built-in PWM module
RS-485 Library Used for operation with modules using RS485 serial communication
Software I2C Library Used for I2C software simulation
Software SPI Library Used for SPI software simulation
Página 36 de 63
Software UART Library Used for UART software simulation
Sound Library Used for audio signal generation
SPI Library Used for operation with built-in SPI module
SPI Ethernet Library Used for SPI communication with ETHERNET module (ENC28J60)
SPI Graphic Lcd Library Used for 4-bit SPI communication with graphic LCD display
Used for 4-bit SPI communication with LCD display (2x16

SPI Lcd Library
characters)
SPI Lcd8 Library Used for 8-bit SPI communication with LCD display
SPI 6963C Graphic Lcd

Used for SPI communication with graphic LCD display
Library
UART Library Used for operation with built-in UART module
USB Hid Library Used for operation with built-in USB module
SIMULADOR
Antes de iniciar o simulador, selecione o modo apropriado

na janela Project Settings (Build type – Release) e clicar a
opção Run/Start Debugger.
O compilador será automaticamente configurado no modo

simulação. Este monitora o estado de todos os bits dos
registradores. Isto também habilita executar o programa
passo a passo enquanto monitora a operação do
microcontrolador na tela (isto é, simulação da operação).
Uns poucos ícones, usados para a operação deste

simulador, serão acrescentados ao toolbar quando
configurando o compilador neste modo.
Figura 37. Icones usados no Simulador
Página 37 de 63
O significado da icone é a seguinte:
Step Into – Ao clicar neste icone se executa a linha de programa na qual o cursor está
posicionado.
Step Over – Este comando é similar ao ícone anterior. Se o cursor é posicionado na

linha na qual é chamada uma rotina de programa então esta será executada primeiro e
o programa procede com a execução na primeira próxima linha de programa. Isto
parece como se uma linha de programa fosse pulada embora toda a rotina seja
executada. Como um resultado, o estado dos registradores muda. Este comando é
comumente usado quando é necessárioacelerar a execução de longos laços de
programa.
Run To Cursor – Este comando é usado para executar uma parte particular do
programa, isto é, desde a última linha executada à linha na qual o cursor está
localizado.
Step Out – Clicando este icone, o programa sai da rotina que está sendo executada.
O simulador e o debugger (depurador) tem a mesma função de monitorar o estado dos

registradores durante a execução do programa. A diferença é que o simulador executa
o programa sobre o PC, enquanto que o depurador usa um microcontrolador de
verdade. Alguma mudança de estado de um pino lógico é refletida sobre o apropriado
registrador (porta). Como o “Watch Window” permite monitorar o estado de todos os
registradores é fácil checar se um pino esta configurado para zero ou um. Para ativar
esta janela é necessário selecionar “View/Windows” e clicar a opção Watch Values.
Então pode fazer uma lista dos registradores e ver o estado que se deseja monitorar.
Figura 38. Janela Watch Values
Página 38 de 63
CAPÍTULO 5. Programando em Linguagem C

Os programas em C se tornam muito mais eficientes e mais rápidos de serem
escritos, pois os Compiladores de Programas em Linguagem C para Microcontroladores
possuem várias bibliotecas de funções prontas como Comunicação Serial, ADC,
EEPRON, I2C, PWM, LCD, etc.
Contudo, uma das grandes vantagens de se programar em C é que o

programador não precisa se preocupar com o acesso a bancos, localização de memória
e periféricos dos Microcontroladores, pois o Compilador é responsável por gerenciar
esses controles.
Toda essa eficiência da Linguagem C proporciona ao programador somente

preocupar-se apenas com o programa em si e o compilador traduz da Linguagem C
para a Linguagem de máquina (.HEX) que é a linguagem que os Microcontroladores
conseguem entender.
5.1. Princípios de Programação

A Álgebra de Boole e seus operadores são muito utilizados em sistemas digitais e
também na programação em Linguagens como o Assembly e também a Linguagem C.
Temos então as operações AND, OR, NOT, NAND, NOR, XOR e XNOR ( E, OU,
NÃO, NÃO E, NÃO OU, OR EXCLUSIVO e NÃO OR EXCLUSIVO respectivamente).
Tabela 2. Operações lógicas da Álgebra de Boole
Porta Simbologia Tabela Verdade Função Lógica Expressão

Função E:
Assume 1 quando
todas as variáveis
E ou AND forem 1 e 0 nos S = A.B
outros casos
Função OU:
Assume 0 quando
todas as variáveis S=A+B
OU ou OR forem 0 e 1 nos
outros casos
Função NÃO:
NÃO ou Inverte a variável
NOT aplicada à sua
entrada
Função NÃO E:
Inverso da função
NÃO E ou E.
NAND
Página 39 de 63
Função NÃO OU:

Inverso da função
NOR ou OU.
NÃO OU
Função OU
EXCLUSIVO:
OR
Assume 1 quando
EXCLUSIVO as variáveis
ou XOR assumirem
valores diferentes
entre si.
Função NÃO OU
EXCLUSIVO
NÃO OR (COINCIDÊNCIA):
EXCLUSIVO Assume 1 quando
ou XNOR houver
coincidência entre
os valores das
variáveis.
5.2. Elementos Lexicos do mikroC

Os elementos léxicos são parecidos com unidades de palavras reconhecidas pelo
mikroC. Cada programa escrito em mikroC consiste de uma sequencia de caracteres
ASCII tais como letras, dígitos e caracteres especiais. Caracteres não imprimíveis
(caractere nova linha, tab, etc.) são referenciados como caracteres especiais.
Espaços em branco (Whitespace)
Espaços (brancos), tabs vertical e horizontal e caracteres nova linha são

coletivamente chamados de espaços em branco (whitespace). Whitespaces são usados
como separadores para indicar onde um símbolo (token) começa e finaliza. Por
exemplo, as duas seguintes sequencias.
char i;
unsigned int j;
e
char
i;
unsigned int j;
são lexicamente equivalentes e analizados (parse) identicamente dando a mesma

quantidade de tokens cada:
char
i
;
unsigned
int
j
;
Página 40 de 63
Whitespace com Strings
Um whitespace pode acontecer em literais de strings. Neste caso este não é

usado como um delimitador, mas como um caractere comum, isto é, representa parte
de uma string. Por exemplo, a seguinte string
some_string = “mikro foo”;
Se analiza como quatro tokens, incluindo a string literal como um único token:
some_string
=
“mikro foo”
;
Palavras Chave (Keywords)
Os keywords são palavras reservadas com um significado fixo o qual não pode ser
usado como identificador. Além dos keywords padrão do mikroC, existe um conjunto
de identificadores (de constantes e variáveis) pré-definidos referidos como palavras
reservadas. Elas descrevem um microcontrolador especifico e não podem ser
redefinidos. A continuação uma lista dos keywords do mikroC em ordem alfabético:
Figura 39. Keywords do compilador mikroC
Página 41 de 63
Comentários
Um comentário é uma parte do programa usado para clarificar a operação de um

programa ou para fornecer mais informação acerca deste. Existem comentários de
uma linha ou multilinhas em mikroC. Os comentários multilinhas são encerrados entre
/* e */ como no exemplo a seguir:
/* digitar um comentário aqui.
Este pode ser de múltiplas linhas
Como este exemplo */
Ou um comentário de uma linha com ‘//’. qui o exemplo:

//Digite seu comentário aqui.
//Este eh de uma linha somente.
Também em blocos de instruções em assembler poderiam ser introduzidos

comentários de uma linha colocando ‘;’ na frente do comentário:
asm{
algo em asm ; esta eh uma instrução em assembler
Identificadores
São nomes arbitrários usados para nomear objetos básicos da linguagem tais
como rótulos, tipos, constantes, variáveis e funções. Os identificadores podem conter
todas as letras do alfabeto (maiúsculas e minúsculas), o caractere underline ‘_’
também como os dígitos de 0 a 9. O primeiro caractere de um identificador deve ser
uma letra ou um underline. mikroC é caso sensitivo por default, o que significa que
Sum, sum e suM não são considerados identificadores equivalentes.
Alguns identificadores válidos:
temperatura V1
Pressao
no hit
dat2string
SUM3
vtext
Alguns identificadores não válidos:

7temp //não pode começar com um número
%alto //não pode conter caractere especial
if //não pode usar palavra reservada
j23.07.04 //não pode conter caractere especial (ponto)
Página 42 de 63
Literais
São símbolos que representam valores numéricos fixos ou caracteres. O

compilador determina o tipo de dado de uma literal sobre a base de seu formato (a
forma desta é representada no código) e seu valor numérico.
Literais Inteiras
As literais inteiras podem ser escritas em notação hexadecimal (base 16),

decimal (base 10), octal (base 8) ou binário (base 2).
As literias inteiras com prefixo 0x (ou 0X) são considerados números hexadecimais. Por
exemplo, 0x8F.
Em notação decimal, as literais inteiras são representadas como uma sequencia de

dígitos (sem comas, espaços ou pontos) com o prefixo opcional + ou - . As literais
inteiras sem prefixo são consideradas positivas. Exemplo o número 6358 é equivalente
ao número +6358.
As literais inteiras que começam com zero são consideradas números octais. Por
exemplo, 0357.
As literias inteiras que começam com 0b (ou 0B) são considerados números binários.
Por exemplo, 0b10100101.
Aqui alguns exemplos de literias inteiras:
0x11 //literal hexadecimal igual ao decimal 17

11 //literal decimal 11
011 //literal octal igual ao decimal 9
0b11 //literal binário igual ao decimal 3
Literais de Ponto Flutuante
O literal ponto flutuante consiste de: inteiro decimal, ponto decimal, fração
decimal e “e” ou “E” e um expoente inteiro com sinal (opcional).
0. //= 0.0
-1.23 //= -1.23
23.45e6 //= 23.45 * 10^6
3E+10 //= 3.0 * 10^10
2e-5 //= 2.0 * 10^-5
.09E34 //= 0.09 * 10^34
Literais Caractere
Um literal caractere é um caractere CII, entre apostrofes. Exemplo: ‘a’, ‘ ’.
Página 43 de 63
Literais Strings
Representa uma sequencia de caracteres CII entre aspas (“”). Os literais strings
podem conter espaços em branco. O analisador não vai dentro da string, mas trata
esta como um único símbolo. Existe um caractere nulo (NULL - ASCII zero) ao final de
string. Este não está incluído no comprimento total da string. Uma string sem nada
entre as aspas (string nulo) é armazenado como um simples caractere nulo. Exemplo:
“Ola mundo” //mensagem, 9 caracteres
“Tempratura estavel” // mensagem, 9 caracteres
“ ” //
“C” //
“” //
Sequencias de Escape
O caractere backslash ‘\’ é usado para introduzir uma sequencia de escape, os

quais permitem uma representação visual de alguns caracteres não imprimíveis. Um
dos mais comumente usados é o caractere nova linha ‘\n’. Um backslash é usado com
um valor octal ou hexadecimal para representar seu símbolo ASCII. A tabela a
continuação mostra as várias sequencias de escape.
Tabela 3. Sequencias de Escape

SEQUENCIA VALOR CARACTERE QUE FAZ?
\a 0x07 BEL Campainha audível
\b 0x08 BS Backspace
\f 0x0C FF Formfeed
\n 0x0A LF Newline (Linefeed)
\r 0x0D CR Carriage Return (retorno de carro)
\t 0x09 HT Tab (horizontal)
\v 0x0B VT Vertical Tab
\\ 0x5C \ Backslash
\’ 0x27 ‘ Apostrofe
\” 0x22 “ Aspas
\? 0x3F ? Pergunta
\O Algo O = string de até 3 digitos octais
\xH Algo H = string de dígitos hexadecimais
\XH algo H = string de dígitos hexadecimais
Página 44 de 63
5.3. Tipos de Dados

mikroC é uma linguagem estritamente tipada, o que significa que cada objeto,
função e expressão devem ter seu tipo definido antes de que o processo de
compilação comece.
Tabela 4. Tipos de Dados
TAMANHO
TIPO
DESCRIÇÃO (NUMERO FAIXA DE VALORES
DADO
DE BITS)
char Caractere 8 0 to 255
int Inteiro 16 -32768 to 32767
float Ponto Flutuante 32 ±1.17549435082 ·10-38 to ±6.80564774407 ·1038
Ponto flutuante desde ±1.17549435082 ·10-38 a ±6.80564774407

double 32
dupla precisão ·1038
Tabela 5. Modificadores dos tipos de dados
TIPO DE T I P O D E D AD O C O M T AM AN H O
F AI X A
D AD O PREFIXO (NUMERO DE BITS)
char signed char 8 -128 a 128
unsigned int 16 0 a 65535
short int 8 0 a 255

int signed short int 8 -128 a 127
long int 32 0 a 4294967295
signed long int 32 -2147483648 a 2147483647
EXEMPLOS
/*
Exemplo_1: Este programa mostra como declarar as variaveis e será mostrado no simulador.
Microcontrolador: PIC16F887
Clock: 8 MHz
*/
//Declaramos variaveis globais

char i;
float j;
void main()
{
ANSEL = 0; // Configura os pinos AN como digitais
ANSELH = 0;
C1ON_bit = 0; // Desabilita os comparadores
C2ON_bit = 0;
i = 47;
j = i; // pode colocar char em float?
i = j; // pode colocar float em char?
while(1);
}
Página 45 de 63
O circuito a ser usado nos seguintes exemplos é feito no Proteus, a continuação o

circuito.
+5
R0
10k
D5 D4 D3 D2 D1 D0
U1
1 15
RE3/MCLR/VPP RC0/T1OSO/T1CKI
16
270R RC1/T1OSI/CCP2
2 17
RA0/AN0/ULPWU/C12IN0- RC2/P1A/CCP1
3 18
RA1/AN1/C12IN1- RC3/SCK/SCL
4 23
RA2/AN2/VREF-/CVREF/C2IN+ RC4/SDI/SDA
5 24
RA3/AN3/VREF+/C1IN+ RC5/SDO
6 25
RA4/T0CKI/C1OUT RC6/TX/CK
7 26
RA5/AN4/SS/C2OUT RC7/RX/DT
14
RA6/OSC2/CLKOUT
13 19
RA7/OSC1/CLKIN RD0
22pF 20
RD1
33 21
RB0/AN12/INT RD2
34 22
RB1/AN10/C12IN3- RD3
8MHz 35 27
RB2/AN8 RD4
36 28
RB3/AN9/PGM/C12IN2- RD5/P1B
37 29
RB4/AN11 RD6/P1C
38 30
RB5/AN13/T1G RD7/P1D
22pF 39
RB6/ICSPCLK
40 8
RB7/ICSPDAT RE0/AN5
9
RE1/AN6
10
RE2/AN7
PIC16F887
Figura 40. Circuito no Proteus a ser usado nos exemplos de variáveis.
No segundo exemplo se mostrará a formatação das constantes.

/* //Formatacao de constantes hexadecimais
Exemplo_2: Este programa faz uma simples PORTA = 0x01;
tarefa de mostrar a formatação das Delay_ms(1000);
constantes. Aqui se mostram as PORTA = 0x02;
equivalencias entre os diferentes sistemas Delay_ms(1000);
de numeração. Será implementado no PORTA = 0x04;
Proteus. Delay_ms(1000);
Microcontrolador: PIC16F887 PORTA = 0x08;
Clock: 8 MHz Delay_ms(1000);
*/ PORTA = 0x10;
Delay_ms(1000);
void main() PORTA = 0x20;
{ Delay_ms(1000);
ANSEL = 0; // Configura os pinos AN //Formatacao de constantes octais
como digitais PORTA = 001;
ANSELH = 0; Delay_ms(1000);
C1ON_bit = 0; // Desabilita os PORTA = 002;
comparadores Delay_ms(1000);
C2ON_bit = 0; PORTA = 004;
PORTA = 0; Delay_ms(1000);
TRISA = 0b11000000; //os pinos 7 e 6 sao PORTA = 010;
entradas de clock, os pinos de 0 a 5 Delay_ms(1000);
//sao saidas digitais. PORTA = 020;
while(1) Delay_ms(1000);
{ PORTA = 040;
//Formatacao de constantes decimais Delay_ms(1000);
PORTA = 1; }
Delay_ms(1000); }
PORTA = 2;
Delay_ms(1000);
PORTA = 4;
Delay_ms(1000);
PORTA = 8;
Delay_ms(1000);
PORTA = 16;
Delay_ms(1000);
PORTA = 32;
Delay_ms(1000);
//Formatacao de constantes binarias
PORTA = 0B000001;
Página 46 de 63
Delay_ms(1000);
PORTA = 0B000010;
Delay_ms(1000);
PORTA = 0B000100;
Delay_ms(1000);
PORTA = 0B001000;
Delay_ms(1000);
PORTA = 0B010000;
Delay_ms(1000);
PORTA = 0B100000;
Delay_ms(1000);
5.4. Operadores Aritméticos

São usados em operações aritméticas e sempre retornam valores positivos.
Diferentes dos operadores unários sendo executados sobre um operador, as
operações binárias são executadas sobre dois operadores. Em outras palavras, são
requeridos dois números para executar uma operação binária. Por exemplo: a+b ou
a/b.
Tabela 6. Operadores Aritméticos
O PER AD O R O PER AÇ ÃO
+ Adição (Soma)
- Subtração
* Multiplicação
/ Divisão
% Resto
5.5. Operadores de Atribuição

Existem dois tipos de atribuições em linguagem C:
 Simples operadores onde as variáveis recebem valores e para isto se usa o

caractere comum “ ”. Por exemplo: a = 8.
 Atribuições compostas são especificas para linguagem C e consiste de dois
caracteres como mostrado na Tabela 7. Uma expressão pode ser escrita de uma
maneira diferente também, mas esta fornece um código de máquina eficiente.
Tabela 7. Operadores de atribuição composta
O P E R AD O R EXEMPLO D E S C R I P Ç ÃO
++a
++ Variável "a" é incrementada por 1
a++
--b
-- Variável "b" é decrementada por 1
b--
Página 47 de 63
5.6. Operadores Relacionais

Os operadores relacionais são usados em comparação para o proposito de
comparar duas variáveis as quais podem ser inteiras (int) ou números de ponto
flutuante (float). Se uma expressão avalia como verdadeira, um 1 é retornado. Outra
coisa, um 0 é retornado. Este é usado em expressões tais como ‘if (expressão
verdadeira) then...’
Tabela 8. Operadores Relacionais
O P E R AD O R S I G N I F I C AD O EXEMPLO C O N D I Ç ÃO V E R D AD E I R A
> é maior que b>a Se b é maior que a
>= é maior que ou igual a a >= 5 Se a é maior que ou igual a 5
< é menor que a<b Se a é menor que b
<= é menor que ou igual a a <= b Se a é menor que ou igual a b
== é igual a a == 6 Se a é igual a 6
!= não é igual a a != b Se a não é igual a b
5.7. Operadores Lógicos

Existem três tipos de operações lógicas em linguagem C: lógica AND(E), lógica
OR(OU) e negação NOT (NÃO). Por uma questão de clareza, os estados lógicos nas
tabelas abaixo são representados como zero lógico (0 = falso) e um lógico (1 =
verdadeiro). Operadores lógicos retornam verdadeiro – true (1 lógico) se a expressão
avaliada é não zero, e falso (0 lógico) se a expressão avaliada for zero. Isto é
importante porque as operações lógicas são comumente usadas em expressões, não
em variáveis individuais (números) no programa. Portanto, as operações lógicas se
referem à verdade de toda a expressão.
Por exemplo: 1 && 0 é o mesmo que (expressão verdadeira) && (expressão falsa). O
resultado é 0, isto é FALSO em ambos casos.
Tabela 9. Operador Lógica AND
OPERADOR LÓGICA AND

Operador 1 Operador 2 Resultado
0 0 0
&& 0 1 0
1 0 0
1 1 1
Página 48 de 63
Tabela 10. Operador Lógica OR
OPERADOR LÓGICA OR
Operador 1 Operarador 2 Resultado
0 0 0
|| 0 1 1
1 0 1
1 1 1
Tabela 11. Operador Lógica NOT
OPERADOR LÓGICA NOT

Operand1 Result
! 0 1
1 0
5.8. Operadores Lógicos Bit a Bit (BITWISE)

Diferente dos operadores lógicos que são executados em variáveis, as operações
bitwise são realizadas sobre os bits individuais dentro de operandos. Os operadores
bitwise são usados para modificar os bits de uma variável. Eles são listados na seguinte
tabela:
Tabela 12. Operadores Lógicos Bit a Bit (Bitwise)
OPERADOR SIGNIFICADO EXEM PLO RESULT ADO

~ Bitwise complemento a = ~b b=5 a = -5
Shift left (desloca a
<< a = b << 2 b = 11110011 a = 11001100
esquerda)
Shift right (desloca a
>> a = b >> 2 b = 11110011 a = 00011110
direita)
a = 11100011
& Bitwise AND c=a&b c = 11000000
b = 11001100
a = 11100011
| Bitwise OR c=a|b c = 11101111
b = 11001100
a = 11100011
^ Bitwise EXOR c=a^b c = 00101111
b = 11001100
Todos os operadores apresentados até agora obedecem a uma prioridade, como

mostrado na Tabela 13. Para não ter que decorar esta tabela se tem as seguintes
sugestões:
 Os operadores devem ser agrupados usando parêntesis. As expressões entre

parêntesis são calculadas primeiro. Se necessário, multiples (aninhar)
parêntesis podem ser usados.
Página 49 de 63
 Excepto pelos operadores de atribuição, dois operadores não devem ser

escritos próximos um do outro.
Tabela 13. Prioridade e Associatividade de Operadores
PRIORIDADE OPERADORES ASSOCIATIVID ADE

High ( ) [ ] -> . De esquerda a direita
! ~ ++ -- +(unario) -(unario) *Pointer &Pointer De direita a esquerda
*/% De esquerda a direita
+- De esquerda a direita
<> De esquerda a direita
< <= > >= De esquerda a direita
== != De esquerda a direita
& De esquerda a direita
^ De esquerda a direita
| De esquerda a direita
&& De esquerda a direita
|| De esquerda a direita
?: De esquerda a direita
Low = += -= *= /= /= &= ^= |= <= >= De esquerda a direita
O circuito a ser usado nos seguintes exemplos é feito no Proteus, a continuação o

circuito.
Figura 41. Circuito no Proteus a ser usado nos exemplos de operadores.
Página 50 de 63
/*
Exemplo_3: O programa testará alguns dos operadores vistos na teoria. Será implementado
no Proteus.
Microcontrolador: PIC16F887
Clock: 8 MHz
*/
int a1; //variáveis

int ser;
void main()
{
ANSELH = 0;
C2ON_bit = 0;
PORTB = 0; //Toda a porta B igual a 0
TRISB = 0; //Toda a porta B será saída
while(1)
{
a1 = 3; //a variavel a1 recebe 3
PORTB = a1; //Porta B recebe o valor de a1.
Delay_ms (1000);
ser = a1;
PORTB = ser;
Delay_ms(1000);
a1 = ser * 11; //Expressao aritmetica simples, resposta 33 = 00100001

PORTB = a1;
Delay_ms (1000);
ser = 48 / 4; //Simples divisao, resposta 12

PORTB = b1;
Delay_ms (1000);
a1 = (ser - 5)% 7; //Expressao aritmetica complexa

//Envolvendo duas operacoes e
//forcando a ordem das operacoes
//Resposta zero.
PORTB = a1;
Delay_ms (1000);
a1 = ser - 5 % 7; //mesma operacao anterior sem forcar a ordem

//Resultado 7.
PORTB = a1;
Delay_ms (1000);
//exemplo 4. O programa testará alguns dos operadores bit a bit vistos na teoria.
char a1; //variavel a1 = 0b10000

char ser; //variavel ser = 0b01000
char res;
void main()
{
ANSELH = 0;
C2ON_bit = 0;
PORTB = 0; //Toda a porta B igual a 0
TRISB = 0; //Toda a porta B será saída
a1 = 16;
ser = 8;
while(1)
{
res = a1 & ser; //funcao logica AND. Resultado = 0b00000
PORTB = res;
Página 51 de 63
Delay_ms (2000);
res = a1 | ser; //funcao logica OR. Resultado = 0b11000=24

PORTB = res;
Delay_ms(2000);
res = ~ser; //funcao logica NOT. Resultado = 0b11110111 = 247. Já que a

//variavel char tem 8 bits.
PORTB = res;
Delay_ms (2000);
res = a1 ^ ser; //funcao logica XOR. Resultado = 0b11000 = 24

PORTB = res;
Delay_ms (2000);
res = a1 >> 2; //funcao deslocamento para direita. Resultado = 0b00100 = 4

PORTB = res;
Delay_ms (2000);
res = ser << 1; //funcao deslocamento para esquerda. Resultado = 0b10000 = 16

PORTB = res;
Delay_ms (2000);
}
}
5.9. Controle de Fluxo

O compilador usado suporta as seguintes instruções condicionais: if, if-else e switch.
A maioria das instruções condicionais pode ser usada para executar seletivamente
uma única linha de código ou múltiplas linhas de código relacionado (chamadas de
bloco). Sempre que uma instrução condicional estiver associada com apenas uma linha
de código executável, não são necessárias chaves { } envolvendo a instrução
executável. No entanto, se a instrução condicional estiver associada com instruções
executáveis múltiplas, é necessário utilizar chaves para conectar o bloco de instruções
executáveis com o teste condicional.
5.9.1. Instruções if
A instrução if é usada para executar condicionalmente um segmento de código. A
forma mais simples da instrução if é esta:
if (expressão)
Ação;
A expressão é avaliada e se for verdadeira executa a ação. No entanto, se a avaliação
da expressão for falsa a ação não é executada.
A sintaxe para uma instrução IF associada com um bloco de instruções executáveis

assemelha-se a:
if (expressão){
Ação1;
Ação2;
Ação3;
Ação4;
}
Exemplo:
if (conta == 5){
a = a++;
PORTC = 0XF1;
}
Página 52 de 63
5.9.2. Instruções if-else

Esta instrução permite que um programa assuma duas ações separadas baseado na
validade de uma expressão especial. A sintaxe é a seguinte.
if (expressão)
ação1;
else
ação2;
Neste caso se a expressão for verdadeira será executada a ação1, caso contrário,
quando a expressão for falsa será executada a ação2.
Podemos ter várias ações dentro da estrutura if .

if (expressão)
{
ação1;
ação2;
ação3;
}
else
{
ação4;
ação5;
ação6;
}
Exemplo:
if (a>22)
{
valor1 = x;
y = contador + 10;
}
else
{
valor2 = x;
Y = contador - 5;
}
Os if-else podem ser aninhados.
5.9.3. Instruções if-else-if

Esta instrução gerlamente é utilizada para executar comparações múltiplas e
sucessivas. Sua forma geral é a seguinte:
if (expressão1)
ação1;
else if (expressão2)
ação2;
else
ação3;
Cada ação poderia ser um bloco composto, necessitando ter seu próprio conjunto de
chaves. Este tipo de fluxo de controle lógico avalia cada expressão até encontrar uma
Página 53 de 63
que seja verdadeira. Quando isso acontece, todas as condições de testes restantes são
saltadas.
Exemplo:
if (contador==12)
{
Dúzia++;
X++;
}
else if (contador<12)
{
Dúzia=0;
y--;
}
else if (contador>12)
{
Dúzia = 0;
Z++;
}
EXERCÍCICOS SOBRE IF
5.9.4. Instruções switch - case

Pode ocorrer que você queira testar uma variável ou uma expressão em relação a
vários valores. Para isso você pode usar as intruções if-else-if ou a instrução switch-
case. Diferentemente de muitas outras instruções de seleção de linguagem de alto
nível, a instrução switch-case de C tem algumas peculiaridades. A sintaxe de uma
instrução switch-case é a seguinte:
switch (expressão integral)
{
case constante 1: instruções 1; break;
case constante 2: instruções 2; break;
.
.
.
case constante n: instruções n; break;
default: instruções;
}
Se a instrução break tivesse sido removida do trecho de programa de constante 1,
uma combinação similar usada no parágrafo anterior faria com que a instrução 2 fosse
a próxima instrução a ser executada. A instrução break faz com que a parte restante
das instruções switch sejam puladas.
A instrução switch opera da seguinte forma: Primeiro, a expressão integral é

avaliada, se expressão integral é igual a constante 1, então as instruções
seguintes a constante 1 são executadas. Se expressão integral é igual a
constante 2, então as instruções seguintes a constante 2 são executadas. Este
processo continua até a constante n, onde se a expressão integral é igual a
constante n, então as instruções seguintes a constante n são executadas. Se
expressão integral não é igual a nenhuma das constantes, então as instruções
seguintes ao default são executadas. Como dito anteriormente, a instrução break em
cada bloco faz que se retorne ao final da instrução switch (depois de fechar as chaves)
e pula fora do bloco de seleção. Sem a instrução break, o programa continuará a
Página 54 de 63
executar as instruções associadas com o próximo “case”. O último break não é

obrigatório, já que o bloco switch fecha depois desta instrução. O default é opcional e
pode ser evitado se temos certeza que a expressão integral será igual a uma das
constantes de 1 a n.
Exemplo: Se requer escrever um programa usando a instrução switch para
converter os caracteres hexadecimais de A até F para seu equivalente
decimal. Assumir que o caractere de entrada é armazenado em uma
variável chamada chr, e a saída será armazenada em uma variável y.
Solução: o equivalente decimal dos caracteres hexadecimais são:
Hexadecimal Decimal
A 10
B 11
C 12
D 13
E 14
F 15
Parte do programa é o seguinte:
switch (chr)
{
case ‘A’: y = 10; break;
case ‘B’: y = 11; break;
case ‘C’: y = 12; break;
case ‘D’: y = 13; break;
case ‘E’: y = 14; break;
case ‘F’: y = 15; break;
}
EXERCÍCIOS SOBRE SWITCH-CASE
Página 55 de 63
5.10. Instruções de Repetição

Outro bloco fundamental em alguma linguagem de programação é a repetição,
ou laço. Aqui, uma ou um grupo de instruções são executados repetidamente, até que
alguma condição seja satisfeita. Basicamente, o compilador mikroC for PIC suporta os
três tipos de instruções de repetição: while, do – while e laços for.
5.10.1. Instrução while

O formato geral da instrução while é a seguinte:
while (expressão) instrução;
Aqui, a instrução é executada enquanto a expressão seja verdadeira (TRUE). Em geral,

o número de instruções são mais do que uma e quando se tem várias instruções estas
devem estar entre chaves ({ }).
while (expressão)
{
Instrução1;
Instrução2;
...
Instruçãon;
}
No seguinte exemplo, o laço formado usando a instrução while é repetido 10 vezes. A

variável de controle do laço é i e é inicializado com 0 antes de entrar no laço (loop). As
instruções são executadas enquanto i seja menor que 10. Notar que dentro do laço, o
contador de laço i é incrementado por 1 em cada iteração.
i = 0;
while (i < 10)
{
Instruções;
i++;
}
Exemplo: Escrever um programa para inicializar um array inteiro chamado

MyArray para zero. Assumir que o array tem 10 elementos.
Solução:
O programa requerido é dado a continuação:
void main()
{
unsigned char i;
int MyArray[10];
i = 0;
while(i < 10)
{
MyArray[i] = 0;
i++;
}
}
Quando se usa a instrução while, é importante se certificar que a condição que
mantém o laço esteja mudando dentro do laço, senão se terá um laço infinito.
Algumas vezes se faz necessário criar laços infinitos em nossos programas. Este pode
ser facilmente alcançado usando uma instrução while, como mostrado a continuação:
Página 56 de 63
while(1)
{
instruções;
}
5.10.2. Instrução do - while

Esta é uma útil variação da instrução while. O format geral da instrução do – while é a
seguinte:
do
{
instruções;
} while(expressão);
Aqui, as instruções são executadas sempre que a expressão seja verdadeira. A

expressão usulamente inclui instruções lógicas e relacionais. Um exemplo é mostrado
onde o laço é terminado depois de 10 vezes.
i = 0;
do
{
instrução;
i++;
} while(i < 10);
Notar de novo que a condição que mantém o laço é mudada dentro do laço, tal que o
laço é terminado depois do número requerido de iterações. Com o laço while as
instruções dentro do laço podem nunca ser executadas se a condição é falsa, de outra
forma as instruções dentro do laço do – while são executadas ao menos uma vez já
que a condição é testada ao final do laço.
Exemplo: Escrever um programa para inicializar um array inteiro chamado
MyArray com 1’s. Assumir que o array tem 100 elementos.
Solução:
O programa requerido é o seguinte:
void main()
{
unsigned char i;
int MyArray[100];
i = 0;
do
{
MyArray[i] = 1;
i++;
} while(i < 100);
}
Exemplo: Escrever um programa usando o laço do – while para copiar uma string
chamada B para outra string chamada A.
Solução: Lembrar que as strings são arrays de caracteres terminados com o
caractere NULL. O laço do – while copiará o conteúdo da string B para A,
incluindo o terminador NULL. Notar que i é incrementado depois que seu valor
tem sido usado como um subscrito para B.
i = 0;
do
{
A[i] = B[i];
} while(B[i++] != ‘\0’);
Página 57 de 63
Exemplo: Escrever um programa para multiplicar dois arrays inteiros X e Y

tendo 10 elementos cada um deles, e armazenar a soma em uma variável inteira
chamada Sum.
Solução: O programa requerido é dado abaixo.
void main()
{
int X[10], Y[10], Sum;
unsigned char i = 0;
Sum = 0;
do
{
Sum = Sum + X[i]*Y[i];
i++;
} while(i < 10);
}
EXERCÍCIOS SOBRE WHILE E DO-WHILE
5.10.3. Instrução for

A instrução for é a instrução mais utilizada em programas com laços. O formato geral
desta instrução é:
for(expressão1; expressão2; expressão3) instruções;
Onde expressão1 configura o valor inicial de contagem do laço e esta variável é

avaliada somente uma vez quando entra no laço. Expressão2 é a condição que
mantém o laço continuamente. Esta expressão é avaliada a cada iteração, para checar
se o laço continua ou não. A expressão2 é usualmente um operador lógico ou
relacional. A expressão3 é também avaliada ao final de cada iteração e esta expressão
muda de valor e é testada para a terminação do laço. Expressão3 é usualmente um
incremento do valor da contagem do laço.
O laço for é comumente usado com mais de uma instrução. Um exemplo é dado a
continuação, onde o laço é repetido 10 vezes. O valor inicial do contador do laço i é 0,
este é incrementado por 1 em cada iteração, e o laço continua até que i seja menor
que 10.
for(i = 0; i < 10; i++)

{
instruções;
}
Alguns exemplos usando a instrução for são dados a continuação.

Exemplo: Escrever um programa para calcular o quadrado de números entre 1 e 49
e armazenar os resultados em um array inteiro chamado Mult.
Solução: o programa requerido é o seguinte:
void main()
{
int Mult[50];
unsigned char i;
for(i = 1; i <= 49; i++)
{
Mult[i] = i*i;
}
}
Página 58 de 63
Os laços for podem ser facilmente aninhados, como mostrado no exemplo seguinte:
Aqui todoso os elementos de um array bidimensional MyArray são inicializados com 0
(assumindo que a dimensão do array é 10). Neste exemplo, o laço interno é repetido
10 vezes para cada valor de i do laço externo, isto é o número total de iterações é de
100.
for(i = 0; i < 10; i++)
{
for(j = 0; j < 10; j++)
{
MyArray[i][j] = 0;
}
}
Os parâmetros em um laço for podem ser omitidos. Existem várias variações do laço
for, dependendo qual parâmetro é omitido.
Criar um laço infinito:
for(;;)
{
instruções;
}
Configurando a condição de laço inicial fora do laço:

i = 0;
for(; i < 10;)
{
instruções;
i++;
}
Para terminar o laço desde dentro do laço:

i = 0;
for(;; i++)
{
instruções;
if(i >= 10) break;
}
EXERCÍCIOS SOBRE FOR
5.11. Funções
Em geral, é uma boa pratica de programação escrever um programa grande e
complexo como uma coleção de pequenos módulos, onde cada modulo pode ser
testado independente do código principal. Uma função pode ser pensada como um
programa de código testável e auto-contido desenvolvido para executar uma tarefa
especifica. Funções são também criadas quando é requerido repetir um certo
algoritmo em vários diferentes lugares do programa principal. Por exemplo, poderia
ser requerido converter a temperatura desde oF em oC em vários lugares de um
programa. Ao invés de repetir o código, é mais eficiente e a manutenção do programa
é melhor se o código de conversão de temperatura é escrito na forma de uma função.
Esta função pode ser chamada sempre que esta é requerida para fazer a requerida
conversão.
O formato geral de uma função é com segue:
tipo nome(parâmetros)
{
Instruções;
}
Página 59 de 63
As funções usualmente (não sempre) executam certa operação e retornam algum

dado em resposta quando são chamados no programa. O tipo da função indica o tipo
de dado retornado, nome é o nome da função e parâmetros (se tiver algum) pode ser
separado por vírgulas. As instruções dentro da função devem estar dentro de um par
de chaves.
Um exemplo de uma declaração de função é dada a continuação, a qual calcula a
circunferência de um circulo e retorna ao programa principal. Aqui, o raio do circulo é
passado como um argumento para a função.
float Circumference(float radius)
{
float c;
c = 2*PI*radius;
return c;
}
Assumindo que desejamos calcular a circunferência de um circulo cujo raio é 2.5 cm, e
armazenamos o resultado em uma variável chamada Circ, a função anterior pode ser
chamada como se mostra:
Circ = Circumference(2.5);
Exemplo: Escrever duas funções para calcular a área e volume de um cilindro.

Mostrar como estas funções podem ser usadas em um programa para calcular a
área e volume de um cilindro cujo raio e altura são 3.0 e 12.5 cm,
respectivamente. Aramzenar a área na variável c_area e o volume na variável
c_volume.
Solução: a continuação se mostram as duas funções. O raio e altura do cilindro

são usados como parâmetros da função.
//
// Esta função calcula a área de um cilindro. O raio e altura são passados
// como parâmetros para a função.
//
float Cyl_Area(float raio, float altura)
{
float c;
c = 2*PI*raio*altura;
return c;
}
//
// Esta função calcula o volume de um cilindro. O raio e altura são passados
// como parâmetros para a função.
//
float Cyl_Volume(float raio, float altura)
{
float c;
c = PI*raio*raio*altura;
return c;
}
//
// Programa principal
//
void main()
{
float r, h, c_area, c_volume;
r = 3.0; // O raio
h = 12.5; // A altura
c_area = Cyl_Area(r, h); // Calcula a area
c_volume = Cyl_Volume(r, h); // Calcula o volume
}
Página 60 de 63
5.11.1 Funções Prototipo

Se uma função não é definida antes de ser usada no programa principal, então o
compilador gera um erro. Isto é porque o compilador não sabe que tipo de dado a
função retorna e o tipo de seus parâmetros. Uma maneira de evitar mensagens de
erros é criar uma função protótipo e declarar esta no começo do programa antes que a
função seja chamada pelo programa principal. Um afunção protótipo consiste do tipo e
nome da função, seguido pelos tipos de seus parâmetros. Um exemplo de declaração
da função protótipo é dado abaixo:
float Circunferencia(float raio);
O nome dos parâmetros são opcionais, e podem ser evitados como:
float Circunferencia(float);
No seguinte código se mostra como o programa do exemplo anterior pode ser

modificado para usar as funções protótipo. Aqui, as funções protótipos são declaradas
antes do programa principal, e as duas funções são declaradas depois do programa
principal.
//funções Prototipo
//
float Cyl_Area(float, float);
float Cyl_Volume(float, float);
//
//
void main()
{
float r, h, c_area, c_volume;
r = 3.0; // O raio
h = 12.5; // a altura
c_area = Cyl_Area(r, h); // Calcula a area
c_volume = Cyl_Volume(r, h); // Calcula o volume
}
//
// Esta função calcula a area de um cilindro
//
float Cyl_Area(float raio, float altura)
{
float c;
c = 2*PI*raio*altura;
return c;
}
//
// Esta função calcula o volume de um cilindro
//
float Cyl_Volume(float raio, float altura)
{
float c;
c = PI*raio*raio*altura;
return c;
}
5.11.2 Funções void

A função void é uma onde a palavra void aparece como o especificador tipo da função,
para indicar que a função não retorna nenhum valor para o programa. Similarmente,
uma função sem parâmetros é especificada usando a palavra void em sua lista de
parâmetros. Tal função é chamada sem parâmetros. Um exemplo de função void é
Página 61 de 63
mostrado a seguir, o qual simplesmente configura todos os pinos de saída da porta B

em nível Alto. Esta função não tem parâmetros e não retorna nenhum dado.
void SET_LED(void)
{
PORTB = 0xFF;
}
5.11.3 Passando Parâmetros para as Funções

É importante frisar que sempre que uma função é chamada com parâmetros, todos
esses parâmetros são passados para a função por valor. Isto significa que os valores
destes parâmetros são copiados para a função e usados localmente pela função. Os
valores desses parâmetros não podem ser modificados pela função. Um simples
exemplo é dado para clarificar este conceito.
float Inc(float x)
{
x++;
return x;
}
//
//
void main()
{
float a, b;
a = 5.0; // a = 5.0
b = Inc(a); // a = 5.0, b = 6.0
}
Neste exemplo, o valor do parâmetro da função (a) foi 5 antes de ser chamado pela
função. Dentro da função, a cópia local deste parâmetro é incrementado para 6, mas o
valor deste parâmetro ainda é 5 no programa principal. Qunado a função retorna, a
variável b recebe o valor de 6.
5.11.4 Passando Arrays para as Funções

Em algumas aplicações, desejamos passar arrays para as funções. Passando um único
elemento de um array é fácil. Tudo o que temos que fazer é indexar o elemento que
desejamos passar. Como descrito na seção prévia, uma variável é passada para uma
função como um valor. Por exemplo, para passar o índice 5 do array MyArray para a
função chamada Sum e armazena o valor retornado em a, simplesmente se escreve:
a = Sum(MyArray[5]);
Passando um array complete para uma função é ligeiramente mais complicado. Aqui,
simplesmente escrevemos o nome do array na chamada do programa. No cabeçalho
da função temos que declarar um array com o mesmo tipo seguido de um colchete
vazio. É importante frisar que não se está copiando o array inteiro para a função, mas
simplesmente passando o endereço do primeiro elemento do array, o qual é igual ao
nome do array. Porque o endereço é passado para a função, os elementos do array são
passados por referência. Como um resultado, os elementos do array original podem
ser modificados dentro da função. Um exemplo é dado abaixo, para ilustrar o
processo.
Página 62 de 63
Exemplo: Escrever um programa para carregar um array inteiro chamado N com

valores de 1 a 10. Então chamar uma função para calcular a soma dos elementos
do array e retornar a soma para o programa.
Solução: Um array inteiro N é inicializado com valores de 1 a 10 no programa
principal. Então, a função Sum é chamada e o array é passado para esta função.
A função calcula a soma dos elementos do array e retorna a soma na variável s
no programa principal. Notar que o array é chamado N no programa principal,
mas A na função.
//
// Esta função calcula a soma dos elementos de um array.
//
int Sum(int A[ ])
{
char i;
int Total = 0;
for(i = 0; i < 10; i++) Total = Total + A[i];
return Total;
}
//
// Programa Principal
//
void main()
{
int s, N[10];
char i;
for(i = 0; i < 10; i++) N[i] = i + 1; // Inicializa array N
s = Sum(N); // Calcula a soma dos elementos.
}
EXERCÍCIOS COM FUNÇÕES
Página 63 de 63

Idioma

Aprenda Linguagem C Básico para Microcontroladores - v1

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Aprenda Linguagem C Básico para Microcontroladores - v1

Enviado por

Direitos autorais:

Formatos disponíveis

Aprenda Linguagem C Básico

para Microcontroladores PIC

Antonio Ramirez Hidalgo

CAPÍTULO 1. MICROCONTROLADOR PIC16F887 ........................................................................... 8

5.9.3. Instruções if-else-if .................................................................................................... 53

CAPÍTULO 1. MICROCONTROLADOR PIC16F887

Neste capítulo se apresenta uma revisão sucinta do microcontrolador PIC16F887,

1. Características básicas do PIC16F887

o Suporta RS-485, RS-232 e LIN2.0

Figura 1. Pinos do microcontrolador PIC16F887 e encapsulado DIP-40

Figura 2. Diagrama em blocos do microcontrolador PIC16F887

1.1. Alimentação de um PIC16F887

Normalmente o microcontrolador PIC16F887 alimenta-se com 5 V aplicados

Figura 3. Circuito de alimentação do microcontrolador PIC16F887. Este também pode

1.2. Portas de entrada/saída.

O microcontrolador comunica-se com o mundo exterior através das portas.

Tabela 1. Pinos do microcontrolador PIC16F887

Figura 4. Pinos do microcontrolador PIC16F887

CAPÍTULO 2. PERIFÉRICOS BÁSICOS

Apesar do fato de que o microcontrolador é um produto de tecnologia moderna,

2.1. Diodo Led

O diodo LED é um dispositivo que permite comprobar o funcionamento dos

Figura 5. Diferentes modelos de diodos LEDs.

Figura 6. Partes do diodo LED e como polarizar este.

O microcontrolador PIC é capaz de governar diretamente os diodos LEDs de duas

O resistor limita o valor da corrente a um valor adequado para iluminar o LED.

Figura 7. Formas de conectar um LED a um microcontrolador

Os LEDs também podem ser encontrados encapsulados em barras de 8 ou 10

a) Parte interna b) Aspecto Físico

2.2. Chaves e Teclas (Switches and push buttons)

Estes dispositivos permitem introduzir um nível lógico “0” ou “1” quando se

Figura 9. Chaves e Teclas

Figura 10. Níveis de tensão ideais de uma chave e uma tecla.

Figura 11. Trepidação em uma chave

2.3. Entradas digitais com optoacoplador

Em alguns projetos é necessário utilizar sinais de entrada de alta tensão ou sinais

Figura 12. Controle de uma entrada com um optoacoplador 4N25

O 4N25 é um optoacoplador popular, dentro do encapsulamento DIL-6 está um led e

RIN = (VIN – 1,2) / 5mA = (24V – 1,2V) / 5mA = 4,56 K

O LED suporta uma tensão máxima inversa de 3 v. Para aplicações em corrente

2.4. Display de sete segmentos

Figura 13. Display de sete segmentos

Figura 14. Conexão do display de sete segmentos como microcontrolador

2.5. Controle com relés

Um relé é um interruptor elétrico que abre e fecha sob o controle de outro

Figura 15. Conexão do relé a dispositivos de potência

Figura 16. Governo de uma carga potência com relé

Quando a saída do microcontrolador (µC) fornece um nível alto à base do

Figura 17. Driver ULN2003 e governo de vários relés

Para cargas de até 10 W é melhor utilizar relés de láminas encapsulados em DIL,

Em muitos projetos é necessário indicar mediante um sinal audível a ocorrência

Buzzer emite som

Figura 20. Conexão do Buzzer a um microcontrolador

CAPÍTULO 3. PRINCIPIOS BÁSICOS DO PROTEUS

PROTEUS é uma ferramenta de software que permite a simulação de circuitos

3.1. Montagem de circuitos com PROTEUS VSM

Figura 21. Ambiente ISIS do PROTEUS

ISIS é o ambiente de trabalho do PROTEUS. Aqui se projetam, desenham e simulam os

Components. Representam todos os cmponentes eletrônicos presentes em um

Simulation Graphs. Para visualizar os resultados da simulação em gráficos, no

O painel da parte esquerda do ambiente ISIS que na Figura 21 se vê com o título de

3.2. Desenhando o Circuito

Com o circuito minimamente montado e com o programa do PIC (.COF, .HEX ou