Apostila C ANSI - Presencial Ver300

Linguagem C Embarcada para Microcontroladores
Autor: Fernando Simplicio de Sousa Fbio Perkowitsch Mulero Equipe Microgenios Cursos e Treinamentos sobre Microcontroladores Presenciais e On-line. www.microgenios.com.br www.portalwebaula.com.br Fone: 11 5084-4518 | 3384-5598
Livro: Programao embarcada em Linguagem C Todos os direitos reservados. Proibida a reproduo total ou parcial, por qualquer meio ou processo, especialmente por sistemas grficos, microflmicos, fotogrficos, reprogrficos, fonogrficos, videogrficos, internet, e-books. Vedada a memorizao e/ou recuperao total ou parcial em qualquer sistema de processamento de dados e a incluso de qualquer parte da obra em qualquer programa jusciberntico. Essas proibies aplicam-se tambm as caractersticas grficas da obra e a sua editorao. A violao dos direitos autorais punvel como crime (art. 184 e pargrafos, do cdigo penal, cf. Lei n6. 895, de 17.12.80) com pena de priso e multa, conjuntamente com busca e apreenso e indenizaes diversas (artigos 102, 103 pargrafo nico, 104, 105, 106 e 107 itens 1, 2, 3 da lei n. 9.610, de 19/06/98, lei dos direitos autorais). Eventuais erratas estaro disponveis no site da Microgenios para download. Dedicatria: Dedico esse livro a Minha famlia e a equipe Microgenios Advertncia: As informaes e o material contido neste livro so fornecidos sem nenhuma garantia quer explcita, ou implcita, de que o uso de tais informaes conduzir sempre ao resultado desejado. Tanto o editor quanto o autor no podem ser responsabilizados por qualquer tipo de reivindicao atribuda a erros, omisses ou qualquer outra impreciso na informao ou material fornecido neste livro, e em nenhuma hiptese podem ser incriminados direta ou indiretamente por qualquer dano, perda, lucros cessantes, etc., devido ao uso destas informaes.
Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 2 de 42
Prefcio
Esta obra foi concebida com o intuito de preparar os estudantes, professores e profissionais da rea tcnica para a criao de projetos utilizando como ferramenta uma linguagem de programao de alto nvel, neste material escolhemos abordar a linguagem C, que uma das linguagens mais poderosas e portveis, fato este que a tornou amplamente utilizada, primeiramente para a criao de programas aplicativos para PC e mais tarde em sistemas embarcados microcontrolados. Trabalhar com uma linguagem de alto nvel, como C, para criar programas para microcontroladores, exige do profissional alm de um bom conhecimento de lgica de programao e habilidade com ela, um slido conhecimento da estrutura de hardware do microcontrolador a ser utilizado, de forma a extrair deste o mximo da funcionalidade de seus perifricos internos. Esta obra estuda o software, propiciando um conhecimento completo ao profissional e tornando-o apto a desenvolver suas prprias aplicaes, alm disso, vale a pena ressaltar a preocupao, por parte do Centro de Tecnologia Microgenios, em priorizar um estudo gradual e prtico, para isso usamos os kits de desenvolvimento, como base para a realizao de diversas experincias que complementam e fixam o aprendizado. Um ponto de destaque da abordagem do treinamento o uso e detalhamento da IDE de desenvolvimento MikroC (www.mikroe.com) a qual apesar das limitaes da verso de demonstrao gratuita mostra-se uma excelente ferramenta de desenvolvimento e simulao. De maneira alguma este material apresentado como nica fonte de estudo sobre o assunto, devendo aqueles que necessitarem se aprofundar nos tpicos aqui estudados buscar outras fontes de pesquisa. Por fim a equipe Microgenios agradece a ateno de todos e deseja bons estudos e projetos.
Fernando Simplicio de Sousa Fbio Perkowitsch Mulero Equipe Microgenios Cursos e Treinamentos sobre Microcontroladores Presenciais e On-line. www.microgenios.com.br www.portalwebaula.com.br Fone: 11 5084-4518 | 3384-5598 Deus seja louvado!
CAPTULO 1 INTRODUO A LINGUAGEM C ...............................................................6

Um pouco de histria .................................................... 6 Conceito ................................................................ 7 Compilador .............................................................. 7
CAPTULO 2 VARIVEIS ..................................................................................................8

O que so variveis? .................................................... 8 Tipos de dados .......................................................... 8 Modificadores de Tipo ................................................... 8 Declarao de variveis ................................................. 9
Variveis globais: .......................................................... 10 Variveis locais: ........................................................... 10
CAPTULO 3 TIPOS DE OPERADORES ........................................................................12

Os Operadores Aritmticos: .................................................. 12 Operadores Relacionais; ..................................................... 13 Operadores lgicos ou Booleanos ............................................. 13 Os operadores Bitwise (Bit a Bit) ........................................... 14 Operador AND (E) ............................................................ 14 O Operador OR (|) ........................................................... 14 O Operador XOR (^) .......................................................... 15 O Operador NOT (~) .......................................................... 15 Operador de deslocamento << >> .............................................. 15
CAPTULO 4 FORMAS E REPRESENTAO NUMRICAS E DE CARACTERES .....17

Representao decimal: ................................................. 17 Representao Hexadecimal: ............................................. 17 Representao octal: ................................................... 18 Exerccios de fixao: ................................................. 18
Representao Representao Representao Representao decimal: ...................................................... 18 binria: ...................................................... 18 hexadecimal: .................................................. 18 octal: ........................................................ 18
CAPTULO 5 MIKROC : CASE INSENSITIVE ................................................................19

Manipulao de bit no MikroC ........................................... 19
CAPTULO 6 COMO ESCREVER PROGRAMAS EM C .................................................20

Estrutura de um programa em C .......................................... 22
Anlise da estrutura do programa: ........................................... 26 Porque devemos criar sub-rotinas ? .......................................... 28
Prottipos de Funes .................................................. 28 Os identificadores ..................................................... 29
CAPTULO 7 ESTRUTURAS DE CONTROLE ................................................................29

O comando if (SE) ...................................................... 29 A estrutura if, else, if ............................................... 31 O comando switch ....................................................... 32
CAPTULO 8 ESTRUTURAS DE REPETIO ...............................................................33

O comando For .......................................................... 33 O lao while ........................................................... 36 O lao do - while ...................................................... 37 O comando break e continue ............................................. 37
Break........................................................................ 37 Continue..................................................................... 38
CAPTULO 9 PADRES DE FORMATAO DE CDIGO ...........................................39

Declarao de variveis: .................................................... 39 Declarao de funes: ...................................................... 39 Identao: .................................................................. 39
CAPTULO 10 ANEXOS ....................................................................................................1

TABELA ASCII ................................................................. 1
Captulo 1 Introduo a Linguagem C

