Aula08-DeclaraçõesdeControle

(1)

Microcontroladores

Prof. Eng. Derig Almeida Vidal

Mestre em Computação Aplicada, Engenheiro de Produção e Tecnólogo em Automática

Aula 08

Declarações de Controle

Prof. Derig Almeida Vidal, MsC

Sumário

• Comando if • Comando switch • Laço for • Laço while • Laço do-while • Comando goto • Exercícios

Declarações de Controle

• Podemos classificar as declarações de controle em duas categorias básicas:

– Declarações de teste condicional: são utilizadas para testar determinadas

condições/variáveis e executar um código para cada caso. Ex: if e switch.

– Declarações de estrutura de repetição: são utilizadas para provocar a execução de um bloco de comandos enquanto uma determinada

condição for verdadeira. Ex: for, while e do-while.

Comando if

• É utilizado para executar um comando ou bloco de comandos no caso de uma determinada condição ser avaliada como verdadeira (true ou 1) ou falsa (false ou 0).

• Forma geral:

if (condição) comando01; { else comando02; }

(2)

Comando if

• Ou: if (condição) { comando01; comando02; ... } else { comando03; comando04; ... }

Comando if

• Exemplo 01:

char letra; int x; ...

if (letra==‘a’) x=0; // caso letra seja igual a ‘a’, então x=0;

if (letra==‘b’) x=5; // caso letra seja igual a ‘b’, então x=5;

... • Exemplo 02:

int x,y; x = 5;

if (x) y= x; // se x for diferente de 0 então é verdadeiro

Comando if

void main() { if (input(PIN_A0)) { output_high(PIN_A1); } else { output_low(PIN_A1); } } Lê o pino A0

Coloca em nível alto o pino A1 Coloca em nível baixo pino A1

Comando if encadeado (aninhado)

#include <16f628a.h> #use delay(clock=4000000) #fuses HS,NOWDT,PUT,NOBROWNOUT,NOMCLR,NOLVP int x; main() { x = input_a(); output_b(0); if (!x) output_high(pin_b0); else if (x==1) output_high(pin_b1); else if (x==2) output_high(pin_b2); else if (x==3) output_high(pin_b3); else output_high(pin_b4); }

(3)

Comando if encadeado (aninhado)

Comando switch

• Na comparação de uma determinada variável a diversos valores diferentes, o comando if pode tornar-se um pouco confuso e pouco eficiente. • O switch permite a realização de comparações

sucessivas de uma forma muito mais elegante, clara e eficiente.

Comando switch

switch (variável) { case constante1: comando01; ... break; case constante2: comando02; ... break; default: comando03; ... }

Comando switch

#include <16f628a.h> #use delay(clock=4000000) #fuses HS,NOWDT,PUT,NOBROWNOUT,NOMCLR,NOLVP main() { output_b(0); switch (input_a()) {

case 0: output_high(pin_b0); break; case 1: output_high(pin_b1); break; case 2: output_high(pin_b2); break; case 3: output_high(pin_b3); break; default: output_high(pin_b4); }

(4)

Comando switch

• Características importantes:

– Somente pode testar igualdades;

– Somente dados ordinais podem ser utilizados como constantes (números inteiros de 1, 8, 16 ou 32 bits), ou ainda constantes de caractere; – Não é permitido que, dentro do mesmo switch,

duas cases tenham constantes iguais; – As cláusulas break e default são opcionais.

Comando switch

#include <16f628a.h> #use delay(clock=4000000)

#fuses HS,NOWDT,PUT,NOBROWNOUT,NOMCLR,NOLVP #use rs232(baud=2400, xmit=PIN_B1, rcv=PIN_B2) main() {

char x; x = getchar(); switch (x) {

case '1' : printf("Domingo"); break; case '2' : printf("Segunda"); break; case '3' : printf("Terca"); break; case '4' : printf("Quarta"); break; case '5' : printf("Quinta"); break; case '6' : printf("Sexta"); break; case '7' : printf("Sabado"); break; default: printf("Valor invalido"); }

}

(5)

Comando switch

