LINGUAGEM C PARA MICROCONTROLADORES PIC
ANDERSON VICENTE BURACOV
PROGRAMAÇÃO DE MICROCONTROLADORES PIC
BASEADO NO PIC 16F628A
Módulo Básico 1
Piracicaba
2013
SUMÁRIO INTRODUÇÃO .............................................................................................................. 01 1 - Os Microcontroladores ......................................................................................... 02 2- Arquitetura Harvard e a tradicional ...................................................................... 06 2.1- Arquitetura Harvard .............................................................................................. 07 3 - Microcontrolador PIC 16F628a ............................................................................. 08 3.1- Alimentação do PIC .............................................................................................. 08 3.2- Devices Flags ........................................................................................................ 08 4 - PORTA E PORTB ................................................................................................. 13 5 - Características Principais ..................................................................................... 14 6 - Introdução à linguagem C .................................................................................... 17 7 - Controle de Fluxo ................................................................................................. 17 8 - Introdução ao Mikro C ........................................................................................... 25 8.1 -Escrevendo programas em C ................................................................................ 25 8.2 -O papel do Compilador ....................................................................................... 26 8.3 -Edição e Compilação ............................................................................................ 27 8.4 -O Programa Compilado......................................................................................... 28 8.5 -Gravação do Programa no PIC ............................................................................. 28 8.6 -Criação de um projeto no Mikro C ......................................................................... 28 8.7 -Conhecendo o Ambiente Mikro C ......................................................................... 30 8.8 -Code Editor ( Editor de Código) ........................................................................... 31 8.9 – Mesages Window ( Janela de mensagens) ......................................................... 32 8.10-Project Setup ........................................................................................................ 32 9 -Primeiro Projeto ................................................................................................ 36 10 - Funções ................................................................................................................ 39 10.1-Acionamento de botões utilizando o IF ................................................................. 40 10.2-Else ....................................................................................................................... 40 10.3-Função Button ...................................................................................................... 40 11 – REFERÊNCIAS ..................................................................................................... 40
1
INTRODUÇÃO
Esta pequena apostila esta orientada para os profissionais que
necessitam de conhecimentos básicos do PIC. Abordaremos noções da estrutura do
PIC16F628A e depois nosso foco será o estudo da linguagem C para
microcontroladores.
A linguagem C provavelmente é a linguagem mais conhecida e tem
muitas vantagens sobre a linguagem assembler no nível técnico.
Primeiramente trataremos sobre a instalação dos programas necessários
para poder trabalhar.
Existe no mercado vários compiladores para desenvolvimento de
programas na linguagem C como Hi-Tech, CCS, PICmicro C, etc. Adotamos para
nosso treinamento o compilador MikroC da Microelektronika por ser uma ferramenta
bastante poderosa e fácil de trabalhar (permite Editar, Simular e Compilar programas
das famílias 12, 16 e 18 da Microchip) além de também possuir uma vasta biblioteca
de controle de periféricos dos Microcontroladores. Além disso, a versão estudante é
gratuito para desenvolvimento de programas de até 2Kwords( 2mil palavras) , o que
torna bastante atraente também para uso educacional.
Pode-se fazer download em www.mikroe.com.
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
preocupar-se apenas com o programa em si e o compilador traduz da Linguagem C
para a Linguagem de máquina hexadecimal (.HEX) que é a linguagem que os
Microcontroladores,conseguem,entender.
2
1- OS MICROCONTROLADORES
Os principais fabricantes de microcontroladores disponíveis no mercado
são descritos a seguir:
Atmel: - Família AVR, 8051
Microchip - Família PIC
Freescale (Motorola) - Família HS908
NXP (Phlips) - Família ARM (LPC)
Texas Instruments - Família MSP, TMS e C2000
Zilog - Família F8
National - Família COP
Cypress - Família PSOC
Intel - Família 8051, 8052, 8096
Analog Device - Família ADuc
... etc.
Os Microcontroladores são chips inteligentes que têm pinos de entradas e
saídas que são utilizadas para controlar equipamentos e ou dispositivos.
Através de programação, estas entradas e saídas são conectadas ao
mundo exterior através de sensores e atuadores controlando máquinas ou sistemas.
3
O PIC é produzido pela Microchip technology Inc
(http://www.microchip.com).
PIC origina-se de Programmable Integrated Circuit (Circuito Integrado
Programável).
Estes circuitos integrados estão cada dia mais barato e poderosos,
contendo internamente circuitos de processamento, memórias PROM
(Programmable Read Only Memory – memória programável somente de leitura) ,
Memórias RAM (Random Access Memory – memória de acesso aleatório),
EEPROM (Electrical Eraseble Programmable Read Only Memory – Memória
somente de leitura regravável eletronicamente) memória Flash (mesma que a
EEPROM), circuitos contadores, circuitos comparadores, conversores
analógico/digital (ADC) conversores digital/analógico (DAC), etc.
Existem basicamente 03 famílias diferenciadas pelo tamanho de palavra
de memória de programa: são as famílias 12, 14 e 16 bits onde, todos os
dispositivos possuem barramento de dados de 8 bits.
Recentemente a Microchip inseriu no mercado a nova família DsPIC com
memória de programa de 16 bits , 24 bits e futuramente 32 bits para barramento de
dados.
Trabalharemos com o PIC de 18 pinos, PIC 16F628A operando com
Clock de 4MHz o que implica em 1MIPS (1 milhão de instruções por segundo).
O PIC PIC16F628A operam com Clock de 20MHz o que implica em
5MIPS (5 milhões de instruções por segundo).
Os Microcontroladores da Série 12, 14 e 16 possuem memória interna e
os da série 17 e 18 podem funcionar também com Memória de Programa externa.
Existem 4 tipos de tecnologias na fabricação das Memórias de Programa dos PICs:
ROM tipo Máscara: Chips programados de fábrica – viáveis para grandes quantidades e são identificados com o prefixo “CR”.
OTP: são Memórias de Programa tipo PROM onde, sai de fábrica “virgem” e permite uma única gravação. Estes dispositivos são identificados pelo sufixo “C”.
EPROM: são indicados para etapas de desenvolvimento e são identificados pela janela de vidro característica das EPROMs. Utilizam sufixo “JW” ou “CL”.
4
FLASH: são os mais indicados tanto para desenvolvimento como implantação final. Permitem mais de 1000 ciclos de gravação/apagamento. São identificados pelo prefixo “F”.
Hoje, os Microcontroladores são uma revolução na eletrônica assim como
ocorreu quando foram introduzidos os primeiros Amplificadores Operacionais.
Antigamente, para se fazer um amplificador transistorizado com ganho 4
por exemplo, era necessário realizar várias contas para polarizar o transistor,
estudar parâmetros do transistor, etc; com a chegada dos famosos Amp. Ops, tudo
isto ficou muito fácil, sem falar de todas as outras funções que os Amplificadores
Operacionais oferecem como somador, diferenciador, integrador, filtros, etc...
Os Microcontroladores invadiram os equipamentos eletrônicos onde,
podemos encontrá-los em vários eletrodomésticos como máquinas de lavar, micro-
ondas, aparelhos de som e imagem, etc. Sem falar no seguimento automobilístico
sendo usado em sistema de injeção eletrônica, alarme, controle de temperatura,
automação de vidros e fechaduras, etc.
Devido a esta expansão dos sistemas Microcontroladores, hoje é mais
que uma necessidade de técnicos e engenheiros saberem como funcionam e como
tirar proveito do seu potencial.
Principalmente para a área de desenvolvimento e projetos, pois as
vantagens são realmente muito atraentes. Começando pelo custo - PIC 16F628a por
exemplo custa aproximadamente R$8,00 e tem um poder de processamento
excelente para um clock de 4MHz ( 1.000.000 de instruções por segundo) Caramba!!
Escolhemos para este curso de PIC o modelo 16F628A. Esta escolha
está relacionada com a facilidade de encontrá-lo no mercado, baixo custo, facilidade
de manuseio e compatibilidade entre os modelos de 18 pinos.
Abaixo, temos a foto do PIC 16F628a e, como pode-se observar, parece
como qualquer circuito integrado comum, porém, vamos descrever agora o que ele
apresenta internamente:
5
Vista geral do PIC 16F628a
- CPU (Unidade Central de processamento) que é a responsável por
gerenciar todas as funções e decisões referente a programação.
- Possui uma ULA (Unidade lógica e Aritmética) que é a responsável por
desenvolver operações de soma, subtração, deslocamento de bits, etc).
1024 posições de memória x 14 bits
124 posições x 8 bits de RAM
64 posições x 8 bits de EEPROM
13 pinos de entrada/saída (configuráveis)
1 Timer / Contador de 8 bits
No decorrer do curso vamos entrar em mais detalhes, importante agora é
se ter em mente que o Microcontrolador é um Circuito Integrado composto de vários
Circuitos Lógicos que nos ajudarão bastante em desenvolvimentos de circuitos
eletrônicos e controle de processos ou sistemas.
Vejamos um exemplo de aplicação:
Digamos que temos interesse em fazer um contador de pulsos crescente
onde o mesmo fará a contagem de 0000 a 9999. Utilizando-se de componentes
discretos, a princípio precisaremos de contadores, decodificadores para display, etc.
Imagine que este circuito foi projetado e em determinado momento deseja-se
modificar o projeto para fazer a contagem de 0000 até 0750. Puxa, teria que se
desenvolver outro Hardware ou adaptá-lo dificultando bastante o desenvolvimento.
Agora, se no projeto utilizamos Microcontroladores, isto pode ser implantado
modificando-se apenas o Software pois o Hardware poderá ser mantido. Isto ajuda
6
bastante os desenvolvedores de sistemas pois um mesmo circuito pode receber
modificações e melhorias modificando apenas o software.
Esse é apenas um exemplo que apresenta algumas vantagens de se
utilizar circuitos Microcontrolados. Observa-se com isso como diminui o trabalho
oneroso de desenvolver circuitos discretos ganhando tempo também de
desenvolvimento e deixando também margem para futuras melhorias ou ajustes do
circuito. Outro exemplo poderia citar uma aplicação automotiva. Desenvolvido um
circuito de controle para determinado modelo de automóvel, para outro modelo
mudaria apenas os parâmetros via software (Ex: controle de
injeção de combustível do Gol 1.0 para o Gol 1.6) – O circuito seria o
mesmo só mudaria a programação entre os modelos do Gol. Observou a grande
vantagem disso?
Os Microcontroladores são encontrados em vários tamanhos e
capacidades onde o projetista deverá determinar qual utilizar em seu respectivo
projeto. Eles variam desde 8 pinos (PIC12Cxx) passando pelos 18 pinos
(PIC16Fxxx) indo até 40 pinos (PIC18Fxxx).
Existem muitos modelos de PIC onde cada um tem suas características
peculiares como número de I/Os (entradas/saídas), conversores A/D, Contadores,
timers, memória, etc.
2- ARQUITETURA HARVARD E A TRADICIONAL
A Arquitetura Tradicional de Computadores e Microprocessadores se
baseia no esquema proposto por John Von Newman, no qual a CPU (Unidade
Central de Processamento) está conectada a uma única memória que contém as
Instruções de Programas e os Dados. Com isso, temos um único barramento para o
tráfego de Dados e Instruções o que limita a velocidade de operação do
Microprocessador.
Outro fator importante é que esta configuração trabalha com a filosofia
CISC (Complex Intruction Set Computer – Computador com Set de Instruções
complexos). Sendo assim, temos centenas de comandos para trabalhar a
programação. O Microcontrolador 8051 trabalha com esta filosofia e possui 115
Instruções.
7
Abaixo temos o Diagrama da Arquitetura Von Newman:
Arquitetura Von Newmann
2.1- ARQUITETURA HARVARD
Consiste simplesmente na separação do barramento de Dados e
Instruções. Uma das memórias possui somente Instruções de programa e é
chamada de Memória de programa.
A outra Memória é responsável pelo armazenamento dos Dados e por
isso chama-se memória de Dados.
Arquitetura Harvard
Um Processador com Set de Instruções reduzido (RISC – Reduced Set
Instruction Computer) contém então barramentos diferentes como 12 ou 14 bits para
Instruções e 8 bits para Dados. Os Microcontroladores PIC trabalham com esta
Filosofia e possuem em média 35 Instruções, o que facilita bastante o entendimento
e o desenvolvimento. Muitos acham isso ruim pois como o número de instruções é
pequeno, precisa-se criar muitas funções que
na Filosofia CISC já está pronta.
8
3- MICROCONTROLADOR PIC16F628A
3.1- ALIMENTAÇÃO DO PIC
Esta também é uma questão que requer certa atenção. Importante é não
termos uma fonte com muita variação (riplle) e ruidosa. Como a alimentação pode
estar entre 3,0 a 5,5V, sugiro que seja utilizado o Circuito Integrado Regulador de
Tensão 7805 que garante uma excelente regulagem em 5,0V.
3.2- DEVICE FLAGS
Fusíveis ou bits de configuração, é o local onde podemos configurar várias funções
através de bits de configuração.
Funções estas que podem ser tipo de oscilador, habilitar WatchDog, Código de
proteção, etc.
Clock:
Vamos inicialmente falar do Clock. Todo Microcontrolador necessita de
um circuito gerador de Clock. O Clock é quem dá todo o sincronismo para os
circuitos internos. Pode ser comparado ao Coração humano. Abaixo temos a
configuração utilizando oscilador a Cristal.
Neste caso temos um Oscilador XT. Sem dúvida esta é a melhor opção
pois a estabilidade dos cristais são excelentes.
9
Note que existe dois capacitores ligados em paralelo com o cristal. O valor
desses capacitores variam de acordo com a freqüência do cristal utilizado. Abaixo
segue uma tabela apresentando os valores dos capacitores:
Tipo de
oscilador
Freqüência do cristal
Valores típicos para o capacitor
C1 C2
LP (cristal de baixa
freqüência)
32kHz 33pF
33pF
200KHz 15pF 15pF
XT (cristal)
200KHz 22-68pF 22-68pF
1.0MHz
15pF
15pF
4.0Mhz
15pF 15pF
HS (cristal de alta
freqüência)
4.0MHz
15pF 15pF
8.0 MHz 15-33pF 15-33pF
20.0MHz 15-33pF 15-33pF
25MHz 15-33pF 15-33pF
cristal de quartzo
Ressonador Cerâmico
10
Podemos também utilizar os osciladores internos do PIC para fazer a
função de oscilação.
Este oscilador interno é do tipo RC e possui uma precisão razoável entre
1 e 5% com clock típico de 4MHz.
Vale ressaltar que quando não utilizamos o Clock interno, ganhamos em
precisão mas em compensação perdemos 1 ou 2 pinos de I/O (entrada/saída).
Realmente tudo tem um preço! Você terá que decidir por isso na definição
do seu projeto.
Sinal de clock
Vale lembrar que para cada 4 ciclos de Clock temos um ciclo de instrução,
para os oscilador de 4MHz, temos 1MHz de ciclo de instrução:
-ciclo de instrução = Fosc/4
-Tempo de instrução = 1/Ciclo de instrução.
Exemplo:
Para um cristal de 20MHz temos:
Ciclo de instrução = 5MHz
Tempo de instrução = 200ns = 0,0000002 segundos para fazer uma instrução.
Rapidinho não acha?
Pwrten: (system clock switch bit)
É o temporizador de Power-Up que faz o microcontrolador aguardar certo tempo
assim que o chip é energizado. Este tempo é de 72ms deixando assim o
microcontrolador inoperante, tempo ideal para que o circuito oscilador estabilize sua
freqüência.
11
Uma maneira bem simples para garantir este tempo é colocar o pino 4
(MCLR – Master Clear on Reset) em nível “um” – conectando-o ao VCC (+5V) ,
através de um resistor com um valor entre 5K e 10K .
Brow-out: detector
É um interessante circuito para resetar o Microcontrolador caso ocorra uma queda
de tensão no mesmo. Restabelecido a tensão, o programa é reiniciado. Podemos
escolher os seguintes limites de tensão: 2,0V, 2,7V, 4,2V ou 4,5V.
Boren:
Este bit é responsável por habilitar/desabilitar o Brown-out.
Wdt: Watchdog Timer Enable
Aqui temos um recurso bastante interessante. Um temporizador de 8 bits que não
pode estourar pois caso isso ocorra o programa será resetado. Imagina que por
algum motivo
o programa trava ou entra em algum loop infinito. A função do watchdog é não
deixar o programa travado.
Lvp: (low voltage programming)
Temos aqui uma opção de poder gravar o Microcontrolador com 5V. O usual é
colocar tensão de 13,5V no pino MCLR. Portanto, é possível deixar o MCLR em 5V e
fazer a gravação mas, o pino RB4 não poderá mais ser utilizado como I/O.
12
Stvren: (Stack Full / Underflow Reset Enable Bit)
O Microcontrolador 16F628a possui 8 endereços de pilha. Este bit serve para
habilitar o chip para ser resetado caso a limite da pilha seja ultrapassado.
A pilha ( Stack) nada mais é que uma memória RAM com algumas localidades,
dentro do PIC 16F628a uma subrotina pode ser chamada no máximo 8 vezes, se o
limite for ultrapassado a memória da pilha fica cheia fazendo o PIC travar.
Code Protect : (CP Código de proteção)
Habilitando este bit, a região de memória fica protegida contra leitura, ficando
impossível de ler o que tem dentro do PIC.
Reset: Resetar o PIC significa colocá-lo no início da programação novamente. As vezes
isso é feito pelo usuário porém, isso pode acontecer também quando ocorrer uma
interrupção. O importante é que quando acontecer um Reset, já está pré-definido o
que o PIC deve fazer.
Existem várias maneiras de Resetar o Microcontrolador:
Reset no instante em que o PIC é alimentado.
Reset quando o pino 4 (MCLR) é colocado em nível zero.
Reset colocando o PIC no modo de economia – instrução Sleep.
Reset quando Whatchdog (WDT) “ transborda” - muda de FF para 00.
Precisamos aqui ressaltar que quando ocorre um Reset, o importante é que o PC
(Program Counter – Contador de Programa) aponte para a posição inicial 0000 e
que todos os Registros (memória RAM) não são alterados. Porém, os SFRs (Special
Function Registers Registradores de Funções Especiais), estes sim são reiniciados
com um valor inicial pré determinado.
13
4.0- PORTA e PORTB (entradas e saídas)
São responsáveis por trabalharem com o mundo exterior, ou seja, são por
eles que recebemos sinais de sensores, chaves, teclados e também por eles que
atuamos relés, solenóides, acopladores ópticos, transistores, etc. Eles que fazem a
interface para acionarmos lâmpadas, sirenes, motores, leds, displays de cristal
líquido, etc.
Vale lembrar aqui que o sinal de saída de cada porta é limitado e, no
entanto, não podemos simplesmente ligar um relé ou um contator diretamente no
pino do PIC. Precisamos muitas vezes fazer um driver para poder drenar uma certa
intensidade de corrente. Mas, isto será analisado em outra oportunidade, o
importante no momento é saber que são por estas portas bidirecionais onde faremos
toda comunicação para enviar e receber dados.
Pelo PORTA temos 5 pinos de controle e pelo PORTB temos 8 pinos.
Para definirmos cada pino para direção do PORTA utilizamos o Registro
TRISA e para o PORTB utilizamos do Registro TRISB.
A direção do fluxo de dados será 0 para saída (OUTPUT) e 1 para
entrada (INPUT).
Mais adiante trabalharemos melhor este detalhe onde iremos definir quais
pinos serão entrada e quais dos pinos serão definidos como saída de dados.
Abaixo temos um exemplo de circuito utilizando PIC
14
Acredito que as principais informações foram analisadas e já podemos
começar a estudar os Microcontroladores 16F628a. Vamos então verificar
inicialmente suas características .
5.0- CARACTERÍSTICAS PRINCIPAIS
O Microcontrolador PIC 16F628A pode operar até 20MHz
- 2K (2048) palavras de 14 bits para programas;
- 224 bytes de RAM para uso geral;
- 128 bytes de EEPROM para dados;
- Stack com 8 níveis;
- Oscilador 4MHz / 37KHz interno;
- Apenas 35 instruções;
- 15 Registros específicos em RAM para controle interno e externo;
- 1 Timer 8 bits;
- 1 Timer / contador de 8 bits;
- 1 Timer / Contador de 16 bits;
- 1 canal PWM com captura e amostragem (CCP);
- 1 canal de Comunicação Serial;
- 2 Comparadores Analógicos com referência interna programável de tensão;
- 16 pinos com flexibilidade de operar como entrada ou saída;
- Intensidade de corrente nos PORTs de 25mA por saída;
- Capacidade de gerenciar interrupções;
- Watch Dog para recuperar travamentos no software;
- Memória de programa com proteção contra cópias;
- Modo Sleep para economia de energia;
- Várias opções de osciladores (interno/externo);
- Alimentação 3V a 5,5V – Típico de 5V;
- Consumo menor que 2mA em 5V a 4MHz.
- Compatível com 16F84 e outros PICs de 18 pinos.
15
16
17
6.0- INTRODUÇÃO À LINGUAGEM C
Estrutura Básica de um programa:
Programas em C são baseados em uma ou mais funções que serão executadas, no
entanto, a função Main() é a primeira a ser executada.
/* -------------------------------------------------
abaixo temos um exemplo de estrutura
Básica de um programa em Linguagem C
----------------------------------------------------- */
Main() // esta é a primeira função que será executada
{ // inicializa a função
Trisb=0x00; // aqui entram os comandos que serão executados
Portb=0xFF;
} // finaliza a função
Observações:
Toda função deve iniciar abrindo chave e finalizar fechando-se a chave.
Toda instrução deve ser finalizada com ponto e vírgula (obrigatoriamente)
Logo após /* são inseridos os comentários para múltiplas linhas e deve-se
Colocar */ para fechar o bloco de comentários.
Utilizamos // para comentários em apenas uma linha.
Representação Numérica: Decimal: Contador=125; Binário: Portb=0b11010011; Hexadecimal: Variável1=0xA4; Octal: Teste=075; String: Unsigned char *texto=”Piracicaba-SP”
18
Caracter:
Usart_write(„&‟);
Dado: Tipo:
int Números inteiros
char Caracteres
float e double Números decimais (ponto flutuante)
void valores nulos
Modificadores:
19
Declaração de variáveis:
Podemos declarar da seguinte maneira:
<qualificador> + <tipo> + <nome da variável> + <valor>;
Obs: valor pode ou não necessariamente ser inicializado.
Exemplos:
int contador;
short var1;
unsigned int contagem = 30500;
Observe agora como atribuir valores às variáveis:
Contador = 10; // atribui o valor 10 à variável contador
Var1 = 25; // atribui o valor 25 à variável Var1
Variável local: Esta é declarada dentro da função e só pode ser utilizada pela função portanto, é
uma variável temporária.
Exemplo:
Void subrotina_soma ()
{
Unsigned Int valor1, valor2;
Valor1=A;
Valor2=B;
Return(valor1+valor2);
}
Variável Global: Esta é declarada fora da função e só pode ser utilizada por qualquer função em
qualquer momento. Todas as funções têm acesso às variáveis globais.
20
Exemplo:
unsigned int valor1, valor 2
Void subrotina_soma ()
{
Valor1=A;
Valor2=B;
Return(valor1+valor2);
}
Operadores Matemáticos: Aritméticos:
Relacionais:
Lógicos:
21
Operadores bit a bit:
7- CONTROLE DE FLUXO
DELAY: ( Atraso de tempo)
Comando de atraso de tempo, ou contagem de tempo de uma maneira bem simples.
Exemplo:
Delay_ms(500); // Atraso de tempo de ½ segundo.
Delay_us(500); // Atraso de tempo de 500 microsegundos.
DECISÃO IF: // A decisão IF é a mesma coisa da pergunta: “Se” ?
Sintaxe: if (expressão) comando;
A expressão é avaliada e se for verdadeiro executa o comando.
Podemos ter também mais que um comando:
Sintaxe if (expressão)
{
comando1;
comando2;
comandoN;
}
Exemplo:
If (conta == 5) // “Se” a conta for igual a 5
{
a=a++; //Soma na variável “a”
22
portb=0xFF; //e coloca todo portb nível alto
}
DECISÃO IF-ELSE:
Sintaxe: if (expressão) comando1;
else comando2;
Neste caso, temos duas possibilidades. Se comando for verdadeiro, comando1 é
executado, caso seja falso, comando2 será executado.
Podemos ter também vários comandos:
if (expressão)
{
comando1;
comando2;
comando3;
}
else
{
comando4;
comando5;
}
Exemplo:
if (a>22) // Se „a‟ for maior que o numero 22
{
Valor1=x; //O valor1 será igual a „x‟
y=contador+10; //e y soma 10 no contador
}
Else //Senão
{
Valor2=x; // O valor 2 é que será igual a „x‟
Y=contador-5; // e „y‟ vai decremantar 5 no contador
}
23
LOOP FOR:
Este é um comando de laço (loop ou repetição).
Sintaxe:
for (inicialização; condição (término); incremento) comando;
Podemos também ter um bloco de comandos:
For (inicialização; condição (término); incremento)
{
comando1;
comando2;
comandoN;
}
Exemplo:
void main ()
{
int contador;
int a = 0;
for (contador=0; contador<=10; contador++) a=a+contador;
}
LOOP WHILE:
Neste caso, o loop é repetido enquanto a expressão for verdadeira.
Sintaxe:
while (expressão)
{
comando1;
comando2;
}
É feita a avaliação no início do loop e, enquanto verdadeira, os comandos serão
executados. Ao término do último comando, volta a ser testada a expressão e caso
seja
falsa, o loop é finalizado.
24
Exemplo:
void main( )
{
int a=15;
While (a>10)
{
a--;
delay_ms(100);
}
}
LOOP DO - WHILE:
Neste caso, diferente do loop anterior (while), o do - while executa pelo menos uma
vez o bloco de comando antes de fazer a avaliação se continua a executar os
comandos ou sai do loop.
Sintaxe:
do
{
comando1;
comando2;
}
while (expressão);
Exemplo:
void main( )
{
int a=0;
do
{
a++;
delay_ms(100);
25
}
while (a<100);
}
8- INTRODUÇÃO AO MIKRO C
O MikroC é um compilador desenvolvido e também comercializado pela
empresa MikroElektroniKa. É composto de um IDE (Sistema Integrado de
Desenvolvimento) abrangendo toda a linha dos PICs das famílias 12,14,16 e 18 da
Microchip.
Este Software pode ser baixado no site www.mikroe.com e sua versão
free possui limite de 2K words. Caso ultrapasse este valor, é necessário adquirir a
versão full junto ao fabricante.
8.1- ESCREVENDO PROGRAMAS EM C
Devido a sua qualidade, portabilidade, eficiência e controle , o C,
podemos dizer, é a linguagem mais utilizada por programadores de
microcontroladores. Atualmente, a maioria dos microcontroladores existentes no
mercado contam com compiladores de linguagem C para o desenvolvimento de
programas.
Quanto estamos tratando de programas para microcontroladores,
devemos tomar certos cuidados com relação a escolha da linguagem de
programação e do compilador a ser utilizada, pois a capacidade de memória de
armazenamento do programa é extremamente reduzida, comparando com PC.
Programa escrito em linguagem C
26
Sabemos que hoje temos computadores portáteis com capacidades de
centenas de gigabytes de memória, nesses aspectos o "tamanho" do código não é
tão importante para o programador.
Agora, quando estamos falando de microcontroladores devemos tomar
certas preocausões, pois microcontroladores como: PIC12C508 e PIC16C54
possuem apenas 512byte de memória de programa e 25 byte de RAM, fato que
exige do programador otimização do código e eficiência na elaboração lógico do
programa.
8.2- O PAPEL DO COMPILADOR
A única maneira de se comunicar com o microcontrolador é através da
linguagem de máquina, ou melhor dizendo, através de códigos de máquinas. Por
tanto os programas em C devem necessariamente serem interpretados e compilados
a fim de termos como resultado os comandos de máquinas a serem gravados na
memória de programa do microcontrolador.
Existem no mercado diversos compiladores de programas em C para
microcontroladores PIC, tais como: HI-TECH PICC, C18, C30, CCS, SDCC, WIZ-C,
mikroC, CC5, PICmicro C, entre outros.
Em nosso curso iremos utilizar a IDE MikroC desenvolvido pela empresa
Mikroelektronika (www.mikroe.com), no qual permite editar, compilar e simular
programas em C para microcontroladores PIC da familia 12, 16 e 18.
IDE mikroC - Editor, compilador, simulador e debugador para PIC em linguagem C
27
Iremos utilizar o mikroc devido a sua eficiência e flexibilidade. Além disso,
este compilador possui uma extensa biblioteca de funções prontas para controle de
diversas periféricos conectados ao nosso microcontrolador PIC.
Aos escrevermos e compilarmos um programa em nosso compilador,
caso o programa não tenha erros de sintaxe, ou algum outro erro cometido pelo
programador, teremos como resultado a criação do arquivo de máquina hexadecimal
(extensão .hex). Este arquivo .hex é conhecido como código de máquina, e será
este o arquivo a ser gravado na memória do microcontrolador.
8.3- EDIÇÃO E COMPILAÇÃO DO PROGRAMA EM C
A partir das informações e funções elaborada no fluxograma, escreva seu
programa em linguagem C na IDE mikroC, compile e simule seu programa
(estudaremos detalhadamente cada função e ferramenta do mikroC mais adiante).
8.4- O PROGRAMA COMPILADO
Após a compilação do seu programa em C, o compilador criará o arquivo
de máquina .hex (nomedoprograma.hex). Este é o arquivo que deverá ser gravado
no microcontrolador PIC.
28
8.5- GRAVAÇÃO DO PROGRAMA NO PIC
Gravar o arquivo compilado .hex no microcontrolador através de um
gravador de microcontroladores PIC, ou através de um Kit de desenvolvimento.
Estudaremos com mais detalhes nas unidades seguintes do nosso curso
os processos de edição, compilação e gravação de programas.
8.6- Criação de um projeto no mikroC
Para criarmos uma aplicações no mikroC é muito fácil, acompanhe o modelo passo
a passo:
Abra o mikroC e vá ao menu Project > New Project. A tela seguinte aparece:
29
Figura 02 - criação de um projeto no mikroC
>> Em
Project Name digite o nome do seu projeto, em Project Path. Todos os arquivos de
saída (list, hex, ASM) terão o mesmo nome do campo Project Name.
Nota: Não crie projetos com nomes com acentuação, caracteres especiais, espaços
entre caracteres, e nomes reservados pelo compilador, como por exemplo: Button.
30
>> Em Description
Flag, ajuste os configurantions bits do microcontrolador, que informam como o
microcontrolador deve operar. Com ele é possível alterar o tipo de oscilador utilizado
pelo projeto, assim como se vai usar o watchdog ou acionar a proteção contra leitura
do chip. Esses bits são conhecidos como "fusíveis".
Description é opcional. Neste campo podemos descrever de forma resumida o
funcionamento de nosso projeto, assim como colocar versões ou informações
adcionais que o programador ache necessário.
>> Em Device podemos selecionar o modelo do microcontrolador PIC que
utilizaremos em nosso projeto.
>> No campo Clock especificamos o valor da frequencia de trabalho de nosso
microcontrolador. No caso de aplicações com o Kit PICgenios PIC18F, utilizaremos o
valor de 8MHz (frequencia do cristal externo conectado ao chip).
Após ter configurado todos os parâmentros e campos, basta clicar no botão ok
para salvar seu projeto. Pronto, nosso projeto está pronto e podemos
inserir os códigos do programa no editor.
8.7- Conhecendo o ambiente mikroC
Observe o ambiente mikroC na figura abaixo:
31
O compilador
O compilador mikroC permite o desenvolvimento rápido de aplicações complexas
graças aos recursos do editor avançado Code Editor. Além disso, é permitido utilizar
as bibliotecas incluídas na linguagem para aumentar a velocidade e a facilidade de
desenvolvimento dos projetos como comunicação serial, displays, aquisição de
dados, memória, etc.
Após a compilação de nosso programa, o mikroC também gera arquivos LIST,
código em assembly e arquivo .HEX. Integrado ao compilador, temos um debugador
para testes do programa no ambiente.
8.8- Code Editor (editor de código)
O editor de código do compilador mikroC oferece grandes auxílios no
desenvolvimentos de projetos.
Alguns aspectos desse editor são:
Sintaxe ajustável
Assistentes de parâmetros
Código modelo
Autocorreção para tipos comuns
Função para saltos de linhas.
32
Assistentes de códigos
8.9- Messages Window (janela de mensagens)
Nos casos de erros encontrados durante a compilação, o compilador reporta o erro e
não gera o arquivo .hex. Além disso, o Message Window informa o tamanho do
código de programa (ROM) gerado pelo sistema, assim como a memória de dados
(RAM) usada pelo programa. Para visualizar a janela de
mensagens, vá em View > Messages.
Figura 4- Janela de menssagens
8.10- Project Setup
Em Project Setup podemos alterar as configurações dos projetos criado no mikroC.
Para acessá-lo pressione Project > Edit Project.
Criação de um projeto no mikroC passo a passo
Vamos aprender passo a passo como criar um projeto no mikroC:
1º. O primeiro passo é abrir o mikroC;
33
2º. Acesse o menu Project > New Project...
3º. No menu New Project, coloque o nome do seu projeto, a pasta onde serão salvos
os arquivos-fontes do programa, escolha o microcontrolador que deseja programar,
o valor da freqüência do cristal, e configure os fusíveis do PIC selecionado.
Neste exemplo, colocamos no nome de meu_programa em nosso
34
projeto, os arquivos -fontes do projeto serão salvos em
C:\...\Meu_programa\ , o microcontrolador que iremos utilizar no
projeto é o PIC18F452, a freqüência do cristal utilizado é de 8 MHZ, e os fusíveis
configurados são:
Oscilador -> XT (definimos o tipo de oscilador utilizado no projeto)
Watchdog -> OFF (Watchdog timer desligado)
LVP -> OFF (Low Voltagem Programming - desligado)
Brown Out -> OFF (Brown-out desligado)
4º. Clique no botão ok do painel New Project para salvar as configurações do
projeto.
A tela seguinte irá aparecer, edite seu programa no Code Editor (painel
de edição).
Para exemplificar copie e cole o programa abaixo no painel de edição
do mikroC.
// o programa abaixo tem por função escrever no PORTB do PIC o valor FF void main() { TRISB = 0x00; PORTB = 0xff; while (1); }
35
5º. Salve seu programa através do ícone salvar na barra de ferramentas do mikroC e
pressione o ícone Build Project ou pressione as teclas de atalho CTRL + F9 para
compilar seu programa;
6º. Seu programa será compilado e seu resultado poderá ser visualizado através da
Janela de mensagens:
Pronto, seu projeto foi criado e compilado com sucesso; O compilador mikroC gerou
na compilação o arquivo .HEX, é este arquivo que deverá ser gravado no
microcontrolador PIC.
Arquivo meu_programa.hex gerado pelo mikroC na compilação do nosso projeto.
36
9- PRIMEIRO PROJETO Inicialmente deve-se criar um projeto onde :
Project Name: Led_1
Project Path: C:/Pasta_aluno
Description: Programa circuito acende led no port “B0”
Device: P16F628a
Clock: 004.000000
Device Flags: _XT_OSC, _PWRT_ON, _WDT_OFF, _LVP_OFF, _CP_OFF
RA7/OSC1/CLKIN16
RB0/INT6
RB1/RX/DT7
RB2/TX/CK8
RB3/CCP19
RB410
RB511
RB6/T1OSO/T1CKI12
RB7/T1OSI13
RA0/AN017
RA1/AN118
RA2/AN2/VREF1
RA3/AN3/CMP12
RA4/T0CKI/CMP23
RA6/OSC2/CLKOUT15
RA5/MCLR4
U1
PIC16F628A
D1LED-RED
R1330R
R210k
Devemos então escrever o código e compilar o projeto para assim poder gravar o
programa no Microcontrolador.
/**********************************************************************
Microcontroladores PIC
Linguagem C – Compilador MikroC
Programa teste
Objetivo: Programa de um circuito que acende o led no PORTB “0”
*********************************************************************/
void main()
37
{
cmcon=0x07;
trisb= 0b00000000; // Port B como saida
portb= 0; //estado inicial do port B
trisa= 0b00000000; // todo o porta como saida
porta= 0;
while(1) //loop infinito
{
portb.f0=1; //ativa saída RB0
}
}
Uma vez escrito o programa, para compilar basta pressionar “CTRL + F9” ou, clicar
em Menu Project e em seguida a opção Build.
Não apresentando nenhum erro, na tela de mensagens deverá aparecer o seguinte
mensagem na cor verde:
SUCCESS ( Release Build)
Esta mensagem garante que o programa foi compilado e que foi gerado o código de
máquina para ser gravado no Microcontrolador (arquivo.HEX).
Gravando o Projeto:
O Programa WinPIC versão 3.62 será utilizado para gravar o programa no
Microcontrolador.
Primeira coisa a se fazer é selecionar o Chip – PIC16F628a.
38
Porém, precisamos ainda configurar o WinPic 800 para o correto funcionamento com
a placa JDM. Para isso, clica-se em Configuração, opção Hardware e selecione o
programador (JDM PROGRAMMER)..
Este Programa é pago mais tem uma versão mais simples e gratuita e está disponível no site: /www.winpic800.com. Identificação dos botões:
- Ler Tudo: Usado para leitura do conteúdo gravado no Microcontrolador;
- Programar Tudo: Usado para gravarmos o programa no Microcontrolador;
- Limpar Tudo: Usado para limparmos o conteúdo gravado no Microcontrolador;
39
- Verificar: Usado para fazer uma comparação do conteúdo gravado no
Microcontrolador com o programa aberto.
Após o término da gravação, se tudo deu certo aparecerá seguinte mensagem:
OK! O programa já está gravado no PIC. Agora é só testar.
Exercícios:
1 - Fazer um programa onde o led de RB0 deve ficar aceso ao ligar o nosso Kit. 2 - Fazer um programa onde o led de RBO deve acender e apagar com intervalo de 500ms.
10- FUNÇÕES
DEFINE:
A diretiva Define da nome ao bit do port em questão
/********************************************************************** Microcontroladores PIC Linguagem C – Compilador MikroC Programa 1 Objetivo: Apresentar o uso da diretiva define *********************************************************************/ #define led1 portb.f1 // define o label led1 para o pino RB1 #define led2 portb.f2 // define o label led2 para o pino RB2 void main()
{
cmcon=0x07;
trisb= 0b00000000; // Port B como saida
40
portb= 0; //estado inicial do port B
trisa= 0b00000000; // todo o porta como saida
porta= 0;
while(1) //loop infinito { led1=1; //ativa saída RB1 led2=1; // ativa saída RB2 }
}
10.1- ACIONAMENTO DE BOTÕES UTILIZANDO O “IF”
/********************************************************************** Microcontroladores PIC Linguagem C – Compilador MikroC Programa 2 Objetivo: Fazer leitura de um botão e utilização do IF *********************************************************************/ void main ( ) { cmcon=0x07;
trisa = 0b00000010; // configura RA1 entrada restante como saída portb = 0; // todos os pinos de saída do portb = nível baixo while(1) //loop infinito { if (porta.f1==1) //Se porta 1 for igual a 1 { portb=255; //acende todo o portb } }
}
**Observe que se for pressionado o botão em RA1 todo o portB vai acende e não
vai mais apagar, a não ser que o PIC seja Resetado ou desligado.
10.2- ELSE: UTILIZANDO A FUNÇÃO ELSE OU SEJA “SE NÃO”
/********************************************************************** Microcontroladores PIC Linguagem C – Compilador MikroC Programa 4 Objetivo: Fazer leitura de um botão e utilização do IF e else
41
*********************************************************************/ void main ( ) { cmcon=0x07;
trisa = 0b00000010; // configura RA1 entrada restante como saída portb = 0; // todos os pinos de saída do portb = nível baixo while(1) //loop infinito { if (porta.f1==1) //Se porta 1 for igual a 1 { portb=255; //acende todo o portb } Else { Portb=0; } }
}
**Observe que se for pressionado o botão em RA1 todo o portB vai acende, senão
vai continuar apagado.
Exercicio:
3- Faça um programa que acenda um led a cada tecla pressionada em “PORTA”
Teclas utilizadas: RA1, RA2, RA3 e RA5.
10.3- FUNÇÃO BUTTON Button (&portX , pinoX , tempoX , Estado_Tecla)
Onde:
&portX = port da tecla (porta, portb, portc, portd ou porte);
pinoX = é o pino onde está conectado a tecla (varia de 0 à 7);
tempoX = tempo de Debounce em milisegundos;
Estado_Tecla = Valor do nível lógico quando a tecla é pressionada.
42
Acionamento de Botões: Abaixo temos o esquema básico do nosso KIT de desenvolvimento:
RA7/OSC1/CLKIN16
RB0/INT6
RB1/RX/DT7
RB2/TX/CK8
RB3/CCP19
RB410
RB511
RB6/T1OSO/T1CKI12
RB7/T1OSI13
RA0/AN017
RA1/AN118
RA2/AN2/VREF1
RA3/AN3/CMP12
RA4/T0CKI/CMP23
RA6/OSC2/CLKOUT15
RA5/MCLR4
U1
PIC16F628A
D1LED-RED
R1330R
R210k
R31k
+ 5 volts+ 5 volts
GND
Botão 1
Resistor de Pull-up
/********************************************************************** Microcontroladores PIC Linguagem C – Compilador MikroC Programa: 3 Objetivo: Fazer leitura de um botão e utilização da função Button *********************************************************************/ void main() { cmcon=0x07; //Conf. básicas trisb= 0b00000000; // Port B como saida portb= 0; //estado inicial de portb trisa= 0b00000010; // todo o porta como saida porta= 0; while(1) //loop infinito
43
{ if (button(&porta, 1,20,1) //Se o botão RA1 é pressionado { Portb=255; //acende todo o portb } Else { portb=0; //senão continua com as saídas em zero “0” } }
}
** A função Button é utilizada como um recurso de software, para eliminar o
problema de Debounce , ou seja um pequeno ruido ao acionar-mos a tecla.
-Agora vamos testar várias chaves individualmente sem o problema de Debounce
utilizando a função Button .
/**********************************************************************
Curso de Microcontroladores PIC
Linguagem C – Compilador MikroC
Programa teste função Button com vária chaves
Objetivo: Testar várias chaves sem ter problema de ruído (Debounce).
*********************************************************************/
void main()
{
cmcon=0x07;
trisb=0; // define o PORTB como saida
trisa=0b00011110; // define todo o PORTA 1,2,3 e 4 como entrada
while(1)
{
if (button(&porta, 1, 20, 1)) // &port identifica o port, 1 identifica o pino,
// 20ms é o tempo e 1 é nível para tecla acionada
portb.f0=1; // se pressionado aciona Rb0
else if (button(&porta, 2, 20, 1))
44
portb.f1=1;
else if (button(&porta, 3, 20, 1))
portb.f2=1;
else if (button(&porta, 4, 20, 1))
portb.f3=1;
delay_ms(200);
}
}
Exercício: 4) Imagine que vamos montar um circuito que controle através de 4 chaves
(ligar/desligar) a iluminação de uma casa. Esse controle ficará no quarto do casal, ao
lado da cama, podendo com praticidade controlar/monitorar a iluminação da casa.
Então teremos as chaves em RA1, RA2 ,RA3 e RA4 e as saídas para acionar os
relés em RB0, RB1, RB2 e RB3.
Pressionado RA1 acende iluminação da sala e pressionado RA1 novamente apaga.
Idem para RA2 (cozinha), RA3 (quarto 1) e RA4 (quarto 2).
11. REFERÊNCIAS
Disponível em:
David José de Souza , Desbravando o PIC
Disponível em : Livro Microcontroladores PIC16F628A/648A Uma abordagem prática objetiva Autor: Wagner da Silva Zanco
Disponível em:
Microchip Technology Inc. (www.microchip.com)
Acessado em 04 outubro 2013.
Recommended