Um pouco de histria
A primeira verso de C foi criada por Dennis Ritchie em 1972 nos laboratrios Bell para ser includo como um dos softwares a serem distribudos juntamente com o sistema operacional Unix do computador PDP-11, na equipe certificada por Ken Thompson. Pelo ponto de vista tcnico, o surgimento do C iniciou-se com a linguagem ALGOL 60, definida em 1960.O ALGOL era uma linguagem de alto nvel, que permitia ao programador trabalhar sem conhecimento especifico da mquina, sem se preocupar com os aspectos de como cada comando ou dado era armazenado ou processado na mquina. O ALGOL no teve sucesso, talvez por tentar ser alto nvel em uma poca em que a maioria dos sistemas operacionais exigiam do usurio um grande conhecimento de hardware. Em 1967 surgiu o CPL (Combined Programming Language) nas universidades de Londres e Cambridge com o objetivo, segundo a equipe do projeto, de simplificar o ALGOL. Da mesma forma que o ALGOL, o CPL no foi bem aceito, em especial pelos projetistas de sistemas operacionais que a consideravam difcil sua implementao. Ainda em 1967, em Cambridge, Martin Richards criou o BCPL (Basic CPL), uma simplificao do CPL, tentando manter apenas as partes funcionais do CPL. Em 1970, Ken Thompson, chefe da equipe que projetou o UNIX para o PDP11 do Bell Labs, implementou um compilador para uma verso mais reduzida do CPL. Que batizou de linguagem de B. Tanto o BCPL quanto o B mostraram-se muito limitadas, resolvendo apenas para certos tipos de problemas. Isto foi sentido especialmente na primeira verso do PDP11, lanado no mercado em 1971. Um dos fatores que levou a esta constatao foi a inteno do grupo responsvel pelo UNIX de reescrev-lo todo em uma linguagem de alto nvel, e para isto B era considerado lento. Diante desses problemas a Bell Labs encarregou o projetista Dennis Ritchie a projetar uma nova linguagem, sucessora do B, que viria ento, a ser chamada de C. A linguagem C buscou manter o poder de manipulao de hardware e ainda assim dar ao programador novas condies para o desenvolvimento de programas em reas diversas como, comercial, cientfica e engenharia. Por vrios anos (aproximadamente 10) a sintaxe(padronizao de cdigo) tida como padro da linguagem C foi aquela fornecida com o UNIX verso 5.0 do Bell Labs. A principal documentao deste padro encontra-se na publicao "The C Programming Language", de Brian Kernighan e Dennis Ritchie (K&R), tida como a "bblia da linguagem C". O mais interessante desta verso de C era que os programas-fonte criados para rodar em um tipo de computador podiam ser transportados e recompilados em outros sem grandes problemas. A esta caracterstica d-se o nome de portabilidade. Com ela, uma empresa que desenvolve um programa pode faz-lo rodar em diferentes computadores sem ter um elevado custo a cada vez que isto for feito. Em 1985, O ANSI (American National Standards Institute) estabeleceu um padro oficial de C o chamado "C ANSI" que adotado at hoje.
Conceito
C uma linguagem estruturada, ou seja, existe um modo de organizao para escrita do programa baseada no modelo ANSI C, a principal caracterstica dessa linguagem a compartilhamento do cdigo e dos dados. C chamada de linguagem de mdio nvel, pois une as facilidades de linguagens de alto nvel(BASIC, PASCAL) com manipulao de hardware somente obtida com a linguagem ASSEMBLY, mas mesmo tendo essas caractersticas uma linguagem de fcil uso e aprendizagem. A linguagem C "Case Sensitive", isto , ela faz a diferenciao das letras maisculas e minsculas EX: MAin() ou mAIn() diferente de main(), portanto utilize uma padronizao para escrita de seus cdigos
Compilador
A linguagem que seja os processadores, incluindo microcontroladores, entendem chamada: "cdigo de mquina", a partir dessa linguagem os processadores executam as tarefas programadas pelo programador. Mas como uma tarefa muito complicada e improdutiva escrever programas em "cdigo de mquina", foi criada uma ferramenta chamada compilador que nada mais que um tradutor que pega seu cdigo escrito em C e traduz para "cdigo de mquina".
Captulo 2 Variveis
Neste capitulo iremos aprender sobre variveis, aritmticos alem de estruturas de controle e deciso. operadores lgicos e
Para facilitar nossos estudos iremos adotar como padro os microcontroladores de 8 bits, mas todos os conhecimentos adquiridos nesse curso podero ser utilizados em qualquer tipo de processador ou microcontrolador. Para iniciarmos nossos estudos vamos falar sobre variveis.
O que so variveis?
Varivel, do ponto de vista da rea de programao, uma regio de memria previamente identificada que tem por finalidade armazenar os dados ou informaes de um programa por um determinado espao de tempo. Uma varivel limita-se a armazenar apenas um valor por vez.
Tipos de dados
Existem cinco tipos primitivos de dados na linguagem C: caractere (char), inteiro (int), ponto flutuante (float e double) e sem valor (void). A tabela abaixo representa o valor e a escala de cada tipo de dado em C. TIPO char int long float ou double void TAMANHO EM BITS TAMANHO EM BYTES INTERVALO 8 16 32 32 0 1 2 4 4 0 a 255 0 a 65535 0 a 4294967295 -1.5 * 1045 a +3.4 * 1038 nenhum valor
O tipo char pode ser utilizado tanto para manipulao de valores entre 0 e 255 quanto para representao de caracteres da tabela ASCII. Cada varivel do tipo char pode representar somente um caractere ASCII. O tipo int utilizado para representar nmeros inteiros de 16 bits (0 a 65535). Esses dois primeiros tipos so os mais utilizados em linguagem C. O tipo char e int representam nmeros inteiros e no podem ser utilizados para representar nmeros fracionrios. Para isso, deve ser utilizado o tipo float, tambm chamado de ponto flutuante. O tipo float deve ser evitado ao mximo e restrito apenas s operaes que realmente necessitarem de um tipo de dados como este.
Modificadores de Tipo
Podemos utilizar comandos especiais do C para obter outros tipos de dados. Esses comandos especiais so chamados de modificadores de tipo e so os seguintes: signed, unsigned, short, e long. O modificador de tipo signed utilizado para modificar um dado para que ele represente valores positivos e negativos. Este tipo opcional, pois na linguagem C a omisso do modificador unsigned o prprio compilador adota como padro o modificador signed. Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 8 de 42
O modificador unsigned indica somente com nmeros positivos.
ao
compilador
que
varivel
trabalhar
O modificador short utilizado para definir uma varivel com tamanho menor que o tipo modificado, ou seja, uma verso reduzida do tipo especificado. O modificador long utilizado para ampliar a magnitude de representao do tipo especificado. TIPO unsigned char (signed) char (signed) short (int) (unsigned) short (int) signed int unsigned int (signed) long int unsigned long int float double long double void TAMANHO EM BITS 8 8 8 8 16 16 32 32 32 32 32 RANGE 0 255 -128 +127 -128 +127 0 255 -32768 32767 0 65535 -2147483648 2147483647 0 4294967295 +/- 1.17549435082E-38 +/6.80564774407E38 +/- 1.17549435082E-38 +/6.80564774407E38 +/- 1.17549435082E-38 +/6.80564774407E38 sem valor
Obs: No caso da nossa ferramenta de trabalho, o MikroC, os tipos de float, double e long double so considerados do mesmo tipo.
Declarao de variveis
Definir uma varivel cri-la na memria (aloc-la), dar a ela um nome e especificar o tipo de dado que nela vai armazenar. Sintaxe para criao de uma varivel em C; <modificador> <tipo> nome_da_variavel; O tipo deve ser um tipo de dado vlido em C tais como: char, int, float, com ou sem seus modificadores, unsigned, signed, short e long. E nome_da_variavel o nome da varivel adotada pelo programador. As regras para a escrita de nomes de variveis e funes em C sero melhor detalhadas mais a frente. Em C, podemos declarar vrias variveis do mesmo tipo em um nica linha de programa, bastando apenas separ-las por vrgulas, acompanhe:
int soma ; unsigned char i,j,k ; float salrio; unsigned int idade; short int y; long caminho, estado; unsigned valor;
Outro aspecto importante da declarao das variveis o local onde so declaradas. Basicamente, uma varivel pode ser declarada em dois escopos distintos, o de acesso global e o de acesso local. Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 9 de 42
Variveis globais:
Essas variveis so declaradas fora das funes do programa, podendo ser acessadas em qualquer parte do programa. Exemplo:
int contador; char a; //define a varivel global "contador" como inteiro //define a varivel global "a" como char
void main() //funo principal do programa { contador = contador + 10 }
Vamos apresentar mais um exemplo de programa utilizando as variveis globais:

int contador; char a; //define a varivel global "contador" como inteiro //define a varivel global "a" como char
void subrotina () //funo de sub-rotina qualquer do programa { contador = contador - 20; a = 100; } void main() //funo principal do programa { contador = contador + 10; a = 55; }
Repare no programa exemplo acima que as variveis "contador" e "a" esto sendo manipuladas no corpo da funo main() e na funo subrotina(). Este tipo de manipulao de variveis somente possvel se declararmos como sendo do tipo GLOBAIS, ou seja, necessariamente devemos defini-las no corpo do programa (fora de qualquer funo do programa, inclusive a funo main()).
Variveis locais:
Ao contrrio das variveis globais, uma varivel local somente existe no escopo da funo em que foi declarada. Isto significa que uma varivel local somente existe enquanto a funo esta sendo executada. No momento que ocorre o retorno da funo, as variveis locais so descartadas; Acompanhe o exemplo abaixo:
void main() //funo principal do programa { int contador; //define a varivel local "contador" como int contador = contador + 10 }
Repare que a varivel "contador" foi declarada (criada) dentro da funo main(), as varivel locais somente ter validade dentro da funo que a declarou, neste caso, "contador" somente poder ser manipulada no programa dentro da funo main(). Acompanhe mais um exemplo de varivel local:
void subrotina () //funo de sub-rotina qualquer do programa { int tempo; tempo = tempo * 2; } void main() //funo principal do programa { int tempo; tempo = tempo / 2; }
Repare no programa exemplo acima que temos duas funes, a funo main() e a funo subrotina(). Dentro de cada uma dessas funes foi criada uma varivel chamada "tempo" do tipo int, essas variveis so locais e somente tem validade dentro da funo que a declarou, ou seja, a varivel "tempo" da funo subrotina() NO tem nenhuma ligao com a varivel "tempo" da funo main(), pois so variveis locais; Se por ventura cometermos o seguinte erro abaixo, acompanhe:
void subrotina () //funo de sub-rotina qualquer do programa { tempo = tempo * 2; } void main() //funo principal do programa { int tempo; }
Repare que a varivel "tempo" foi declarada unicamente dentro da funo main() e que seus dados esto sendo manipuladas por outra funo chamada subrotina(). Ao compilarmos este programa, certamente o compilador apresentar um erro de compilao nos informando que a varivel "tempo" no foi definida. Esse um erro comum que muitos programadores inexperientes cometem na linguagem C, pois esquecem que uma varivel local somente tem validade dentro da funo que a declarou. Podemos declarar variveis como parmetros formais de uma funo, que so tambm tratadas como variveis locais. Iremos estudar esse tipo de varivel quando estivermos falando de funes em nosso curso.
Captulo 3 Tipos de Operadores