#include <16f628a.h> #use delay(clock=4000000) #fuses HS,NOWDT,PUT,NOBROWNOUT,NOMCLR,NOLVP main() { int saida = 10;

switch (saida){ //.gfedcba case 0: output_b(0b00111111); break; case 1: output_b(0b00000110); break; case 2: output_b(0b01011011); break; case 3: output_b(0b01001111); break; case 4: output_b(0b01100110); break; case 5: output_b(0b01101101); break; case 6: output_b(0b01111101); break; case 7: output_b(0b00000111); break; case 8: output_b(0b01111111); break; case 9: output_b(0b01101111); break; default:output_b(0b01111001); // Indica Erro } }

Comando switch

Laço for

• É basicamente utilizada para laços finitos de contagem, normalmente utilizando uma variável de controle da contagem.

• Formato geral:

for ( inicialização ; condição ; incremento) comando;

• Ou:

for ( inicialização ; condição ; incremento) { comando01;

comando02; ... }

Laço for

• Cada uma das três seções possui uma função distinta:

– Inicialização: contém uma expressão válida utilizada normalmente para inicialização da variável de controle do laço for.

– Condição: pode conter a condição a ser avaliada para decidir pela continuidade ou não do laço de repetição. Enquanto a condição for verdadeira o laço permanece em execução.

– Incremento: pode conter uma ou mais declarações para incremento da variável de controle do laço.

(6)

Laço for

• O funcionamento básico do comando é o seguinte: – Primeiramente a seção de inicialização do

comando é executada;

– Em seguida, a condição de teste é avaliada e caso verdadeira, é executado o comando ou bloco de comandos;

– Em seguida a seção de incremento é executada e o laço é repetido (voltando a avaliar a condição de teste).

Laço for

#fuses HS,NOWDT,PUT,NOBROWNOUT,NOMCLR,NOLVP #use rs232(baud=2400, xmit=PIN_B2, rcv=PIN_B1)

main() { int conta;

for (conta=0; conta<=10; conta++) printf(“%u\r\n”, conta);

}

Laço for

Laço for sendo utilizado para Delays

• Não possui nenhum comando associado a ele, o que implica simplesmente serão executadas as interações do laço antes do programa continuar a execução.

• Ex:

(7)

Laço for

• Pode-se utilizar também contagens regressivas:

main() { int conta;

for (conta=10; conta>=0; conta--) printf(“%u\r\n”, conta); }

Laço for

• Pode-se utilizar mais de uma variável para o controle do funcionamento do laço.

main() { int x,y;

for (x=0, y=10; x<=10; x++, y--) printf(“%u , %u\r\n”, x, y); }

Comando switch + for

#fuses HS,NOWDT,PUT,NOBROWNOUT,NOMCLR,NOLVP main() {

int saida;

for (saida = 0; saida<=9; saida++){ switch (saida){ //.gfedcba

case 0: output_b(0b00111111); break; case 1: output_b(0b00000110); break; case 2: output_b(0b01011011); break; case 3: output_b(0b01001111); break; case 4: output_b(0b01100110); break; case 5: output_b(0b01101101); break; case 6: output_b(0b01111101); break; case 7: output_b(0b00000111); break; case 8: output_b(0b01111111); break; case 9: output_b(0b01101111); break;

default:output_b(0b01111001); // Indica Erro } delay_ms(1000); } }

(8)

Laço for

• Pode-se utilizar uma condição de teste não relacionada à variável de controle do laço.

main() { long int x;

for (x=0; (x<=1000) && input(pin_b3); x++) printf(“%lu \r\n”, x);

}

Laço for

• Pode-se também criar um laço infinito. • Ex:

for ( ; ; ) ;

Laço for

– Cada uma das seções de argumentos do comando admite qualquer tipo de declaração válida da linguagem C;

– A seção de teste é sempre avaliada no início de cada ciclo do laço;

– Se a seção de teste for inicialmente falsa, nenhuma interação do laço é executada;

– A seção de incremento é sempre executada ao final de cada ciclo do laço.

A cláusula break no for

• O break fará com que o laço seja prematuramente encerrado, independentemente de a condição de repetição do laço ser avaliada;

main() { long int x;

for (x=0; (x<=1000); x++) if (!input(pin_b3)) break; printf(“%lu \r\n”, x);

(9)

A cláusula continue no for

• Sua finalidade é forçar o término do ciclo atual do laço, fazendo com que ocorra um novo ciclo.

main() { long int x; for (x=0; (x<=1000); x++) { if (!bit_test(x,4)) continue; printf(“%lu \r\n”, x); } }

Laço while

• É utilizada para repetição de um determinado conjunto de instruções enquanto uma condição for verdadeira.

• Formato geral:

while (condição) comando;

• Ou: while (condição) { comando01; comando02; ... }

Laço while

• O funcionamento básico do comando é o seguinte: – Primeiramente a condição é avaliada, caso seja

verdadeira, então o comando ou bloco de comandos é executado e a condição é novamente avaliada, reiniciando o laço;

– Caso a condição seja falsa, o comando ou bloco de comandos não é executado e o programa tem seqüência a partir da declaração seguinte ao bloco while.

Laço while

• Laço de contagem simples utilizando o while. • Ex:

int x; while (x<=10) x++;

(10)

Laço while

• Não é necessário associar nenhum comando ao while.

main() {

while (!input(pin_b3));

printf(“O pino RB3 esta em nivel 1 \r\n”); }

Laço while

– A condição de teste é avaliada sempre no início de cada interação do laço;

– O comando ou bloco de comandos, caso exista, será executado somente se a condição for verdadeira;

A break e continue no while

#include <16f628a.h>

#use delay(clock=4000000)

main() { int x=0; while (x<30) { if (!input(pin_b3)) break; x++; if (!(x%2)) continue; printf(“%u \r\n”, x); } }

Laço do-while

• A diferença entre o while tradicional e a estrutura do-while é que esta última realiza a avaliação da condição de teste no final de cada ciclo de iteração do laço de repetição, ao contrário do while, que realiza o teste no início de cada ciclo.

• Formato geral:

do comando while (condição);

• Ou: do {

comando01; comando02; ... } while (condição) ;

(11)

Laço do-while

main() { int x=0; do { x++; printf(“%u \r\n”, x); } while (input(pin_b3)); }

Laço do-while

– A condição de teste será avaliada sempre ao término de cada ciclo de repetição;

– Caso a condição seja inicialmente falsa, o comando, ou bloco de comandos, será executado uma vez;

A break e continue no do-while

#include <16f628a.h>

#use delay(clock=4000000)

main() { int x=0; do { x++; printf(“%u \r\n”, x); if (x>=100) break; } while (input(pin_b3)); }

Comando goto

• É um comando de desvio incondicional (vá para). • Ex:

int conta = 0;

loop:

conta++;

(12)

Exercícios

1. No fragmento de programa seguinte, a condição analisada pelo comando if é verdadeira ou falsa? int x = 0, y = 10;

...

if (x = 1) y = 0; else y = 5; ...

2. O programa seguinte aguarda o pressionamento de uma tecla e toma algumas decisões em relação a ela. Qual tecla em questão?

#fuses HS,NOWDT,PUT,NOBROWNOUT,NOMCLR,NOLVP #use rs232(baud=2400, xmit=PIN_B2, rcv=PIN_B1) main() { char x; boolean y = 0; while (true) { x = getc(); If (x == 77) { y = !y;

if (y) printf(“Liga \r\n”); else printf(“Desliga \r\n”); } else {

y=0;

printf(“Desliga \r\n”); } } }

Exercícios

3. Crie um programa que conte de 0 a 255 e imprima numa porta estes valores (em forma binária). Coloque um intervalo de 255ms entre a exibição de um número e outro.

4. Agora a saída só pode receber os valores de 0 a 9 e esta saída deve exibir os valores em um display de 7 segmentos.

5. Idem ao anterior de forma ininterrupta.

6. Idem ao anterior mas só efetue o incremento caso um botão esteja pressionado.

Bibliografia

• PEREIRA, Fábio. Microcontroladores PIC: