Você está na página 1de 30

Linguagem C

para
microcontroladores
PIC
(Curso B!sico)
VIDAL Microcontroladores
Eng. Vidal Pereira da Silva J#nior
ltima revisao: 10/01/2002
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
2
Objetivo:
Iniciar o projetista no uso da linguagem C para sistemas dedicados baseados na
famlia PIC 16CXXX e 16FXXX.
Metodologia:
O curso esta dividido em 3 partes:
w Iniciao Linguagem C
w Implementao da CCS para a linha microchip
w Exemplos prticos de hardware e software

Parte I - Iniciao linguagem C
A principal vantagem de se usar linguagens de alto nvel (no nosso caso a
linguagem C) esta na menor interao do projetista com o hardware, no que diz respeito
ao controle do mesmo (ajuste de bancos de registradores, seqncias de inicializao, ...).
Desta forma o projetista dedica seu tempo basicamente lgica do problema e no
aos detalhes internos do chip.
Como exemplo vamos ver a seqncia de escrita na EEPROM do 16F84A (gravar
no endereo 20H o valor 12H, pg. 27 do livro):
Em assembler: Em 'C'
bcf STATUS,RP0 write_eeprom(0x20,0x12);
movlw 20H
movwf EEADR
movlw 12H
movwf EEDATA
bsf STATUS,RP0
bcf INTCON,GIE
bsf EECON1,WREN
movlw 55H
movwf EECON2
movlw 0AAH
movwf EECON2
bsf EECON1,WR
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
3
I.1 - Modelo bsico de um programa em C
Quatro elementos esto presentes em um programa C:
Comentrios
Diretivas de compilao
Definies de dados
Blocos com instrues e funes
Modelo bsico
#include <....> Diretivas de compila#o
#fuses ......
// comentrio ocupando uma linha Coment&rios
/* comentrios entre '/ *' e '* /'
podem ocupar mais de
uma linha
*/
char i , j ; Vari&veis
float Tempo;
void main()
{
instru(es do programa principal
}
void delay()
{
instru(es da fun#o (rotina) delay
}
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
4
I.2 - Comentrios
Comentrios so informaes anexadas ao programa fonte (*) que permitem ao
programador ou outros entenderem o significado do que esta sendo feito.
boa prtica comentar todas as linhas, pois aps um certo tempo, nem mesmo o
criador do programa lembrar de tudo o que estava pensando no momento da escrita.
O compilador ignora tudo que estiver definido como coment rio
(*) O programa fonte em C deve ter terminao ".C
Exemplo: teste.c
Existem dois tipos de comentrios:
Comentrios que ocupam apenas 1 linha
Este tipo de comentrio iniciado com duas barras conjuntas: //
Neste caso, tudo que estiver aps as duas barras ser ignorado pelo compilador.
Exemplo:
x = x + 2; // soma 2 varivel x
Comentrios com mltiplas linhas
Este tipo de comentrio iniciado com a seqncia /* e finalizado pela seqncia */.
Neste caso, tudo que estiver ENTRE estas duas seqncias ser ignorado pelo
compilador. Ideal para excluir temporariamente trechos de cdigo.
Exemplo:
x = x + 2;
/* tempo++;
a = SQRT(25); */
x = 0;
No exemplo acima, as linhas tempo++; e a=SQRT(25); sero ignoradas no
momento da compilao.
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
5
I.3 - Diretivas de compilao
So instrues para o compilador, e no para o programa que ser gerado, se bem
que em alguns casos implicar na incluso de alguns trechos de cdigo j pronto.
As diretivas informam, por exemplo, o processador para o qual o cdigo dever ser
gerado, o valor do clock que ser usado pela cpu,..).
As diretivas sempre comeam com ' # '.
Um bom exemplo a diretiva que inclui no processo de compilao as definies do
chip.
#include <16F874A.H>
A terminao .H indica um Header File da linguagem C, ou seja, um cabealho.
Equivale ao P16F874A.INC usado no assembler.
I.4 - Indicador de fim de instruo
O compilador C no um compilador de linha, como o assembler.
O compilador C procura o sinal de que a instruo ou o bloco de instrues j
acabou.
Este sinal o "ponto e virgula para uma instruo ou o ' } ' para o bloco
(mais tarde falaremos sobre blocos de instrues).
No exemplo abaixo, as duas maneiras so corretas, pois o ' ; ' que sinaliza o fim
da instruo.
x = x + 25; x =
x + 25
;
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
6
I.5 - Definio de variveis, constantes e identificadores
Todas as variveis e constantes usadas no programa devem ser devidamente
definidas, com um nome e um tipo. O mesmo vale para identificadores de funes e
rotinas. Os dados bsicos podem ser de 8, 16 e 32 bits de comprimento, e devido as
caractersticas peculiares dos microcontroladores, variveis de 1 bit tambm podem ser
definidas.
Variveis: tamanho faixa
varivel de 8 bits: CHAR ( de 0 255 * )
varivel de 16 bits: LONG INT ( de 0 65535 * )
varivel de 32 bits: FLOAT ( +- 1.2 E -38 a +- 1.2 E +38)
varivel de 1 bit: SHORT ( pode assumir 0 ou 1)
(*) Variveis com valores negativos:
As variveis do tipo CHAR e LONG INT podem ou no ter sinal negativo. Para
garantir que a varivel seja sempre positiva, usamos unsigned antes da definio da
mesma. Caso seja necessrio tratar nmeros negativos, usaremos signed.
Ex.: unsigned long int tempo; // tempo ir de 0 65535
signed long int espaco; // espaco ir de -32768 32767
Observe que o indicativo signed diminui o alcance da varivel pela metade.
O padro da linguagem, quando no indicado, o tipo UNSIGNED.
FLOAT no admite os indicativos mas pode ser positivo ou negativo.
I.5.1 - Seqncia de declarao de variveis e constantes
Para se declarar uma varivel temos a seguinte ordem das defini es:
Tipo Nome
char tempo; // a varivel 'tempo' vai de 0 255
Um grupo de variveis de mesmo tipo pode ser declarada na mesma linha.
char i, j, k; // declara que i, j e k so do tipo char.
Constantes:
CONST define um 'label' para valores que no sero alterados pelo programa:
Exemplo: FLOAT CONST PI = 3.14;
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
7
I.5.2 - Como escrever os nomes de vari veis, constantes e funes
Todo 'label' (nome ou identificador), seja de varivel, constante ou funo, deve
comear por letra, ter no mximo 32 caracteres e no usar caracteres especiais ou de
controle ( ! \ ? % ....).
Nomes de funes e rotinas internas tambm no podem ser utilizados.
- Exemplos de definies:
Corretas Incorretas
Teste 0local comea com n*mero
teste parte!dois
TESTE ^
_12A caracter inv&lido ( ! )
x_2_5
IMPORTANTE: O compilador diferencia letras minsculas de maisculas.
Nos exemplos acima, Teste, teste e TESTE so 3 variveis diferentes para o
compilador.
Uma boa prtica esta em diferenciar variveis, labels e registros com tipos
diferentes de letras.
Exemplo: PORTB registro da CPU
TempoMs Rotina de tempo em ms
quantos varivel em RAM
I.5.2 - Atribuindo valores
A atribuio de valores feita pelo sinal de igualdade,
tempo = 123;
aqui a varivel tempo passa a ter o valor 123 decimal.
I.5.3 - IMPORTANTE Valores iniciais das variveis
Devemos sempre ajustar os valores iniciais de cada varivel do programa
antes de usa-las, pois nada garante que esto em "0 " no reset.
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
8
I.6 - Funes
Chamamos funo um trecho de programa que realiza determinada operao
(funo que l teclado, funo que escreve no display, ...) bem como as funes
pr-definidas (SQRT, ABS, ACOS, ...).
Para evitar conflito, vamos chamar de 'rotinas' as funes escritas pelo projetista do
software.
No exemplo abaixo, temos a funo MAIN (falaremos dela depois) que a rotina
executada no reset do programa. A funo MAIN chama uma ROTINA para ler teclas, e a
rotina de ler teclas chama uma FUNO para calcular o valor absoluto da tecla.
main ( )
{
---
---
LeTeclas( );
---
---
}
LeTeclas( )
{
---
---
X = ABS(tecla_lida);
---
---
}
Pela nomenclatura normal, 'LeTeclas' seria chamada de funo, mas preferimos
chama-la de rotina, para diferenciar das funes pr-definidas.
I.6.1 - Funes especialmente desenvolvidas para os PIC's
Na parte II, referente ao compilador da CCS, veremos quais as funes que existem
para os PIC's e como funcionam.
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
9
I.7 - Expresses numricas e de string (caracteres)
Vamos ver neste item os tipos de expresso permitidas para valores numricos e
para a manipulao de caracteres.
Nmeros Decimais: No podem comear por ' 0 ' (zero)
Exemplos: 123; 2; 14534; 3.14; ...
Nmeros Octais: Devem comear por ' 0 ' (zero)
(Pouco utilizados)
Exemplos: 045; 09;...
Nmeros Binrios: Devem iniciar por ' 0b '
Exemplo: 0b10101010
Nmeros Hexadecimais: Devem iniciar por ' 0x '
Exemplo: 0x32; 0xA9; ...
String de 1 caractere: Entre Apstrofos ' '
Exemplo: 'z'; 'A'; ....
String de vrios caracteres: Entre aspas " "
Exemplo: "teste de escrita
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
10
I.8 - Operadores lgicos e aritmticos bsicos da linguagem C
Temos aqui os principais operadores lgicos e aritmticos da linguagem C:
+ Adio
++ Incremento da varivel indicada
( D++ equivalente a D = D + 1)
- Subtrao
-- Decremento da varivel indicada
( X-- equivalente a X = X - 1)
* Multiplicao
/ Diviso (parte inteira para variveis inteiras)
% Resto da diviso (diviso de inteiros)
< Comparador lgico "menor que
> Comparador lgico "maior que
<= Comparador lgico "menor ou igual que
>= Comparador lgico "maior ou igual que
== Comparador lgico "igual a (*)
!= Comparador lgico "diferente de
&& AND lgico ou relacional (todas as condies verdadeiras)
|| OR lgico ou relacional (uma das condies verdadeira)
! NOT lgico ou relacional (v se a condio TRUE ou FALSE)
& AND binrio (bit a bit nas variveis)
| OR binrio (bit a bit nas variveis)
~ NOT binrio (inverte o estado de cada bit da varivel)
^ XOR binrio (bit a bit nas variveis)
(*) Se numa comparao usarmos ' = ', o compilador far uma atribuio, gerando um
programa errado logicamente.
Exemplo correto: SE A == 5 ..... // Verifica se A igual a 5
Exemplo errado: SE A = 5 ...... // Primeiro faz A igual a 5, e o
// teste acaba dando verdadeiro
Cuidado ! O compilador n#o avisa deste erro.
Exemplo para inverter a varivel X e escrever no portb:
portb = ~ X; // operador NOT binrio
Exemplo para ver se o bit T0IF ainda no chegou a 1:
if ( ! T0IF ) .... // Se T0IF NO (not) TRUE ( true = 1),....
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
11
I.9 - Matrizes
Define-se como matriz um grupo de dados que podem ser agrupados num mesmo
nome, diferenciando-se apenas pela posi o no grupo.
Como exemplo temos uma rua com vrias casas. A rua seria nossa matriz, por
exemplo, Rua Paran. Cada casa tem um nmero que indica sua posio na rua (na
matriz).
Exemplo: casa 32 da Rua Paran
Poderamos escrever Rua Parana[32]
Em C, a definio de uma varivel ou de uma constante como matriz feita apenas
pela incluso de seu tamanho entre colchetes [ ].
Exemplo:
Matriz para os 20 valores de temperatura lidos, vari veis tipo char:
char temperatura[20]; // reserva espao de memria para
// 20 bytes que indicaro a temperatura
Para acessar os elementos da matriz basta escrever o nome da vari vel com o
ndice do valor desejado.
Exemplo:
valor = temperatura[12]; // o 13
o
elemento da matriz temperatura
// copiado para a varivel valor.
IMPORTANTE:
1. O ndice de acesso a matriz vai de 0 at tamanho-1.
No nosso exemplo, ir de 0 19.
2. CUIDADO! Se voce usar como indice da matriz um numero maior que o seu
limite, o compilador usar uma posicao de memria RAM de outra varivel.
3. Muito cuidado com o uso de matrizes, pois temos pouca memria RAM nos
chips.
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
12
I.10 - Controle do programa em C
Um dos pontos mais importantes do aprendizado da linguagem C esta na sua
sintaxe, isto , como o programa deve ser escrito.
At agora vimos apenas teorias sobre variveis, dados, e funes.
Veremos a partir de agora como tudo isto integrado de forma a produzir um
resultado til.
Para tal vamos estudar as estruturas de montagem de programas e ver como se
controla o fluxo de "aes que o programa deve tomar.
Para facilitar o aprendizado no vamos nos preocupar agora com o PIC e nem com
as funes criadas para o mesmo, mas apenas com a forma como escrevemos o
programa em C.
I.10.1 - Blocos de declaraes
Sempre que mais de uma instruo tiver de ser executada para uma certa rotina, as
mesmas devero estar contidas dentro de um BLOCO de declaraes.
Um bloco tem incio com a abertura de uma chave ' { ' e finalizado pelo
fechamento da chave ' } '.
Como um bloco no termina no fim da linha, mas sim ao fechar a chave, podemos
escrever o mesmo de forma mais clara, colocando seus elementos em vrias linhas e
permitindo melhor colocao de comentrios..
Exemplo 1: { x = 1; tempo = x * 2; }
Exemplo 2: {
x = 1; // posso colocar um
tempo = x * 2; // comentrio para cada
} // linha
Os dois exemplos acima realizam a mesma tarefa, mas o exemplo 2 mais fcil de
ser lido e posteriormente entendido.
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
13
I.10.2 - Bloco IF (executa se a condio for verdadeira)
Podemos entender o bloco IF como um teste simples.
Temos duas opes bsicas, sendo que a condio de teste dever estar entre
parnteses:
Temos vrios formatos possveis para o IF
IF simples, com apenas uma declarao caso o teste seja verdadeiro
if ( A = 0 ) A = 10; // SE a varivel A estiver zerada, atribui 10
// mesma.
IF com mais de uma declarao caso o teste seja verdadeiro.
Neste caso o grupo de declaraes dever estar num BLOCO, entre chaves ' { } '.
if ( tempo > 10 )
{
tempo = 0;
contador = contador + 1;
}
IF com exceo (se o teste falha, executa outra declarao ou bloco).
Pode na exceo executar uma instruo apenas ou um bloco
if ( teste = sim ) declara#o individual ou bloco
else
declara#o individual ou bloco da exce#o
Importante: A instruo (declarao) simples no precisa estar na mesma linha do IF ou
do ELSE. (Ver item I.10.2.1, nos exemplos de IF's aninhados).
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
14
- SE (teste = ok!) "executa esta(s) declara#o((es)
- SE (teste = ok!) "executa esta(s) declara#o((es)
SENO "executa esta(s) outras declara#o((es)
Podemos ento resumir numa tabela todas as combinaes dos IF's:
if (teste a realizar) instru#o para teste ,OK-
if (teste a realizar)
{
grupo de instru(es para teste ,OK-
}
if (teste a realizar) instru#o para teste ,OK-
else instru#o para teste ,N.O OK-
if (teste a realizar)
{
grupo de instru(es para teste ,OK-
}
else instru#o para teste ,N.O OK-
if (teste a realizar) instru#o para teste ,OK-
else
{
grupo de instru(es para teste ,N.O OK-
}
if (teste a realizar)
{
grupo de instru(es para teste ,OK-
}
else
{
grupo de instru(es para teste ,N.O OK-
}
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
15
I.10.2.1 - IF's aninhados (embutidos um no outro)
Chamamos a estrutura de "IF's aninhados quando a instruo a ser executada para
um teste (seja verdadeiro ou falso) na verdade outro IF.
Vamos ver dois exemplos que ajudaro a esclarecer o assunto.
Exemplo 1: Observe os dois trechos de programa a seguir:
if ( X ) | if ( X )
if (Y) | {
a = a * 2; | if (Y)
else | a = a * 2;
a = a * 4; | }
| else
| a = a * 4
No trecho da esquerda, o else refere-se ao if (Y), pois esta "mais prximo deste.
Somente se o if (Y) resultar falso que a linha a = a * 4 ser executada.
Se o if (X) resultar falso, nenhuma operao ser realizada.
No trecho da direita, o else refere-se ao if (X), pois o if (Y) esta dentro de um bloco,
no sendo visvel para o else.
Se o if (X) resultar verdadeiro mas o if(Y) resultar falso, nenhuma operao ser
realizada.
Exemplo 2: Vrios IF's seqnciais
if ( posio == 1) // V se posio = 1.
peso = 1; // 1. Faz peso = 1.
else if (posio == 2) // No 1. V se posio = 2.
peso = 2; // 2. Faz peso = 2.
else if (posio == 3) // No 2. V se posio = 3.
peso = 4; // 3. Faz peso = 4.
else if (posio == 4) // No 3. V se posio = 4.
peso = 8; // 4. Faz peso = 8.
else peso = 0; // No 4. Faz peso = 0.
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
16
I.10.3 - Bloco FOR (loop para executar por um certo nmero de vezes)
A idia do bloco FOR executar uma instruo ou um bloco de instrues
repetidamente, por um nmero de vezes determinado pela chamado do loop.
Sua sintaxe a seguinte:
Para melhor entendimento, vejamos um exemplo de um loop que conta de 1 a 100,
e escreve este valor numa varivel chamada PORTB.
for ( i = 1; i < 101 ; i++ ) PORTB = i;
Se desejarmos escrever na varivel PORTB e ainda somar estes nmeros,
podemos usar o seguinte programa:
char PORTB; // declarei PORTB como varivel de 1 byte
long int soma; // declarei a varivel soma como 16 bits.
char i; /* a varivel que usada no loop tambm
precisa ser declarada. Neste caso, 1
byte suficiente */
soma = 0; // fao soma = 0 para inicializar a varivel
for ( i = 1; i < 101; i++)
{
PORTB = i; // escreve ' i ' em PORTB
soma = soma + i; // a soma anterior somada a ' i '
}
I.10.3.1 - Loop infinito com FOR
Podemos criar um loop infinito com a declarao
for ( ; ; ) instru#o que ser& executada indefinidamente
ou
for ( ; ; )
{
Instru(es que ser#o executadas indefinidamente
}
Lembre-se que o programa de um microcontrolador no tem fim, sempre esta
rodando.
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
17
for ( inicializa#o ; condi#o ; incremento ) instruo ;
ou
for ( inicializa#o ; condi#o ; incremento )
{
( grupo de instrues )
}
I.10.4 - O condicional WHILE (enquanto)
O WHILE executa a instruo ou o bloco de instrues "enquanto a condio de
teste for verdadeira.
Se logo no inicio do teste a condio der falsa, nada ser executado.
Sintaxe:
Vamos proceder novamente a soma dos nmeros de 1 a 100 como no exemplo
anterior.
i = 0; // nunca esquecer de inicializar
soma = 0; // todas as variveis do programa.
while ( i < 101 ) // faa enquanto I<101
{
soma = soma + 1;
i++; /* como o WHILE apenas faz o teste
devo incrementar a varivel */
}
I.10.4.1 - Loop infinito com WHILE
while (1)
{
( declaraes executadas eternamente )
}
A condio booleana "1 sempre ser verdadeira (1 = true).
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
18
while ( teste ) instru#o para teste verdadeiro
ou
while ( teste )
{
( grupo de instrues para teste verdadeiro)
}
I.10.5 - O condicional DO / WHILE (faa ... enquanto)
O condicional DO / WHILE funciona de forma semelhante ao WHILE, exceto pelo
seguinte fato:
#pelo menos uma vez a instru$'o ou o bloco ser'o executados).
Sua sintaxe :
A instruo (ou o bloco) executada uma vez porque neste formato o teste dentro
do While ser executado APS a execuo, enquanto que no bloco While comum o teste
executado ANTES.
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
19
do
instru#o para teste verdadeiro
while ( teste ) ;
ou
do
{
( grupo de instrues para teste verdadeiro)
}
while ( teste ) ;
I.10.5 - O condicional SWITCH
O SWITCH testa a varivel e conforme seu valor pula diretamente para o grupo de
instrues conforme a clusula CASE.
Caso nenhuma das condies previstas nos vrios CASE sejam satisfeitas, executa
o bloco DEFAULT, se houver (o default no obrigatrio).
Mesmo que apenas uma instruo seja usada para um certo CASE, sempre
teremos um bloco ( entre chaves ' { } ' ) pois alm da instruo a ser executada devemos
incluir a instruo BREAK, que faz com que o programa v imediatamente para o fim do
SWITCH, continuando a partir dai.
Caso o BREAK no seja colocado, o programa continuar pelo CASE logo abaixo
do que foi chamado (ou no DEFAULT).
Seu formato geral :
switch ( vari&vel )
{
case constante1
{
( instruo ou grupo de instrues )
break;
}
case constante2
{
( instruo ou grupo de instrues )
break;
}
.
.
.
default:
{
( instruo ou grupo de instrues para falso geral )
break;
}
}
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
20
Vamos ver um exemplo que faz o mesmo que o IF aninhado que vimos
anteriormente.
switch ( posio )
{
case 1: // CASO posio = 1 ....
{
peso = 1;
break; // sai do CASE.
}
case 2:
{
peso = 2;
break;
}
case 3:
{
peso = 4;
break;
}
case 4:
{
peso = 8;
break;
}
default: // CASO posio NO seja 1, 2, 3 ou 4,
{ // executa este bloco
peso = 0;
break;
}
}
Para ilustrar vamos escrever vrias declaraes em uma s linha.
switch ( posio )
{
case 1: { peso = 1; break; } // CASO peso=1, ....
case 2: { peso = 2; break; } // CASO peso=2, ....
case 3: { peso = 4; break; }
case 4: { peso = 8; break; }
default: { peso = 0; break; }
}
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
21
I.11 - Abreviaes teis para instrues aritmticas
I.11.1 - Incremento e Decremento
Duas delas foram mostradas no item I.8 (Operadores l gicos e aritmticos bsicos
da linguagem C), a saber:
++ Incremento da varivel indicada
O operador '++' facilita a escrita de instrues para o incremento de variveis.
Ao invs de escrever: a = a + 1;
podemos escrever: a++; ou ++a; (*)
-- Decremento da varivel indicada
O operador '--' facilita a escrita de instrues para o decremento de variveis.
Ao invs de escrever: a = a - 1;
podemos escrever: a--; ou --a;
I.11.2 - Soma ou subtrao de valores maiores que '1' uma varivel
Instru#o normal Instru#o abreviada
X = X + 10; X + = 10;
Tempo = Valor - 25; Tempo - = Valor;
I.11.3 - Combinando abreviaes
Podemos combinar numa nica linha abreviaes e atribuies, de forma a facilitar
a escrita do programa.
Importante: Os iniciantes na linguagem devem usar inicialmente as instrues bsicas
para no se confundirem.
Vamos explicar com alguns exemplos:
X = X + 1;
Y = X; ---> Y = ++X;
Como o ++ esta 'antes' do X, primeiro o X ser incrementado para depois Y receber
o valor.
Se fizermos o equivalente ser
Y = X++; Y = X;
X = X + 1;
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
22
I.12 - Variveis locais, variveis globais e parmetros
Existem duas maneiras principais para a alocao de variveis em memria:
1.12.1 - Variveis Globais:
As variveis globais tem "alcance para todas as rotinas e funes existentes no
programa. Isto significa que qualquer rotina ou funo poder utiliza-la.
1.12.2 - Variveis Locais:
As variveis locais tem "alcance apenas dentro das rotinas ou funes onde foram
criadas.
Isto significa que apenas a rotina ou funo onde a mesma foi criada poder
utiliza-la.
Vamos ver um fragmento de cdigo como exemplo:
char A,B,C; // A, B e C so variveis globais, pois esto fora de
// qualquer funo ou rotina.
main ()
{
A = 0; // Faz A=0
Tempo(); // chama rotina Tempo
Espera(); // chama rotina Espera
}
Tempo()
{
char J; // cria uma varivel chamada J.
// Somente a rotina Tempo() poder utiliza-la
J = A;
}
Espera()
{
char X; // cria uma varivel chamada X.
// Somente a rotina Espera() poder utiliza-la
X = A;
X = J; // Erro: A varivel J no existe para esta rotina
}
A principal vantagem no uso das variveis locais esta em que a memria RAM
ocupada pela mesma poder ser compartilhada por outras variveis locais, permitindo um
"aumento relativo no espao de memria, pois as variaveis locais de duas rotinas que
nunca se comunicam podero estar no mesmo endereo fsico de memria.
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
23
I.12.3 - Variveis como parmetros
Outra facilidade da linguagem C esta na passagem de valores de uma rotina ou
funo para outra.
Estes valores so conhecidos por "parmetros.
Vamos imaginar uma rotina que calcula o quadrado de um certo nmero.
Podemos chamar a rotina assim:
...
Nmero = 5;
Quadrado();
X = result;
.
.
.
void Quadrado()
{
Result = Nmero * Nmero;
}
Ou podemos chamar de forma mais elegante:
Result = Quadrado(5); // Result receber o resultado da rotina
// quadrado.
...
long int Quadrado(char H) // crio uma varivel local para receber o
{ // parmetro enviado.
return(H * H); // retorna um long int
}
No fonte e listagem anexos poderemos entender melhor esta facilidade.
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
24
I.13 - A varivel tipo VOID
Existe um tipo de varivel especial chamada VOID.
Seu significado seria mais ou menos do tipo VAZIO.
usada principalmente na chamada de rotinas ou no retorna das mesmas, para
indicar que nenhum valor foi "enviado ou ser "retornado da funo.
Para melhor entendimento, vejamos uma rotina que no precisa de parmetros e
nada retorna:
LeTeclas( ); // chama a rotina sem enviar nada
.
void LeTeclas( ) // este void indica que a rotina no envia
{ // parmetros de volta
.
}
No inicio do programa podemos informar ao compilador todas as rotinas que ser o
usadas e seus parmetros. Isto auxilia para evitar que ao usar a rotina a mesma seja
chamada de forma errnea ou o compilador apenas a busque acima do ponto de
chamada.
Esta declarao da rotina sem suas instrues e finalizada pelo " ; " conhecida por
prottipo.
Exemplos:
void LeTeclas (void); // Este prottipo indica que a rotina LeTeclas no recebe
// parmetros e tambm no retorna valores.
void Tempo (char yyy); // Este prottipo indica que a rotina Tempo receber um
// valor do tipo char, que receber o nome de yyy para
// seu uso, mas no retornar nada.
Vantagem de se usar os prottipos de funes:
long int XXX // declarei que XXX uma varivel de 16 bits
.
.
XXX = 100;
Tempo (XXX); // Chamo a rotina Tempo e espero que ela use a
// varivel XXX.
// COMO NO PROTTIPO ESTA INDICADO QUE A
// ROTINA DEVE USAR "char, O COMPILADOR GERA
// UM ERRO.
// Sem o prottipo o erro ocorreria no momento da
// execuo do programa.
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
25
I.14 - A funo MAIN ( )
Todo programa em C deve ter uma funo chamada MAIN ( ), que a rotina que
ser executada quando o programa for chamado (em nosso caso aps o reset da cpu ).
Exemplo de um programa que nada faz, mas que teoricamente pode ser compilado:
void main ( void) // a funo MAIN no recebe ou devolve valores
{
}
I.15 - Exemplos de programas simples
Veremos neste item alguns programas pequenos e simples, sem funo tcnica
especfica, apenas para ilustrar os conceitos vistos at agora.
Todos os conceitos vistos so genricos para a linguagem C, servindo inclusive
para usar em outros microprocessadores e computadores pessoais.
Programa 1:
Calcula a soma dos nmeros de 1 a 100.
char i; // varivel i usada no loop (0 a 255)
long int soma; // soma de 0 a 65535
void main( void)
{
for ( i = 0; i < 101; i++)
soma = soma + i;
}
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
26
Programa 2:
Conta indefinidamente de 1 a 10. Sempre que chegar a 10 incrementa a vari vel X
e recomea.
char i, x; // declarei que i e x so variveis do
// tipo char
void main ( void)
{
i = 0; x = 0; // inicializei as variveis
while (1) // fica eternamente neste loop
{
i++; // incrementa i
if ( i == 10 ) // v se i = 10.
{
x++; // . Incrementa x e faz i = 0.
i = 0;
}
}
}
Programa 3:
Incrementa indefinidamente a vari vel chamada PORTB
( na parte II veremos como executar no PIC ).
char PORTB; // declarei que PORTB varivel do
// tipo char (8 bits)
void main ( void)
{
PORTB = 0; // inicio em 0
while (true) // fica eternamente neste loop
{
PORTB++; // incrementa PORTB
}
}
ANEXO
Temos a seguir um programa ilustrativo do que foi estudado at agora.
Este programa foi compilado para o 16F874 e no de modo genrico porque o
compilador sempre precisa saber a quantidade de RAM e de ROM disponvel.
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
27
Listagem do programa "REGRAS.C"
/****************************************************************************************
Programa demo para o compilador C da CCS.
Compila blocos e instrues apenas para ver a compilao.
Aqui j temos um exemplo de coment rios em varias linhas
*****************************************************************************************
*/
// Cabealho inicial com diretivas de compilao
#CASE // COMPILADOR CASE SENSITIVE.
// Padro da linguagem C
#include <16F874.H> // Define processador
// Necessrio para informar a
// quantidade de RAM e ROM disponvel
// *********************************************************************************************
// prottipos de rotinas
void _while(void); // nao recebe e nao devolve
void _do_while(void); // nao recebe e nao devolve parametros
void _switch(void); // nao recebe e nao devolve parametros
void _ifs(void); // nao recebe e nao devolve parametros
void _for(char j); // recebe um char como parametro
// mas nao devolve nada
float quadrado(char q); // recebe char e deve devolver float
// *********************************************************************************************
// constantes e variaveis
char a,b,c,d,e; // variaveis de 8 bits
long int aa,bb,cc,dd,ee; // variaveis de 16 bits
float VarFloat; // variavel de 32 bits
short Led; // Led ser um pino de I/O
float const PI = 3.14; // definicao de constante tipo float
char Temperatura[20]; // definiao de uma matriz de 20 elementos
// *********************************************************************************************
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
28
void main() // Programa Principal
{
while (1) // loop infinito
{
a = 65; // atribuicao de variavel decimal 65
b = 0b01000001; // atribuicao de variavel 65 em binario
c = 0x41; // atribuicao de variavel 65 em hexa
d = 'A'; // atribuicao de variavel 65 em ascii
_ifs(); // chamada de rotinas sem parametros
_while();
_do_while();
_switch();
_for(20); // chama rotina com parametro de valor 20
VarFloat = quadrado(4);
}
}
// *********************************************************************************************
void _ifs()
{
if (a == 0)
{
e = 100;
}
else
{
e = 90;
}
}
// *********************************************************************************************
void _while()
{
a = 0;
while (a < 10)
{
b = 5;
c = b * 10;
a++;
}
}
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
29
// *********************************************************************************************
void _do_while()
{
char VarLocal;
VarLocal = 0;
e = 0;
do
e += 3;
while ( e < 100 );
}
// *********************************************************************************************
void _switch()
{
switch (d)
{
case 1:
{
a = 1;
break;
}
case 2:
{
a = 2;
break;
}
default:
{
a = 5;
break;
}
}
}
// *********************************************************************************************
void _for(char j)
{
for (e=1; e<j+1; e++) // 'e' varia de 1 a 'j'
Temperatura[e] = e;
}
// *********************************************************************************************
float quadrado(char q)
{
return (q*q);
}
Linguagem C para microcontroladores PIC
VIDAL Micorocntroladores - (11) - 6451 - 8994 - www.vidal.com.br
30

Você também pode gostar