A linguagem C faz uso de diversos operadores. Podemos classific-los em algumas categoria principais: aritmticos, relacionais, lgicos, lgicos bitwise(bit a bit) , outros.
Os Operadores Aritmticos:
Os operadores aritmticos so utilizados para efetuar operaes matemticas entre dados e so classificados em duas categorias, sendo binrio ou unrio. Os operadores binrios atuam em operaes de exponenciao, diviso, adio e subtrao. Os unrios atua na inverso de valores, atribuindo o sinal de positivo ou negativo. operador + * / % ++ -Adio e Subtrao Os operadores de adio e subtrao so muito simples de serem utilizados, acompanhe:
c d c a = = = = a d c d + + b; b; a; a + c;
ao Adio Subtrao ou menos unrio Multiplicao Diviso Resto da diviso inteira Incremento Decremento
Multiplicao e Diviso Os operadores assimilao;

c d c a = = = = a * b; d * d; c / a; (d * a) / c;
de
multiplicao
de
diviso,
em
C,
so
de
fcil
O operador % O operador % utilizado para retornar o mdulo(resto) de uma operao de diviso inteira. Vejamos um exemplo: 7 / 3 = 2, em uma diviso inteira, sendo o resto igual a 1. Assim, o valor de 7 / 3 = 2 e o valor de 7 % 3 = 1. O operador de Incremento ++ e Decremento --: O operador de incremento subtrair 1 de uma varivel. EX: C = C + 1; No exemplo acima a varivel C foi incrementada em 1 unidade. Podemos ter o mesmo resultado da operao acima atravs do operador de incremento ++ que termos o mesmo resultado; Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 12 de 42 e decremento so utilizados para somar 1 ou
c++; c++; d--;
//equivale a c = c + 1; //incrementa em 1 unidade o valor da varivel C //incrementa em 1 unidade o valor da varivel D
Acompanhe o exemplo abaixo:

variavel_a = variavel_b++;
Observe que o valor da varivel variavel_b atribudo a varivel variavel_a, e logo aps isso, o valor de variavel_b incrementado em 1 unidade: Isso tambm vlido para o comando de decremento --.
variavel_a = variavel_b--;
Observe que o valor da varivel variavel_b atribudo a varivel variavel_a, e logo aps isso, o valor de variavel_b decrementado em 1 unidade: Devemos tomar alguns cuidados em C com relao aos operadores de incremento e decremento: vejam;
variavel_a = variavel_b++;
diferente de
variavel_a = ++variavel_b;
Note que na primeira linha de comando, variavel_b incrementada em 1 depois que atribuiu seu valor a varivel variavel_a. Na segunda linha, o valor da variavel_b incrementada em 1 antes de atribuir seu valor a varivel variavel_a. Vejamos um exemplo:
int a = b = c = a, b, c; 0; a++; ++a;
Neste caso, aps a execuo dos trs comandos, o valor de "a" ser igual a 2, o valor da varivel "b" ser igual a 0 e o valor da varivel "c" ser igual a 2.
Operadores Relacionais;
Os operadores relacionais servem para comparar expresses. So muito utilizado para comparar condies de controle do fluxo de execuo de programas. Operador > >= < <= == != Operao realizada maior que maior ou igual a menor que menor ou igual a igual a diferente de construir expresses
Estes operadores sero muito utilizado para condicionais, como veremos mais adiante em nosso curso.
Operadores lgicos ou Booleanos

Os operadores lgicos ou booleanos construes de testes condicionais. Operador so de grande importncia para
Operao realizada
&& || !
AND (E) OR (OU) NOT (NO)
Com esses operadores podemos relacionar diversas condies diferentes em um mesmo teste lgico.
if (c = 10 && b = 5) c = 5; /* condio verdadeira de teste: se a varivel "c" for igual a 10 e a varivel b = 5 ento "c" assumir o valor 5.*/ if (c>0 || a==0) b = a; /* condio verdadeira de teste: se a varivel "c" for maior que 0 ou a for igual a 0 ento "b" igual a varivel "a".*/ if (!a) b = c; /* condio verdadeira de teste: se a varivel "a" for igual a 0, a varivel "b" assumir o valor da varivel "c". Note que estamos utilizando o operador de negao "!" NOT, por esse motivo a varivel "a" assumir o valor verdadeiro, j que possui valor 0.*/
Os operadores Bitwise (Bit a Bit)

Os operadores Bit a Bit so utilizados para realizar operaes lgicas entre elementos ou variveis. Operador & | ^ ~ >> << Operao realizada AND (E) OR (OU) XOR (OU exclusiva) NOT (complemento de um) deslocamento direita deslocamento esquerda
Operador AND (E)

O operador lgico AND realiza operao separadamente para cada bit dos operandos. Utilizamos muito o operando AND como "mscara" de um byte, para habilitar ou desabilitar somente os bits que desejamos. Esse operando funciona da seguinte maneira, verifica se nos dois operandos um respectivo bit, se nos dois forem 1 coloca no resultado 1 no bit respectivo, caso contrario coloca 0.Veja um exemplo:
int a = b = a = a, b; 100; 28; a & b;
A operao AND ocorrer da seguinte maneira: a = 100 ----> AND (&) b = 28 ----> 00011100 01100100
Resultado= 00000100 ou 4 decimal
O Operador OR (|)
O operador OR muito similar ao operador AND, sua operao tambm realizada para cada bit do operando. Esse operando funciona da seguinte maneira, verifica se nos dois operandos um respectivo bit, se em qualquer dos dois for 1 coloca no resultado 1 no bit respectivo, caso contrario coloca 0. Exemplo:
int a = b = a =
a, b; 100; 28; a | b;
A operao OR ocorrer da seguinte maneira: a = 100 ----> OR (|) b = 28 ----> 00011100 01100100
Resultado=01111100 ou 124 decimal
O Operador XOR (^)

O operador XOR so muito utilizado em funes de comparao de valores, pois em uma operao lgica, o resultado somente ser verdadeiro (nvel lgico 1) se um e somente um deles for verdadeiro (nvel 1). Esse operando funciona da seguinte maneira, verifica se nos dois operandos um respectivo bit, se nos dois forem diferentes coloca no resultado 1 no bit respectivo, caso contrario coloca 0. Exemplo:
int a = b = a = a, b; 100; 28; a ^ b;
A operao OR ocorrer da seguinte maneira: a = 100 ----> XOR (^) b = 28 ----> 00011100 01100100
Resultado=01111000 ou 120 decimal
O Operador NOT (~)

O operador NOT inverte o estado de cada bit do operando em uma operao. Exemplo:
int a = b = b = c = a, b, c; 1; 240; ~a ~b
A operao OR ocorrer da seguinte maneira: a = 0B00000001; b = 0B11110000; NOT de "a" ----> NOT de "b" ----> 0b11111110; 0b00001111;
Operador de deslocamento << >>

O operador >> desloca para a direita os bits de uma varivel um determinado nmero de vezes. Exemplo:
int a = b = b = c = a, b, c; 10; 10; a >> 1; b << 5;
No exemplo acima, os valores dos bits da varivel "a" foram deslocados 2 vezes para a direita, enquanto os bits da varivel b foram deslocados 5 vezes para a esquerda. Teremos como resultado: varivel a; >> // ----> 00000101 - valor 5 em binrio // ----> 00001010 - valor 10 em binrio
Observe que o valor aps deslocamento passa a ser agora 5 em binrio. A descrio do operador (>>), deslocamento direita, anloga ao operador deslocamento esquerda (>>), com ressalva de que os bits sero deslocados esquerda. Quando utilizamos (>>) deslocamento direita o valor do 8 bit ser propagado, ou melhor, deslocado N vezes. Exemplo 1: Vamos rotacionar o valor da varivel a 5 vezes o seguinte nmero para a direita e salvar em b. b = a >> 5; varivel a; >> // ----> 1111 1000 Exemplo 2: Vamos rotacionar para a esquerda o valor da varivel a 4 vezes, e salvar em b. b = a << 4; varivel a; >> // ----> 1110 0000 - valor 224 decimal // ----> 1101 1110 - valor 222 em decimal - valor 248 decimal // ----> 1000 0000 - valor 64 em decimal
Captulo 4 Formas e representao numricas e de caracteres

No compilador MikroC podemos manipular dados do tipo: decimal, binrio, hexadecimais e octal. Podemos representar um valor numrico de diversas formas. Para exemplificar, vamos supor o que desejamos carregar o valor 187 no registrador PORTB no PIC utilizando o MikroC, acompanhe:
Representao decimal:
Para representarmos um nmero em decimal nenhuma abreviatura, conforme o linha abaixo:
PORTB = 187; //representao decimal
basta
colocar
seu
valor
sem
NOTA: NUNCA DEVEMOS REPRESENTAR UM NMERO DECIMAL INICIANDO COM 0 (ZERO), POIS MIKROC INTERPRETAR O NMERO COMO OCTAL. EX:
PORTB = 25; // (25 representado em decimal)
diferente de
PORTB = 025; // (025 representado em octal)
Representao Hexadecimal:
Para representar um nmero em hexadecimal devemos colocar o prefixo 0x (ou 0X) antes do nmero hexadecimal. (0 a F)
PORTB = 0xBB; //representao hexadecimal do numero 187 decimal
ou
PORTB = 0Xbb; //representao hexadecimal do numero 187 decimal Representao binria:
Para representarmos um nmero em binrio devemos colocar o prefixo 0b (ou 0B) antes do nmero em binrio.
PORTB = 0b10111011; //representao binria do nmero 187 decimal
ou
PORTB = 0B10111011; //representao binria do nmero 187 decimal
A representao binria de um nmero ocorre da seguinte forma: 0 B 1 RB7 MSB 0 RB6 1 RB5 1 RB4 1 RB3 0 RB2 1 RB1 1 RB0 LSB
Observe que na representao binria de um nmero, o bit mais significativo fica ao lado do prefixo 0b. No confunda de forma alguma a construo e as
representaes de um nmero binrio, caso contrrio seu programa no funcionar corretamente.
Representao octal:
O sistema octal no um sistema muito difundido nos dias atuais. Apesar do compilador MikroC suportar esse tipo de representao numrica, somente devemos utiliz-la quando for realmente necessrio. Para representar um nmero octal necessrio colocar o prefixo 0 (zero) antes do valor numrico octal.
portd = 0273; //representao octal do nmero 187 em decimal
Exerccios de fixao:
Gostaramos de enviar aos pinos do PORTB os seguintes estados;
RB0 = 0; RB1 = 1; RB2 = 1; RB3 = 0; RB4 = 0; RB5 = 1; RB6 = 0; RB7 = 0
Qual o valor numrico que devemos colocar na instruo abaixo para representar os estados dos pinos do PORTB. Obedea as representaes numricas solicitadas:
Representao decimal:
PORTB = 38;
Representao binria:
PORTB = 0b00100110;
Representao hexadecimal:
PORTB = 0x26;
Representao octal:
PORTB = 046;
Captulo 5 MikroC : Case Insensitive

Diferente do padro ANSI C, No MikroC podemos utilizar maisculos e minsculos no programa (case insensitive). Acompanhe: contador, Contador e COnTadOR So interpretados como sendo a mesma palavra. (esse recurso particularidade do MikroC e no pertence ao padro ANSI C Standart). uma caracteres
NOTA: COMANDOS QUE FAZEM PARTE DA ESTRUTURA DO C, COMO POR EXEMPLO: IF, WHILE, FOR, SWITH , VOID MAIN, ENTRE OUTROS, OBRIGATRIAMENTE DEVERO SER DECLARADOS EM MNSCULO.
Manipulao de bit no MikroC

Podemos manipular os bits de registradores do PIC de diversas formas no compilador MikroC Podemos manipular os bits dos registradores do PIC da seguinte maneira:
PORTA.F5 = 0; PORTD.F7 = 1; TRISB.RB0 = 1; T0CON.PSA = 0; // // // // -->> -->> -->> -->> faz faz faz faz referncia referncia referencia referncia ao ao ao ao pino RA5 do PIC. pino RD7 do PIC. bit 0 do registrador TRISB bit 3
OBS: No so todos os registradores que permitem acesso direto ao seus bits.
Captulo 6 Como escrever programas em C

Acompanhe o exemplo abaixo:
//Primeiro Programa /* Programa Pisca-Pisca (1 segundo) Este programa tem por objetivo ascender e apagar um led conectado no pino RB0 do PIC em intervalos de 1 segundo aproximadamente; Curso Online: Microcontroladores PIC - Programao em C */ void main() { TRISB = 0; //define PORTB como sada PORTB = 0; //coloca nvel lgico 0 em todos os pinos do PORTB while(1) { PORTB.F0 = 1; Delay_ms(1000); PORTB.F0 = 0; Delay_1sec(); } }
// // // //
Coloca pino RB0 em 1 Aguarda 1000 ms (milisegundos) Coloca pino RB0 em 0 Aguarda 1 segundo
Vejamos o significado de cada linha de programa: A primeira linha de programa:

//Primeiro Programa
chamada de comentrio. Os comentrios so importantes para documentar o programa. Podemos adicionar comentrios em nosso programa de duas maneiras: Atravs de comentrios de linhas simples: quando queremos comentar apenas uma linha de programa, iniciamos os comentrios com os caracteres " // " (igual a linha do programa anterior). Esses tipo de comentrio no faz parte da padronizao ANSI original, mas atualmente encontrado em vrios compiladores. Atravs de comentrios de mltiplas linhas: podemos comentar linhas ou blocos de cdigo de programa utilizando a seqncia de caracteres "/* " para iniciar o comentrio e a seqncia "*/" para terminar o comentrio.
/* Programa Pisca -Pisca Este programa tem por objetivo ascender e apagar um led conectado no pino RB0 do PIC em intervalos de 1 segundo aproximadamente; Curso Online: Microcontroladores PIC - Programao em C */
Na prxima linha temos:

