Resumo Linguagem C

Prévia do material em texto

RESUMO
Linguagem C para Microcontroladores
Prof. Glauber G. O. Brante
UTFPR – Universidade Tecnológica Federal do Paraná
DAELT – Departamento Acadêmico de Eletrotécnica
Sumário
1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2 Definições Gerais em Linguagem C . . . . . . . . . . . . . . . . . . . . . 4
2.1 A Linguagem C é Case Sensitive . . . . . . . . . . . . . . . . . . . . . . . 4
2.2 Palavras Reservadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.3 Comentários . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.4 Representação Numérica . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.5 Tipos de Dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.5.1 Constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.5.2 Definições . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.6 Variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.6.1 Variáveis Locais . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.6.2 Variáveis Globais . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.7 Funções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.8 Header . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3 Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.1 Operadores Aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.2 Operadores Relacionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.3 Operadores Booleanos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.4 Operadores Lógicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.5 Associação de Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . 14
4 Estruturas Condicionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.1 A Estrutura if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.2 A Estrutura if-else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.3 A Estrutura if-else if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.4 A Estrutura switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
5 Estruturas de Repetição . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
5.1 O Laço for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
5.1.1 O Comando break . . . . . . . . . . . . . . . . . . . . . . . . . . 18
5.2 O Laço while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
5.2.1 Estrutura de Repetição Infinita . . . . . . . . . . . . . . . . . . . . 19
5.3 O Laço do-while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
6 Comentários Finais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1 Introdução 3
1 Introdução
O objetivo desse documento é fornecer um resumo sobre a linguagem C com ênfase em
aplicações para microcontroladores. O emprego da linguagem C na programação de mi-
crocontroladores não é complicado, mas exige conhecimento mínimo da estrutura de pro-
gramação, além de conhecimentos específicos sobre as estruturas internas do microcon-
trolador em questão. Este resumo apresentará as estruturas de programação mais comuns,
necessárias para se programar microcontroladores. Para os conhecimentos específicos de
cada microcontrolador, uma leitura do datasheet do componente se faz necessária.
A estrutura básica de um programa em C para microcontroladores é a seguinte:
void main()
{
// inicializações de hardware e software
while(1) // loop infinito
{
/* tarefas a serem executadas pelo microcontrolador
durante o funcionamento */
}
}
Com o uso inteligente dos comentários e funções, a programação se torna de mais fá-
cil compreensão. Programas extensos podem ser divididos em sub-rotinas (funções) que
ocasionalmente consumirão menos memória do microcontrolador e tornarão o se proces-
samento mais rápido.
2 Definições Gerais em Linguagem C 4
2 Definições Gerais em Linguagem C
2.1 A Linguagem C é Case Sensitive
Case sensitive significa que a linguagem C diferencia as letras maiúsculas das minúsculas.
Assim, os identificadores CONTADOR, contador e Contador são diferentes entre si. De-
vemos prestar bastante atenção a esse fato, pois se criarmos uma variável de uma maneira
e escrevermos de outra na hora de utilizá-la teremos um erro de compilação.
Essa regra também se aplica a todos os comandos da linguagem C, que devem ser
escritos em letras minúsculas, e.g., while, for, if.
2.2 Palavras Reservadas
A linguagem C possui um conjunto de palavras reservadas que não podem ser usadas como
variáveis de programa. As palavras reservadas da linguagem C, no padrão ANSI, são:
Tab. 1: Palavras Reservadas em Linguagem C
auto break case char const
continue default do double else
enum extern float for goto
if int long register return
short signed sizeof static struct
switch typedef union unsigned void
volatile while main
Como já comentado, uma palavra reservada da linguagem C não pode ser utilizada pelo
programador como variável do programa. A seguir temos um exemplo de erro no emprego
de variáveis:
while = 1;
int = 200;
2.3 Comentários
Os comentários auxiliam na documentação do programa e são fundamentais para enten-
dimento futuro de sua funcionalidade, especialmente se quem vai fazer a manutenção do
firmware não é o próprio programador que o criou. Além disso, os comentários também
são úteis exclusão de linhas de código durante a compilação, facilitando os testes durante a
programação.
Em geral, grande parte dos compiladores aceita dois tipos de comentários, os de linha
simples e os de múltiplas linhas. Os comentários de linha simples sempre são iniciados
com “//” (dupla barra), fazendo com que o compilador ignore tudo o que estiver na mesma
linha depois da dupla barra. Por exemplo:
// Este é um comentário de linha simples.
2 Definições Gerais em Linguagem C 5
Por sua vez, os comentários de múltiplas linhas devem ser sempre iniciados com “/*” e
terminados com “*/”. Por exemplo:
/* Este é um
comentário de
múltiplas linhas.
*/
2.4 Representação Numérica
Nessa subseção apresentaremos um resumo das representações numéricas para microcon-
troladores PIC, baseados no compilador MikroC Pro. Os tipos numéricos são os mesmos
para todos os microcontroladores, porém a representação numérica pode variar entre os
diversos compiladores existentes.
• Decimal:
valor_decimal = 125;
• Binário:
PORTA = 0b11110001;
• Hexadecimal:
valor_hexa = 0xFF;
• Octal:
valor_octal = 075;
• Caractere:
caracter = ’a’;
2.5 Tipos de Dados
Toda variável usada em um programa deve ser declarada como de um determinado tipo,
que define seu tamanho (em número de bits) e suas características. As variáveis podem ser:
Tab. 2: Tipos de Dados
Tipo Bytes Mínimo Máximo Representa
void Zero Sem valor Sem valor Valores nulos
char 1 -128 127 Caracteres
int 2 -32768 32767 Inteiros
float 4 ±1, 5× 10−45 ±3, 4× 1038 Valores com casas decimais (ponto flutuante)
double 8 ±4, 9× 10−324 ±1, 8× 10308 Valores com casas decimais (ponto flutuante)
2 Definições Gerais em Linguagem C 6
Além disso, temos os seguintes modificadores de tipo:
Tab. 3: Modificadores de Tipos de Dados
Tipo Modificação
signed Com sinal
unsigned Sem sinal
short Inteiro menor que o padrão
long Inteiro maior que o padrão
Portanto, temos os seguintes tipos de dados inteiros:
Tab. 4: Tipos de Dados Inteiros
Tipo Bytes Mínimo Máximo
char 1 -128 127
signed char 1 -128 127
unsigned char 1 0 255
short int 2 -128 127
signed short int 2 -128 127
unsigned short int 2 0 255
int 2 -32768 32767
signed int 2 -32768 32767
unsigned int 2 0 65535
short 2 -32768 32767
signed short 2 -32768 32767
unsigned short2 0 65535
long int 4 −231 231 − 1
signed long int 4 −231 231 − 1
unsigned long int 4 0 232 − 1
2.5.1 Constantes
Servem para criar símbolos de valor constante que auxiliam na programação. No momento
da compilação, o compilador se encarrega de atribuir os valores corretos aos símbolos
criados. Por exemplo:
const LIGADO = 1;
const DESLIGADO = 0;
const TMAX = 100;
Após definir as constantes, é possível utilizar estas palavras como tendo o mesmo sig-
nificado do valor numérico atribuído.
2 Definições Gerais em Linguagem C 7
2.5.2 Definições
Além de dar nome a valores constantes, também podemos atribuir outros nomes a símbolos
já existentes no microcontrolador. Por exemplo, imagine que você tenha um LED ligado
ao bit 0 da porta A do seu microcontrolador, além de um motor DC ligado ao bit 1 dessa
mesma porta. Para facilitar a programação, pode-se fazer:
#define LED PORTA.B0
#define MOTOR PORTA.B1
Observe que na Linguagem C os comandos iniciados pelo caractere “#” são os únicos
que não recebem ponto-e-vírgula no final da sentença.
Assim, os comandos de definição “#define” e “const” servem para tornar o programa
mais compreensível. Além disso, estes comandos são sempre eliminados pelo compilador,
ou seja, não consomem memória extra do microcontrolador.
Para visualizar sua utilizada, considere o código abaixo utilizando definições e cons-
tantes:
#define LED PORTA.B0
#define MOTOR PORTA.B1
const LIGADO = 1;
const DESLIGADO = 0;
void main()
{
LED = LIGADO;
MOTOR = LIGADO;
}
2.6 Variáveis
Uma variável sempre deve ser declarada da seguinte forma:
(<modificador>) <tipo de dado> <nome da variável> (= <valor>);
Note que a utilização do modificador e da inicialização da variável são opcionais.
Exemplos:
unsigned int valor = 123;
char letra = ’a’;
int contador;
As variáveis podem ser do tipo locais ou globais, conforme veremos a seguir.
2 Definições Gerais em Linguagem C 8
2.6.1 Variáveis Locais
São variáveis declaradas dentro de um bloco de instruções (ou função) e só podem ser
acessadas dentro desse bloco. Exemplo:
int media()
{
int valor1 = 5;
int valor2 = 7;
return (valor1+valor2)/2;
}
Uma observação importante é que todas as definições de variáveis locais devem apare-
cer logo no início do bloco/função.
2.6.2 Variáveis Globais
São declaradas fora dos blocos de função e podem ser acessadas por todas as funções e
blocos de instruções. Exemplo:
int valor1 = 5;
int valor2 = 7;
int media()
{
return (valor1+valor2)/2;
}
int soma()
{
return valor1+valor2;
}
Mas atenção, apesar de parecer uma boa ideia declarar funções globais devemos ter
bastante cuidado com sua utilização. Uma vez que estas variáveis podem ser acessadas
por todas as funções, é difícil manter o controle sobre seus valores à medida que o código
vai sendo executado. Por essa razão, declarar variáveis globais não é considerada uma boa
prática de programação, devendo ser utilizadas apenas quando estritamente necessárias, e
de forma bastante cuidadosa.
2.7 Funções
Quando temos trechos de códigos que são repetidos várias vezes, podemos isolar estes tre-
chos em funções. Assim, podemos chamar uma função em diferentes pontos do programa
principal, evitando reescrever aquele trecho de código repetidamente.
Uma função deve ser declarada antes de ser chamada. Por isso é importante escrever
todas as novas funções antes da função principal (main). Por exemplo:
2 Definições Gerais em Linguagem C 9
void piscaLED() // declara o início da função piscaLED
{
PORTA.B0 = 1; // liga o pino A0
delay_ms(1000); // aguarda 1000ms (1 segundo)
PORTA.B0 = 0; // desliga o pino A0
delay_ms(1000); // aguarda 1 segundo
}
void main(void) // início do programa principal
{
while(1)
{
piscaLED(); // chama a função piscaLED
}
}
O void, que traduzido para português quer dizer vazio, é um tipo de dado utilizado em
funções que não retornam nenhum parâmetro. A função main é sempre do tipo void, pois
não retorna nem recebe nanhum valor.
Entretanto, as funções podem muitas vezes conter parâmetros de entrada que carregam
informações para dentro do bloco da função, além de parâmetros de saída, devolvendo
informações ao programa principal. Por exemplo:
int media(int a, int b) /* declara o início da função media.
Essa função recebe dois valores
do tipo int (a e b) */
{
return (a + b)/2; // retorna um valor do tipo int
}
void main(void) // início do programa principal
{
int valor1 = 10;
int valor2 = 20;
int result;
result = media(valor1, valor2); /* A função média retorna
seu valor do tipo int
na variável result */
}
2.8 Header
Em muitos compiladores, é necessário incluir um arquivo que contém todas as definições
do microcontrolador sendo utilizado. Isto é feito através do comando “#include”. Em geral,
temos a seguinte sintaxe que deve ser incluída logo no início de qualquer programa:
#include<microcontrolador.h>
Além deste arquivo com as definições do microcontrolador, podemos utiliza a instrução
“#include” para incluir algum arquivo denominado cabeçalho, contendo funções auxiliares
a serem utilizadas. Por exemplo:
#include<nome_do_arquivo.h>
3 Operadores 10
3 Operadores
A linguagem C possui operadores para atribuir, comparar ou modificar dados e variáveis.
Podemos dividir estes operadores em quatro categorias principais:
• Aritméticos: para cálculos;
• Relacionais: para comparar valores numéricos;
• Lógicos: para testar condições ou manipular bits;
• Booleanos: para realizar operações lógicas com mais de um bit.
3.1 Operadores Aritméticos
Em linguagem C temos os seguintes operadores aritméticos:
Tab. 5: Operadores Aritméticos
Símbolo Operação
+ Soma
- Subtração
* Multiplicação
/ Divisão
% Resto inteiro da divisão
++ Incremento em um
– Decremento em um
Os operadores aritméticos sempre usam duas variáveis e retornam um terceiro valor
mantendo inalteradas as variáveis originais. Exemplos:
• Soma:
int y = 10;
int z = 5;
int x = 0;
x = y + z; /* Soma o conteúdo da variável y com a
variável z e armazena o resultado na
variável x */
• Subtração:
int a = 10;
int b = 5;
int c = 0;
c = b - a; /* Subtrai da variável b o conteúdo da
variável a e armazena o resultado na
variável c */
3 Operadores 11
• Multiplicação:
int a = 1;
int b = 20;
int c = 2;
a = b*c; /* Multiplica o conteúdo da variável b pelo da
variável c e armazena o resultado na
variável a */
• Divisão:
int a = 0;
int b = 20;
int c = 2;
a = b/c; /* Divide o conteúdo da variável b pelo da
variável c e armazena o resultado na
variável a */
• Resto inteiro da divisão:
int a = 1;
int b = 25;
int c = 2;
a = b%c; /* Divide o conteúdo da variável b pelo da
variável c e armazena o resto da divisão na
variável a */
• Incremento em um:
int contagem = 0;
contagem++; // Incrementa a variável contagem em um
• Decremento em um:
int contagem = 0;
contagem--; // Decrementa a variável contagem em um
3.2 Operadores Relacionais
Realizam operações de comparação, retornando os valores FALSO (0) ou VERDADEIRO
(1). Esses operadores não afetam o conteúdo das variáveis sendo comparadas.
3 Operadores 12
Tab. 6: Operadores Relacionais
Símbolo Descrição
== Igual a
!= Diferente de
< Menor que
> Maior que
<= Menor ou igual
>= Maior ou igual
Exemplo:
void main()
{
unsigned char cont = 0;
while(1)
{
if (PORTA.B0 == 1) // Se o pino A0 estiver ligado
if (cont < 9)
cont++; /* Se contagem for maior que 9,
incrementa */
else
cont = 0; // Caso contrário, zera
}
}
3.3 Operadores Booleanos
São usados para realizar testes booleanos entre elementos em um teste condicional. Os
operadores são:
Tab. 7: Operadores Booleanos
Símbolo Descrição
&& E (AND)
| | OU (OR)
! NÃO (NOT)
• Exemplo 1:
int A = 0;
if ((A > 0) && (A < 10))
A++;
Significado: se A for maior do quezero E A for menor do que dez, então incremente
A em um.
3 Operadores 13
• Exemplo 2:
int A = 0;
int B = 0;
int C = 0;
if ((A != B) || (A != C))
A--;
Significado: se A for diferente de B OU A for diferente de C, então decremente A
em um.
3.4 Operadores Lógicos
São usados para realizar testes lógicos bit a bit. Os operadores lógicos são:
Tab. 8: Operadores Lógicos
Símbolo Descrição
& E (AND)
| OU (OR)
∧ OU Exclusivo (XOR)
∼ NÃO (NOT)
» Deslocamento para a direita
« Deslocamento para a esquerda
• Exemplo 1:
int cont = 0;
if (PORTA.B0 & PORTA.B1)
cont++;
Significado: se PORTA.B0 for igual a um E PORTA.B1 for igual a um, então cont é
incrementado em uma unidade.
• Exemplo 2:
int cont = 0b00000001;
if (PORTA.B0 | PORTA.B1)
cont = cont<<1;
Significado: se PORTA.B0 for igual a um OU PORTA.B1 for igual a um, então o
valor de cont é deslocado para a esquerda.
• Exemplo 3:
int cont = 10;
if (PORTA.B0 & ~PORTA.B1)
cont--;
Significado: se PORTA.B0 for igual a um E PORTA.B1 não for igual a um, então o
valor de cont é decrementado de uma unidade.
3 Operadores 14
3.5 Associação de Operadores
Algumas abreviações são comumente utilizadas com os operadores. Dentre elas podemos
citar:
Tab. 9: Abreviações de Operadores
Forma Expandida Forma Reduzida
x = x + y x += y
x = x - y x -= y
x = x * y x *= y
x = x / y x /= y
x = x % y x %= y
x = x & y x &= y
x = x | y x |= y
x = x ∧ y x ∧= y
x = x << y x <<= y
x = x >> y x >>= y
4 Estruturas Condicionais 15
4 Estruturas Condicionais
4.1 A Estrutura if
A estrutura if, que significa “se” em português, é uma estrutura de decisão baseada no
resultado de um teste lógico. Sua forma geral é:
if (condição)
{
comando 1;
comando 2;
...
comando n;
}
Se houver apenas uma instrução a ser executada após o teste lógico, as chaves podem
desprezadas:
if (condição)
comando;
Em C, qualquer número diferente de zero é considerado verdadeiro, o que significa que
a condição if só será falsa se o teste lógico aplicado resultar em zero (0). Qualquer outro
valor, mesmo que negativo, é considerado verdadeiro (1).
Exemplo:
void main()
{
int contagem = 0;
if (PORTA.B0)
contador++; /* Apenas se o valor da porta A0 for igual a
um, o contador será incrementado */
}
Entretanto, em geral utilizamos uma expressão lógica como condição de entrada para a
estrutura if:
void main()
{
int contagem = 0;
if (PORTA.B0 == 0)
contador++; /* Apenas se o valor da porta A0 for igual a
zero, o contador será incrementado */
}
Uma observação importante é quanto a diferença entre o operador de atribuição (=) e
a operação booleana de igualdade (==). Para inicializar uma variável utilizamos =, porém,
para testar o valor de uma variável utilizamos ==. Por exemplo:
int a = 10; // Inicializamos a variável ’a’ com o valor 10
if (a == 10) // Fazemos o teste booleano com a variável ’a’
a++;
4 Estruturas Condicionais 16
4.2 A Estrutura if-else
A estrutura if pode ser expandida com o uso de else (senão), que permite definir comandos
a serem executados caso o teste seja falso (0). Por exemplo:
int i = 10;
int j = 5;
if (i == 10) // Se ’i’ for igual a 10, incrementa j
j++;
else // Senão, decrementa j
j--;
Caso haja mais de um comando if na sequência, o else estará sempre relacionado com
o último if. Por exemplo:
int i = 10;
int j = 5;
if (i == 10) // Se ’i’ for igual a 10, incrementa j
j++;
else // Senão, decrementa j
j--;
4.3 A Estrutura if-else if
Este tipo de estrutura permite um número de alinhamentos de comandos, possibilitando
colocar estruturas if dentro de outras estruturas if com maior facilidade. Seu formato geral
é:
if (condição 1)
{
comandos;
}
else if (condição 2)
{
comandos;
}
else if (condição 3)
{
comandos;
}
A estrutura if-else if é uma alternativa para tornar tomadas de decisões mais rápidas em
alguns casos, Isto ocorre porque, no momento em que alguma condição seja satisfeita, os
demais blocos if subsequentes não serão sequer testados.
4 Estruturas Condicionais 17
4.4 A Estrutura switch
A estrutura switch é muito parecida com a estrutura if-else if. A diferença é que switch não
aceita expressões lógicas para tomar decisões, mas somente constantes. O comando switch
testa o valor de uma variável e executa os comandos correspondentes a casos (cases) pré-
estabelecidos. Cada case define uma série de comandos que serão executados até chegar na
instrução break. Quando nenhum caso correspondente for encontrado, a cláusula default
será executada. Porém, o uso da cláusula default é opcional.
Formato da estrutura switch:
switch(variável)
{
case constante1:
comandos;
break;
case constante2:
comandos;
break;
...
case constante n:
comandos;
break;
default:
comandos;
break;
Exemplo de uso da estrutura switch:
int contador = read_ADC(); /* lê o valor do conversor AD e armazena
na variável ’contador’ */
switch(contador)
{
case 0:
x++;
PORTA.B0 = 1;
break;
case 1:
PORTA.B1 = 1;
break;
case 2:
PORTA.B0 = 0;
PORTA.B1 = 0;
break;
default:
break;
5 Estruturas de Repetição 18
5 Estruturas de Repetição
5.1 O Laço for
O laço for é utilizado quando precisamos de uma ciclo controlado de repetições. Em sua
inicialização definimos uma variável de controle, a qual damos um valor inicial, uma con-
dição de parada, e uma regra de incremento (ou decremento). Antes de serem executados
os comandos do laço for, avalia-se a condição de teste. Caso esta condição seja verdadeira,
os comandos são executados. A cada ciclo de execução (iteração), a variável de controle é
incrementada ou decrementada de acordo com uma regra.
A estrutura geral do laço for é:
for(inicialização; condição; incremento)
{
comandos;
}
Vejamos um exemplo de uso:
for(i = 0; i < 10; i++)
{
PORTA.B0 = 1; // liga o pino A0
delay_ms(1000); // aguarda 1 segundo
PORTA.B0 = 0; // desliga o pino A0
delay_ms(1000); // aguarda 1 segundo
}
Neste exemplo, a variável ’i’ é inicialmente carregada com o valor 0 (i = 0). Como
a condição inicial é verdadeira (i < 10), os comandos do laço são executados. Após a
execução dos comandos do laço, a variável ’i’ é incrementada em uma unidade, dada pela
condição de incremento ’i++’, e novamente os comandos do laço são executados. Isto é
feito até que a condição se torne falsa, isto é, quando ’i’ for igual a 10.
Ainda é possível utilizar o laço for em passos decrescentes. O mesmo código acima
pode ser escrito de maneira equivalente como:
for(i = 10; i > 0; i--)
{
PORTA.B0 = 1; // liga o pino A0
delay_ms(1000); // aguarda 1 segundo
PORTA.B0 = 0; // desliga o pino A0
delay_ms(1000); // aguarda 1 segundo
}
5.1.1 O Comando break
o comando break é utilizado para encerrar o laço for antes de se completar todas as itera-
ções. Quando o laço é quebrado, o programa pula para a próxima instrução após o laço.
Exemplo:
void main()
{
int i = 0;
5 Estruturas de Repetição 19
for(i = 0; i < 10; i++)
{
if (PORTB.B0 == 1)
break;
PORTA.B0 = 1; // liga o pino A0
delay_ms(1000); // aguarda 1 segundo
PORTA.B0 = 0; // desliga o pino A0
delay_ms(1000); // aguarda 1 segundo
}
}
Neste exemplo, o pino A0 ficará piscando desde que o pino B0 seja diferente de 1.
Quando isto acontecer (quando B0 for ligado), o comando break será executado e o laço
será encerrado.
5.2 O Laço while
O laço while tem a seguinte estrutura:
while(condição)
{
comandos;
}
Dessa forma, o laço inicialmente verifica uma condição lógica. Se esta condição for
verdadeira, os comandos dentro do laço serão executados, caso contrário, o programa salta
para a linha de comando imediatamente após o fim do laço.
A condição pode ser uma operação relacional, ou um teste booleano. Por exemplo:
while(x<50) // Enquanto x for menor do que 50
{
x++; // incrementa x
}
5.2.1 Estruturade Repetição Infinita
Microcontroladores em geral são programados para executar uma tarefa indefinidamente.
Dessa forma, o uso de laços infinitos é bastante comum. Uma maneira de criar um laço
infinito é fornecer uma condição sempre verdadeira ao while. Assim, uma estrutura típica
de um programa em C para microcontroladores é a seguinte:
void main()
{
// inicializações de hardware e software
while(1) // loop infinito
{
/* tarefas a serem executadas pelo microcontrolador
durante o funcionamento */
}
}
onde a condição em “while(1)” é sempre verdadeira (sempre igual a 1).
5 Estruturas de Repetição 20
5.3 O Laço do-while
O laço do-while nada mais é do que uma variação do laço while. Sua estrutura geral é:
do
{
comandos;
} while(condição);
A diferença aqui é que os comandos são executados antes de se realizar o teste lógico
de condição. Caso o teste executado ao final seja verdadeiro, o laço é executado novamente
do início. Caso contrário, o programa segue com a instrução imediatamente após o laço.
6 Comentários Finais 21
6 Comentários Finais
Todo o material apresentado neste resumo é material de livre acesso, baseado nas notas de
aula disponíveis em http://paginapessoal.utfpr.edu.br/gbrante, bem como no livro “Progra-
mação Linguagem C para Microcontroladores 8051”, da iniciativa u8051, disponível em
http://www.u8051.com.br/.
	Introdução
	Definições Gerais em Linguagem C
	A Linguagem C é Case Sensitive
	Palavras Reservadas
	Comentários
	Representação Numérica
	Tipos de Dados
	Constantes
	Definições
	Variáveis
	Variáveis Locais
	Variáveis Globais
	Funções
	Header
	Operadores
	Operadores Aritméticos
	Operadores Relacionais
	Operadores Booleanos
	Operadores Lógicos
	Associação de Operadores
	Estruturas Condicionais
	A Estrutura if
	A Estrutura if-else
	A Estrutura if-else if
	A Estrutura switch
	Estruturas de Repetição
	O Laço for
	O Comando break
	O Laço while
	Estrutura de Repetição Infinita
	O Laço do-while
	Comentários Finais