void main()
A declarao main() especifica o nome da funo. A funo main(), na linguagem C, sempre a primeira a ser executada. O programa termina quando for encerrada a execuo da funo main(). Uma funo, em C, nada mais do que um conjunto de instrues que pode ser executada a partir de qualquer ponto do programa. Utilizamos o sinal de abertura de chave "{" para iniciar uma funo e o sinal de fechamento de chave "}" para finalizar a funo. Todas as instrues devem estar dentro das chaves que iniciam e terminam a funo e so executadas na ordem em que as escrevemos.
No caso deste programa exemplo, ela no recebe nenhum parmetro e tambm no retorna parmetro nenhum. Isto fica explcito atravs da palavra-chave void escrita na frente do programa. As funes e as suas caractersticas sero apresentadas em detalhes mais adiante em nosso curso; Na prxima linha de programa encontramos:
TRISB = 0; //define PORTB como sada PORTB = 0; //coloca nvel lgico 0 em todos os pinos do PORTB
O comando TRISB define o sentido de acionamento do PORTB do PIC. Neste exemplo, TRISB = 0, logo o PORTB foi programado como sada. O comando PORTB = 0 coloca nvel lgico 0 em RB0 a RB7. As instrues C so sempre encerradas por um ponto-e-vrgula ( ; ). O ponto-e-vrgula parte da instruo e no um simples separador e devemos ao final de cada instruo colocar o acrscimo de um ponto-vrgula ;. Na prxima linha temos:
while(1)
Este um comando de controle utilizado na repetio de um determinado bloco de instruo. O bloco de instruo ser executado repetidamente enquanto o condio for verdadeira, ou seja, for diferente de zero. No nosso exemplo, o valor 1 utilizado no comando while garante que a condio seja sempre verdadeira. Estudaremos mais sobre o comando while mais adiante no curso; Os comandos a seguir pertencem ao bloco da instruo while;
{ PORTB.F0 = 1; Delay_ms(1000); PORTB.F0 = 0; Delay_1sec(); } // // // // Coloca pino RB0 em 1 Aguarda 1000 ms (milisegundos) Coloca pino RB0 em 0 Aguarda 1 segundo
Como no temos nenhum comando que interrompa o lao while, os blocos de comandos apresentados sero executados indefinidamente at que o processador seja desligado ou reiniciado. A operao PORTB.F0 = 1 faz com que o pino RB0 do PORTB seja colocado em nvel lgico 1; Para se referir a um pino das portas do PIC, PORTA, PORTB, PORTC, PORTD, PORTE, devemos apresentar o nome do porta, mais o ponto ".", mais a inicial "f" e o nmero do pino correspondente. Exemplo:
PORTB.F0 = 0; // Estamos nos referindo ao pino RB0 do PORTB PORTD.F5 = 1; // Estamos nos referindo ao pino RD5 do PORTD PORTE.F1 = 1; // Estamos nos referindo ao pino RE1 do PORTE
A linha de programa seguinte, Delay_ms(1000), uma funo interna do compilador MikroC utilizada para gerar atrasos em escala de milissegundos. No nosso exemplo, o comando ir gerar atraso de 1000 milessegundos, ou seja, 1 segundo. A operao nvel lgico 0; PORTB.F0 = 0 faz com que o pino RB0 do PORTB seja colocado em
A linha de programa seguinte, Delay_1seg(), tem a mesma funo de gerar atrasos que a funo estudada anteriormente, sua diferena que o valor do atraso passa a ser de 1 segundo aproximadamente.
Desta forma, ao programarmos o PIC com o programa exemplo, o pino RB0 ficar mudando de estado lgico 1 e 0 a cada 1 segundo, NOTA: COLOQUE EM PRTICA ESTE PEQUENO PROJETO. COPIE E COMPILE ESTE PROGRAMA EXEMPLO NO COMPILADOR MIKROC, ISSO LHE AJUDAR NOS SEUS ESTUDOS. Vamos estudar mais um programa: Acompanhe:
//Segundo Programa /* Programa Pisca -Pisca (100 milisegundos) Este programa tem por objetivo ascender e apagar um led conectado no pino RB0 do PIC em intervalos de 1 segundo aproximadamente; Curso Online: Microcontroladores PIC - Programao em C */ void main() { TRISB = 0; //define PORTB como saida PORTB = 0; //coloca nvel lgico 0 em todos os pinos do PORTB TRISD= 0; //define PORTB como saida PORTD= 0; //coloca nvel lgico 0 em todos os pinos do PORTD while(1) { PORTB = 255; TRISD = 255; Delay_ms(100); PORTB = 0; PORTD = 0; Delay_ms(100); } }
//seta todos os pinos do port //seta todos os pinos do portd //aguarda 1000 ms (milisegundos) //resseta todos os pinos do PORTB //resseta todos os pinos do PORTD //aguarda 1000 ms (milisegundos)
O programa acima tem por objetivo piscar infinitamente o PORTB e PORTD do PIC em intervalos de 100 milissegundos. Suas caractersticas so parecidas com a do programa anterior, sua nica diferena est no tratamento das portas;
PORTB = 255; PORTB = 255; //seta todos os pinos do PORTB //seta todos os pinos do PORTD
Estrutura de um programa em C
Todo programa escrito em C consiste em uma ou mais funes, tendo como particularidade deste fato a possibilidade de construir programas modulares e estruturados. O programa principal escrito em C uma funo. O C uma linguagem extremamente estruturada e exige do programador domnio adequado de tal conceito. Veja a seguir, o menor programa possvel de ser escrito em C:
void main() // a primeira e principal funo a ser executada { //inicia ou abre o corpo da funo } //finaliza ou fecha o corpo da funo
A funo main() a principal instruo a ser considerada em um programa escrito na linguagem C e deve estar presente em algum lugar do programa, pois ela que marca o ponto de inicializao do processo de execuo do programa. A seguir veremos um modelo de escrita de um programa em C, com todas as definies e comentrios. Acompanhe:
[blocos de comentrios de grande importncia na documentao do programa] [<definies de pre-processamento - cabealhos>] [<declarao das variveis globais>] [<tipo>] nome_da_funcao([<parmetros>]) [<declarao de parmetros>] { /* Este trecho reservado para o corpo da funo_nome, com a declarao de suas variveis locais, seus comandos e funes de trabalho. Esta funo pode ser chamada de sub-rotina do programa. */ [return ou return() ou return(valor)] } void main([<parmetros>]) { /* Este trecho reservado para o corpo da funo, com a declarao de suas variveis locais, seus comandos e funes de trabalho. Aqui esto os primeiros comandos que sero executados no programa. */ }
Toda a informao situada entre colchetes "[" e "]" indica informaes que podem ou no estar presentes em um programa. Vamos comentar cada bloco de programa: O primeiro bloco: Os comentrios gerais
[ blocos de comentrios de grande importncia na documentao do programa]
O programador poder inserir ou no o comentrios em seu programa. Por conveno, importante colocarmos sempre os cabealhos nos programas, pois a apresentao do programa. O segundo bloco: O cabealho
[<definies de pr-processamento - cabealhos>] [<declarao das variveis globais>]
Neste trecho do programas podemos declarar todo o cabealho do nosso programa assim como definir variveis globais que podero ser utilizadas em todas as funes do nosso programa. Exemplo de cabealho:
#include "minhas_funcoes.h" /* inclumos em nosso programa as bibliotecas de funes que esto no arquivo minhas_funcoes.h. */ int a ; //definimos a varivel a como inteiro e como sendo global int b; //definimos a varivel b como inteiro e como sendo global
O terceiro bloco: As funes de subrotinas
[<tipo>] nome_da_funcao([<parmetros>]) [<declarao de parmentros>] { /* Este trecho reservado para o corpo da nome_da_funcao, com a declarao de suas variveis locais, seus comandos e funes de trabalho. Esta funo pode ser chamada de sub-rotina do programa. */ [return ou return() ou return(valor)] }
Este ltimo bloco trata-se de uma funo que carrega o nome nome_da_funcao. Seu tipo pode ou no ser explicitado. Caso no seja, qualquer funo ser do tipo int por default. Esta funo no faz parte da funo main() e dever ser chamada em algum momento pelas funo main() ou por outra funo para seja executados seus comandos. Podemos no momento da chamada da funo enviar parmetros (estudaremos mais sobre as funes a seguir). No final da funo, encontramos o comando return, cujo objetivo retornar a funo que a chamou um valor de retorno da funo. No obrigatrio o uso do comando return, caso no precisemos retornar nenhum valor na funo. Exemplo de funo de subrotina:
void funcao(void) { PORTB = ~ PORTB; return; }
O quarto bloco: A funo main()

void main([<parmetros>]) { /* Este trecho reservado para o corpo da funo, com a declarao de suas variveis locais, seus comandos e funes de trabalho. Aqui esto os primeiros comandos que sero executados no programa. */ }
A funo main() ser a primeira a ser executada pelo processador. Junto a funo main(), temos o modificador de tipo void que tem a funo de declarar que a funo main() no deve retornar nenhum valor. A manipulao de programas em linguagem C para microcontroladores diferente de trabalharmos com programas para PC's, pois nos computadores PC's existem o sistema operacional que receber o retorno da funo main(). Nos microcontroladores, como no possumos um sistema operacional rodando em paralelo com o programa, no podemos retornar nenhum valor na funo main(). Para este caso, devemos sempre iniciar a funo main() com o modificador de tipo nulo void. Exemplo de funo main():
void main() { PORTB = 0; TRISB = 0; PORTB = ~PORTB; Delay_ms(1000); }
NOTA: ANTES DE CHAMARMOS QUALQUER FUNO DO PROGRAMA, COMO POR EXEMPLO EXECUTAR UMA SUBROTINA QUALQUER, DEVEMOS GARANTIR QUE NOSSO COMPILADOR J A RECONHECEU. NO MOMENTO DA COMPILAO, O PR-COMPILADOR, RESPONSVEL PELO RECONHECIMENTO DA ESTRUTURA DO PROGRAMA, NO PODE ENCONTRAR UMA CHAMADA DE UMA FUNO SEM ANTES DE RECONHECE-LA. PARA EVITAR ESSE ERRO DE COMPILAO, RECOMENDADO QUE COLOQUEMOS O PROTTIPO DE FUNO NO PROGRAMA A CADA INSERO DE UMA NOVA FUNO. Vamos analisar um exemplo de programa em linguagem C disponvel no prprio compilador MikroC como exemplo. Em princpio, no quero que voc entenda o funcionamento do programa, mas quero que voc identifique os principais blocos de funes desse programa. Vejamos:
/* * Project name: PWM_Test_01 (PWM library Demonstration) * Copyright: (c) MikroElektronika, 2009. * Test configuration: MCU: P18F4520 Dev.Board: BIGPIC3 Oscillator: HS, 10.0 MHz Ext. Modules: SW: MikroC PRO v2.50 * NOTES: None. */ unsigned short j, oj; void InitMain() { PORTB = 0; TRISB = 0; ADCON1 |= 0x0F; PORTA = 255; TRISA = 255; PORTC = 0x00; TRISC = 0; PWM1_Init(5000); }//~ void main() { initMain(); j = 127; oj = 0; PWM1_Start(); while (1) { if (Button(&PORTA, 0,1,1)) j++ ; if (Button(&PORTA, 1,1,1)) j-- ; if (oj != j) { PWM1_Set_Duty(j); oj = j; PORTB = oj; } Delay_ms(200); } }//~!
Anlise da estrutura do programa:

Primeiro bloco: Os comentrios
/* * Project name: PWM_Test_01 (PWM library Demonstration) * Copyright: (c) MikroElektronika, 2009. * Test configuration: MCU: P18F4520 Dev.Board: BIGPIC3 Oscillator: HS, 10.0 MHz Ext. Modules: SW: MikroC PRO v2.50 * NOTES: None. */
Este bloco do programa so comentrios e so responsvel pela "documental do programa". No momento da compilao, esses textos descartados pelo compilador. Segundo Bloco: O cabealho
unsigned short j, oj;
parte sero
Neste trecho do programas definido o cabealho do programa, e nele foi declarado as varivel globais do programa. Terceiro Bloco: as sub-rotinas
void InitMain() { PORTB = 0; TRISB = 0; ADCON1 |= 0x0F; PORTA = 255; TRISA = 255; PORTC = 0x00; TRISC = 0; PWM1_Init(5000); }//~
Esta funo uma sub-rotina do programa, e foi chamada pelo programador de InitMain(); Quarto Bloco: as funo main()
void main() { initMain(); j = 127; oj = 0; PWM1_Start(); while (1) { if (Button(&PORTA, 0,1,1)) j++ ; if (Button(&PORTA, 1,1,1)) j-- ; if (oj != j) { PWM1_Set_Duty(j); oj = j; PORTB = oj; } Delay_ms(200); } }//~!
Apesar do funo main() ser a ltima na ordem de escrita do programa, ela ser a primeira funo a ser executada pelo processador.
Porque devemos criar sub-rotinas ?

Para permitir o reaproveitamento de cdigo j construdo(por voc ou por outros programadores); Para evitar que um trecho de cdigo que seja repetido vrias vezes dentro de um mesmo programa; Para permitir a alterao de um trecho de cdigo de uma forma mais rpida. Com o uso de uma funo preciso alterar apenas dentro da funo que se deseja; Para que os blocos do programa conseqncia, mais difceis de entender; no fiquem grandes demais e, por
Para facilitar a leitura do programa-fonte de uma forma mais fcil; Para separar o programa em partes (blocos) que possam ser logicamente compreendidos de forma isolada.
Prottipos de Funes
No podemos usar uma funo sem declar-la previamente. Trata-se duma instruo geralmente colocada no incio do programa ou do arquivo, obrigatoriamente antecedendo a definio e a chamada da funo. O prottipo informa ao compilador o tipo que a funo retorna, o nome da funo, bem como os parmetros que ela recebe. Eis um exemplo:
void minha_rotina (); /*prottipo de funo, esta linha de programa deve ser colocada no topo do programa , junto com as declaraes;*/ void main() { // aqui esta meu programa principal } //***************** funo de subrotina ******************** void minha_rotina() { //aqui esta os comandos da sua subrotina }
Conforme podemos ver no programa acima, a funo de sub-rotina minha_rotina() ficou em depois da funo main(), nesse caso, necessariamente, devemos colocar o prottipo de funo (linha de programa com o cabealho da funo de sub-rotina) no topo do programa, caso contrrio teremos erro de compilao pois o no podemos utilizar nenhuma funo antes de declar-la. No caso de colocarmos as funes de sub-rotinas antes da funo main() no programa, no precisamos declarar os prottipos de funes no programa.
Os identificadores
A linguagem C define identificadores como sendo nomes usados para se fazer referncia a entidades do programa (variveis, funes, rtulos, etc.) definidas pelo programador. Em C, um identificador composto de um ou mais caracteres, sendo que, para identificadores internos, os 31 primeiros so significativos. O primeiro caractere deve ser uma letra ou um sublinha (_) e os caracteres subseqentes devem ser letras, nmeros ou sublinhas. Eis aqui alguns exemplos de identificadores corretos e incorretos: Corretos cont Incorretos 1cont Descrio Um identificador deve sempre comear com uma letra do alfabeto, nunca por um nmero. Um identificador no pode conter acentos (, ^, ~, ) Um identificador no pode conter simbolos (-)
valor23 totalGeral
al valor-total
Isto quer dizer que se duas variveis tm em comum os 31 primeiros caracteres e diferem apenas a partir do trigsimo segundo, o compilador C no ser capaz de distingui-Ias. Por exemplo, esses dois identificadores so iguais: isto_e_um_exemplo_de_um_nome_longo isto_e_um_exemplo_de_um_nome_longo_tambem
Captulo 7 Estruturas de Controle

As estruturas de controle so usadas nos programas em lugares em que necessitamos que a mquina faa repetidas operaes ou necessite de tomadas de deciso.
O comando if (SE)
O if (SE, em portugus) uma estrutura de tomada de deciso baseada no resultado lgico de um teste. Sua forma geral :
if (condio) comando;
ou
if (condio) { blocos de comandos};
Em C, qualquer nmero diferente de zero tido como verdadeiro. O que significa que uma condio em C s falsa, quando os resultados dos operadores que aplicados for zero (0). Qualquer outro valor, mesmo negativo, considerado como verdadeiro ou no zero. No comando If, caso a condio seja verdadeira (diferente de zero), o comando, ou blocos de comandos sero executados, caso contrrio, quando a condio for falsa (0 zero) o comando ser ignorado. Exemplo:
void main() { char a = 10; char b = 0 ; if (a) b--; }
A varivel "a" foi atribuda o valor 10, que diferente de zero (0). Conseqentemente, o comando if ser executado e a condio de decremento da varivel b ser executado;
if (a) b--;
tambm possvel executar outro comando ou bloco de comandos no caso da condio ser avaliada como falsa, para isso utilizamos os recursos do comando if - else. Acompanhe seu formato geral:
if (expresso) comando 1 else comando 2
Exemplo:
if (x > 5) z = 10; else z = 20;
A linha de comando if (x > 5) tem por funo verificar se a condio x>5 verdadeira, caso seja verdadeira, a linha de programa z = 10 ser executada. Caso a condio do comando IF seja falsa, ou seja, se "x" for menor que 5, ento a linha de comando z = 20 ser executada. Todos os operadores do C podem ser includos no teste de uma condio, expresses vlidas da linguagem C podem ser avaliadas para a gerao de um resultado booleano na estrutura if. As expresses seguintes so vlidas e seus resultados dependero do valor de suas variveis. Exemplo:
if (a > b) b = a; /* se a expresso a > b for verdadeira, a varivel "b" assume o valor da "a"*/ if (b < a) b = 10; /* se a expresso a < b for verdadeira, a varivel "b" assume o valor 10*/ if (a != b) b = 55; /* se a expresso a !=b (diferente) for verdadeira, a varivel "b" assume o valor 55*/ if ( (a + b) > (b + d) ) b++; /* se a expresso (a + b) > (b + d) for verdadeira, a varivel "b" ser incrementada em uma unidade.*/
Observaes importantes: O operador de atribuio de igualdade (=) em C diferente do operador relacional de igualdade (==). Para testar a condio de uma varivel qualquer, utilizamos o operador relacional de igualdade (==). Acompanhe:
if (a == b) c = 10;
diferente de
if (a = b) c = 10;
A condio (a == b) faz uma comparao entre as duas variveis, caso a condio seja verdadeira, a varivel "C" assumir o valor 10; O comando if seguinte, possui uma expresso de atribuio de igualdade (a = b). O compilador ao compilar este comando, ir primeiramente atribuir a varivel "a" o valor contido em "b", e depois disso, verificar se a condio no zero, caso seja verdadeiro o resultado (diferente de zero), a varivel "c" assumir o valor 10; No comando if para adicionarmos blocos de programas, faz necessrio o uso dos smbolos abre-chaves ({) e fecha-chaves (}). Exemplo:
if ( PORTB == PORTC) { //blocos de comandos a++; PORTB.F0 = 1; d = c + e; }
A estrutura if, else, if

Podemos criar arranjos (nesting) de comandos atravs da estrutura if, else, if. Os arranjos so criados bastando colocar estruturas if aninhadas com outras estruturas if. Seu formato geral :
if (condio1) declarao 1; else if (condio2) declarao 2; else if (condio3) declarao 3; else if (condio4) declarao 4;
Exemplo:
void main() { int contador = 10; int sinal = 5; if (contador > sinal) sinal++; else if (contador < sinal) sinal--; else if (contador == sinal) sinal = 0; }
Podemos tambm chaves ( { e } ). Exemplo:

void main() { int contador = 10; int sinal = 5;
executar
blocos
de
comandos
utilizando
os
recursos
das
if (contador > sinal) { /*utilizao de blocos de comando na estrutura if-else-if*/ sinal++; contador = 20; } else if (contador < sinal) { sinal--; contador = 15; }else if (contador == sinal) sinal = 0; }
A estrutura if uma das mais utilizadas para tomada de decises lgicas. Iremos utiliz-la em vrios programas que desenvolveremos durante nosso curso.
O comando switch
O comando switch uma forma mais clara e elegante de tomar deciso dentro de um programa em C. Diferente do comando if, a estrutura switch no aceita expresso para a tomada de deciso, mas s aceita constante.
switch (varivel) { case constante1: declarao1A; declarao1B; declarao1N; break; case constante2: declarao2A; declarao2B; declarao2N; break; default; declarao_default; }
O valor da varivel no comando switch comparada contra as constantes especificadas pela clusula case. Caso a varivel e a constante possuam valores iguais, os comandos seguinte a clusula case sero executados. Caso no tenha nenhuma constante com o mesmo valor da varivel, ento os comandos especificados pela clusula default sero executados. Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 32 de 42
Acompanhe o exemplo:
void main() { int contador = 10; int sinal = 5; switch(contador) { case 2: sinal++; break; case 1: sinal = 2; break; case 10: contador--; break; default: sinal = 0; } }
No exemplo de acima, a varivel contador ser comparada s constantes 2, 1 e 10. Como a varivel contador possui o valor 10, conseqentemente o comando que ser executado no exemplo acima case 10: contador--; (decrementa a varivel contador). A clusula break possui a funo de encerrar uma seqncia de comandos de uma clusula case. A clusula default o ltimo comando switch.
Captulo 8 Estruturas de Repetio

Os laos de repetio servem para repetir uma ou mais vezes determinada instruo ou blocos de instrues. Existem basicamente trs tipos de estruturas de repetio na linguagem C: for while do - while
A estrutura for basicamente utilizada para laos finitos de contagem, normalmente utilizando uma varivel de controle da contagem. A estrutura while basicamente utilizado para repetio de um determinado conjunto de instruo enquanto uma condio for verdadeira. O comando do - while similar estrutura while, diferenciando apenas o momento que analisada a condio. Vamos conhecer sobre cada estrutura de repetio, acompanhe:
O comando For
O lao for utilizado quando necessitamos de um ciclo de repeties controlado, pois em sua declarao podemos inicializar e incrementar ou decrementar a varivel de controle. Antes de serem executados os comandos do lao For-next, primeiramente avaliada a condio do teste. Caso seja verdadeira, so executados os comandos do lao. A cada ciclo que executado o fao for, a varivel de controle ser incrementada ou decrementada no valor programado no incremento.
Veja a estrutura do comando For :

for (inicializao ; condio ; incremento/decremento ) comando;
ou
for (inicializao ; condio ; incremento/decremento) { ... comandoA1; comandoA2; ... }
em que: inicializao: expresso vlida utilizada normalmente para inicializao da varivel de controle do lao. condio: condio para que decide pela continuidade ou no do lao de repetio, enquanto esta condio for verdadeira, o lao for permanecer em execuo. Incremento/decremento: "valor incrementado em" a cada repetio do lao for. Exemplo:
int contador; for (contador = 0 ; contador = 10 ; contador++ ) PORTB = contador;
Na estrutura anterior, a varivel contador inicialmente carregada com o valor 0 (zero), e os comandos do lao for so executados. Aps a execuo de todos os comandos presentes no lao for, a varivel contador incrementada no passo do valor do incremento, que no nosso exemplo 1 unidade, e novamente os comandos do lao for so executados. A estrutura de repetio for termina quando a varivel contador assume o valor 10. Exemplo:
int v, d = 10; for (v = 0 ; v <= d ; v++) { Comando A; Comando B; }
Este exemplo funciona da seguinte maneira: A varivel V recebe o valor 0. A varivel V comparada com d O comando A e o comando B so executados. A varivel V tem seu valor incrementado em 1 unidade. Aps esta incrementao, o valor de V comparado com o valor D, e a seqncia retorna ao item 3, para nova repetio. Caso contrrio (V ultrapassou D), o lao de repetio for finalizado. O grande beneficio do lao for sua flexibilidade, pois aceita qualquer expresso vlida em C, mesmo que essas expresses no tenham relacionamento com o lao de repetio diretamente. Um exemplo simples de aplicao do lao for a criao de pequenos tempos de atrasos (delays).
int atraso; for (atraso = 0 ; atraso < 1000 ; atraso++);
O lao for acima faz com que o processamento fique incrementando constantemente a varivel atraso em 1 at que esta varivel seja igual ao valor 1000; Observe o fragmento de programa seguinte vlido dentro do loop for:
for (n = 0 ; (n < 100) && PORTB.F0 ; n++)
No exemplo acima a varivel n ser incrementada 100 vezes, desde que o pino RB0 permanea em estado lgico alto. Se o pino RB0 em algum momento do lao cair para nvel lgico baixo, o loop ser imediatamente encerrado. Programa Exemplo: Aproveitando que estamos estudando as estruturas do lao de repetio for, vamos elaborar um programa que pisca um led conectado ao pino RD0 do PIC utilizando os recursos do lao for. Acompanhe o esquema abaixo:
Figura 01 Esquema de ligao dos leds no Kit PICgenios O programa seguinte vai contar at 100.000. Para acomodar um nmero dessa grandeza poderamos ter utilizado uma varivel long, mas optamos pela varivel int para que voc entenda a construo de dois laos for encadeados. Para contar at 100,000 necessrio termos uma varivel que conte at 100 e outra at 1000 (100 * 1000 = 100.000).
//********************************************************** // programa de perda de tempo utilizando o lao de repetio for. //********************************************************** void atraso(void) // rotina de perda de tempo { int contador1, contador2; for (contador1 = 0 ; contador1 < 100 ; contador1++) //lao de repetio for for (contador2 = 0; contador2 < 1000; contador2++) ; } void main() { TRISD = 0; while(1) { atraso(); PORTD = ~PORTD; } }
//chama rotina de perda de tempo // inverte os estados do PORTD do PIC
O lao while
Muitos dos programadores iniciantes no sabem do que iremos comentar agora. Os microcontroladores no geral no possuem sistemas operacionais, os programas que desenvolvemos para os microcontroladores PIC devem rodar eternamente, ou possurem mecanismos que paralise a operao da CPU em alguns momentos. Isso necessrio, pois, por no possuir sistema operacional, o programa do PIC no tem para onde sair, devendo ficar em operao, de preferncia eterna. Esses um dos motivos pelos quais a funo principal main() dos programas para microcontroladores deve ser do tipo void (valor nulo), pois no tem quem receba os valores de retorno da funo principal main(). O comando while o comando ideal criar loops infinitos no nosso programa. A estrutura while verifica inicialmente se a condio de teste verdadeira. Em caso verdadeiro, todos os comandos dentro do lao while sero executados. Ao retornar para o incio do lao, verificado novamente se a condio de teste verdadeira, se for verdadeira, executa novamente os blocos de comandos; se for falsa, o lao while finalizado. Acompanhe o exemplo abaixo:
void main() { while (1) /* condio a ser testada. Neste exemplo a condio sempre ser verdadeira (1);*/ { declarao 1; declarao 2; declarao n; } }
Veja outro exemplo de programa:
void main() { int a = 25; while (a = 5) { a++; PORTB = a; } }
Repare que no exemplo acima o valor a condio do lao while falsa, neste caso os comandos do lao no sero executados no programa at que a condio seja verdadeira, ou seja, at que a = 5.
O lao do - while
O comando do - while forma uma estrutura de repetio diferente dos comandos while e for estudado anteriormente. Sua diferena fundamental com relao as outras tradicionais laos de loop while e for est no fato da avaliao da condio de teste ser no final do lao de repetio, contrrio dos outros laos que estudamos, que testam as condies no incio de cada ciclo. formato geral:
do comando while (condio);
ou
do { comando 1; comando 2; } while (condio de teste);
Na estrutura do-while a condio de teste efetuada somente na parte final do loop. Isso faz com que as instrues contidas no interior do lao do - while sejam executadas ao menos uma vez. Caso a condio teste seja atendida, o lao de repetio finalizado, caso contrrio o bloco que est na estrutura seria novamente executado at que a condio teste seja atendida. Exemplo:
void main() { int a = 0; //declara a varivel a como inteiro com o valor 0 do { a++; //incrementa a varivel a em uma unidade PORTD = ~PORTD; //inverte os estados do PORTD } while(a > 100); // enquanto a < 100 permanece no loop do-while; }
O comando break e continue

Break
O comando break, na linguagem C, utilizado para interromper (quebrar) qualquer lao de repetio instantaneamente. No momento da execuo do loop, ao encontrar o comando break, o lao de repetio finalizado. Exemplo: Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 37 de 42
void main() { int a = 0; do { a++; break; PORTD = ~PORTD; }while(a < 100); executada.*/ }
//incrementa //interrompe //inverte os /*enquanto a
a varivel A em uma unidade a execuo do lao de repetio do-while estados dos PORTD varivel a for menor que 100 a rotina do-while ser
O comando break vlido para os laos do-while, while, for e case.
Continue
O comando continue reinicia novamente o teste da condio do lao de repetio. Toda a vez que no lao for encontrado o comando continue, os comandos seguintes no sero executados no lao. Exemplo:
void main() { int a = 0; do { a++; continue; PORTD = ~PORTD; } while(a < 100); executada*/. }
//incrementa a varivel A em uma unidade //retorna para o incio do lao de repetio //inverte os estados dos PORTD /*enquanto a varivel a for menor que 100 a rotina do-while ser
No exemplo de programa acima, os comandos abaixo de continue no sero executados, pois, toda a vez que for executado o comando continue, automaticamente o programa ser redirecionado para o cabealho do lao de repetio independente de qualquer estado de variveis. O comando continue valido para os laos do-while, while, for e case.
Captulo 9 Padres de Formatao de Cdigo

Nesse capitulo iremos sugerir algumas formas de padronizao de cdigo, essa padronizao no pertence ao ANSI-C, mas facilita, em muito, a programao e leitura de seus cdigos.
Declarao de variveis:
Nas variveis podemos declarar desta forma: [modificador] [tipo] [letra_do_modificador][letra_do_tipo][nome_variavel]; EX:
unsigned char ucVariavel; char scVariavel; // mesmo que signed char
Declarao de funes:
Podemos utilizar a mesma formatao para declarao de funes, excluindo a funo main(): [modificador] [tipo] [letra_do_modificador][letra_do_tipo][nome_funcao] [parametros]; EX:
void vFuncao1(unsigned char ucContador) { // comandos } unsigned char ucFuncao2() { // comandos }
Identao:
Um dos recursos mais importantes e necessarios para a escrita de um programa legvel, ela nada mais que o uso de recuos no seu cdigo para identificao de blocos de cdigo. Em nosso curso utilizaremos o recuo de 3 espaos. Ex:
unsigned char ucFuncao2() { if (ucContador==1) // Recuo de 3 espaos { ucContador++; // Recuo de 3 espaos em relao ao anterior } // comandos }
Captulo 10 ANEXOS
TABELA ASCII
Dec
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
Binrio
0b00000001 0b00000010 0b00000011 0b00000100 0b00000101 0b00000110 0b00000111 0b00001000 0b00001001 0b00001010 0b00001011 0b00001100 0b00001101 0b00001110 0b00001111 0b00010000 0b00010001 0b00010010 0b00010011 0b00010100 0b00010101 0b00010110 0b00010111 0b00011000 0b00011001 0b00011010 0b00011011 0b00011100 0b00011101 0b00011110 0b00011111 0b00100000
Hex
0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1A 0x1B 0x1C 0x1D 0x1E 0x1F 0x20
ASCII
SOH STX ETX EOT ENQ ACK BEL BS HT LF VT FF CR SO SI DLE D1 D2 D3 D4 NAK SYN ETB CAN EM SUB ESC FS GS RS US SPC
Dec
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96
Binrio
Hex
ASCII
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ `
Dec
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160
Binrio
Hex
0x81 0x82 0x83 0x84 0x85 0x86 0x87 0x88 0x89 0x8A 0x8B 0x8C 0x8D 0x8E 0x8F 0x90 0x91 0x92 0x93 0x94 0x95 0x96 0x97 0x98 0x99 0x9A 0x9B 0x9C 0x9D 0x9E 0x9F 0xA0
ASCII

Dec
193 194 195 196 197 198 199 200 201 202 203 204 205
Binrio
Hex
0xC1 0xC2 0xC3 0xC4 0xC5 0xC6 0xC7 0xC8 0xC9 0xCA 0xCB 0xCC 0xCD 0xCE 0xCF 0xD0 0xD1 0xD2 0xD3 0xD4 0xD5 0xD6 0xD7 0xD8 0xD9 0xDA 0xDB 0xDC 0xDD 0xDE 0xDF 0xE0
ASCII

206 207 208
209 210 211 212 213 214 215 216 217 218 219 220 221
222 223 224
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
! " # $ % & ' ( ) * + , . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~
161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
0xA1 0xA2 0xA3 0xA4 0xA5 0xA6 0xA7 0xA8 0xA9 0xAA 0xAB 0xAC 0xAD 0xAE 0xAF 0xB0 0xB1 0xB2 0xB3 0xB4 0xB5 0xB6 0xB7 0xB8 0xB9 0xBA 0xBB 0xBC 0xBD 0xBE 0xBF 0xC0
225 226 227 228 229 230 231 232 233 234 235 236 237
0xE1 0xE2 0xE3 0xE4 0xE5 0xE6 0xE7 0xE8 0xE9 0xEA 0xEB 0xEC 0xED 0xEE 0xEF 0xF0 0xF1 0xF2 0xF3 0xF4 0xF5 0xF6 0xF7 0xF8 0xF9 0xFA 0xFB 0xFC 0xFD 0xFE 0xFF 0x00
NULL
238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 0
192

Apostila C ANSI - Presencial Ver300

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Apostila C ANSI - Presencial Ver300

Uploaded by

Copyright:

Available Formats

Linguagem C Embarcada para Microcontroladores

Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 2 de 42

Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 3 de 42

CAPTULO 1 INTRODUO A LINGUAGEM C ...............................................................6

CAPTULO 2 VARIVEIS ..................................................................................................8

CAPTULO 3 TIPOS DE OPERADORES ........................................................................12

CAPTULO 4 FORMAS E REPRESENTAO NUMRICAS E DE CARACTERES .....17

CAPTULO 5 MIKROC : CASE INSENSITIVE ................................................................19

CAPTULO 6 COMO ESCREVER PROGRAMAS EM C .................................................20

Anlise da estrutura do programa: ........................................... 26 Porque devemos criar sub-rotinas ? .......................................... 28

Prottipos de Funes .................................................. 28 Os identificadores ..................................................... 29

CAPTULO 7 ESTRUTURAS DE CONTROLE ................................................................29

CAPTULO 8 ESTRUTURAS DE REPETIO ...............................................................33

CAPTULO 9 PADRES DE FORMATAO DE CDIGO ...........................................39

CAPTULO 10 ANEXOS ....................................................................................................1

Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 5 de 42

Captulo 1 Introduo a Linguagem C

Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 6 de 42

Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 7 de 42

O modificador unsigned indica somente com nmeros positivos.

void main() //funo principal do programa { contador = contador + 10 }

Vamos apresentar mais um exemplo de programa utilizando as variveis globais:

Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 10 de 42

Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 11 de 42

Captulo 3 Tipos de Operadores

Multiplicao e Diviso Os operadores assimilao;

c++; c++; d--;

//equivale a c = c + 1; //incrementa em 1 unidade o valor da varivel C //incrementa em 1 unidade o valor da varivel D

Acompanhe o exemplo abaixo:

Operadores lgicos ou Booleanos

Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 13 de 42

AND (E) OR (OU) NOT (NO)

Os operadores Bitwise (Bit a Bit)

Operador AND (E)

Resultado= 00000100 ou 4 decimal

Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 14 de 42

Resultado=01111100 ou 124 decimal

O Operador XOR (^)

Resultado=01111000 ou 120 decimal

O Operador NOT (~)

Operador de deslocamento << >>

Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 15 de 42

Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 16 de 42

Captulo 4 Formas e representao numricas e de caracteres

Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 17 de 42

representaes de um nmero binrio, caso contrrio seu programa no funcionar corretamente.

Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 18 de 42

Captulo 5 MikroC : Case Insensitive

Manipulao de bit no MikroC

OBS: No so todos os registradores que permitem acesso direto ao seus bits.

Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 19 de 42

Captulo 6 Como escrever programas em C

Vejamos o significado de cada linha de programa: A primeira linha de programa:

Na prxima linha temos:

Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 20 de 42

Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 21 de 42

Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 22 de 42

O terceiro bloco: As funes de subrotinas

Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 23 de 42

O quarto bloco: A funo main()

Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 24 de 42

void main() { PORTB = 0; TRISB = 0; PORTB = ~PORTB; Delay_ms(1000); }

Microgenios Treinamentos, Kits de desenvolvimento e muito mais... Pgina 25 de 42

Anlise da estrutura do programa: