Você está na página 1de 15

AULA 4

LÓGICA E
MICROCONTROLADORES

Prof. Charles Way Hun Fung


TEMA 1 – ESTRUTURAS DE REPETIÇÃO

Durante o desenvolvimento de um programa, é interessante que alguns


trechos de código se repitam por um número específico de vezes ou enquanto
uma condição for verdadeira. Da mesma forma que a estrutura condicional, essas
estruturas utilizam expressões para definir condições e são conhecidas como laço
de repetição ou loop, em que as instruções que são repetidas na estrutura de
repetição são chamadas de iteração.
A linguagem Wiring e o Scratch possuem estruturas de controle que fazem
uso de uma variável para repetir diversas vezes os comandos. Essas variáveis
devem possuir um valor inicial, condição de parada e incremento ou decremento.
Na linguagem Wiring, há três estruturas de repetição: while, do while e for.
Para iniciar nossos estudos, vamos começar com a estrutura while.
A estrutura de repetição while (enquanto, em português) tem o seguinte
formato:
while(<condição>){
<comandos>
}

A estrutura while delimita, dentro das chaves, os comandos que serão


repetidos enquanto a condição for verdadeira. Caso a condição se torne falsa, os
comandos deixam de executar e a execução do código continua depois da chave
que finaliza o while.
Exemplo: um potenciômetro é medido na entrada analógica A0. O
potenciômetro é um resistor variável que tem um valor de tensão que varia de
acordo com a resistência marcada. As leituras realizadas são transmitidas pela
porta USB (serial) para que sejam monitoradas. As Figuras 1-2 apresentam o
esquema usado no exemplo e o código, em Wiring, da leitura analógica.

2
Figura 1 – Leitura do potenciômetro pela serial

Crédito: Charles Way Hun Fung/Tinkercad Screenshots Reprinted Courtesy of Autodesk, Inc.

Figura 2 – Uso da estrutura while

No exemplo da Figura 2, o loop while é controlado pela variável i. Nesse


código, podemos verificar três fatos que acontecem com aquela variável:

3
1. Na linha 13, é dado um valor inicial: i = 0.
2. Na linha 15, há uma condição que deve ser verificada.
3. Na linha 18, há o incremento da variável i.

Perceba que haverá uma iteração a cada 1 segundo, devido ao comando


da linha 19: delay(1000). Nesse exemplo, a cada iteração é escrito o valor lido do
potenciômetro na serial. Na Figura 3, é apresentado o resultado do monitor serial.

Figura 3 – Resultado da leitura no monitor serial

Uma observação sobre esse exemplo é o uso da serial, dispositivo que foi
configurado na linha 7 com uma taxa de comunicação de 9,6 mil bits por segundo.
Após isso, toda vez que se deseja escrever algo na serial, basta usar o comando
Serial.println.
O funcionamento desse exemplo segue o seguinte procedimento:

1. A variável i inicia o loop com valor zero.


2. Verifica-se se i é menor que 60.
3. Se a condição for verdadeira, é realizada a leitura do potenciômetro e a
escrita na serial.
4. i é incrementado (i é adicionado em 1).
5. Espera-se um segundo (1.000 ms = 1 s).
6. Volta-se para o passo 2.

Com o aumento do valor de i, haverá um momento no qual a condição não


será mais verdadeira e, nesse caso, o laço de repetição irá terminar.

4
TEMA 2 – LOOP DO... WHILE

Um segundo loop que vamos estudar se parece muito com o anterior, mas
possui uma diferença no conceito. O laço do... while (repita... até) repete os
comandos até que uma condição deixe de ser verdade.
O loop do... while possui a seguinte sintaxe:

do{
<comandos>
}while(<condição>);

Nesse loop, os comandos são executados enquanto a condição for


verdadeira; entretanto, a verificação da condição é realizada no final do loop. Essa
é a grande diferença entre o loop while e o do... while: o primeiro verifica a
condição no começo do loop e o segundo, no seu final.
Para exemplificar, vamos usar o mesmo esquema da Figura 1, porém agora
vamos resolver o mesmo problema usando do... while (Figura 4).

Figura 4 – Uso da estrutura do... while

5
Da mesma forma que no loop while, a variável i é que faz o controle desse
loop apresentado na Figura 4. Podemos verificar três fatores que ocorrem com i:

1. Na linha 13, i é inicializado com zero.


2. Na linha 18, i é incrementado (i é adicionado em 1).
3. Na linha 20, a condição deve ser verificada.

Nesse exemplo, em setup() o pino A0 é considerado entrada e a serial é


configurada com uma taxa de 9,6 mil bits por segundo. A seguir, na função loop(),
seguem-se as seguintes instruções:

1. A variável i inicia o loop com valor zero.


2. É realizada a leitura do potenciômetro e a escrita na serial.
3. i é incrementado (i é adicionado em 1).
4. Espera-se um segundo (1.000 ms = 1 s).
5. Verifica-se se i é menor que 60.
6. Se a condição for verdadeira, volta-se para o passo 2.

Perceba que, nesse loop, a verificação sempre ocorre no final, ou seja, os


comandos sempre executam pelo menos uma vez. Para testar isso, podemos
fazer a variável i começar com o valor 60. A seguir é apresentado o resultado do
monitor serial (Figura 5).

Figura 5 – Resultado no monitor serial

A Figura 5 mostra que ocorreu uma iteração, mesmo que o valor de i resulte
em uma condição falsa. O que não aconteceria com o loop while, pois a sua
verificação acontece no começo do laço de repetição.
Na prática, o loop do... while possui aplicações muito específicas e
normalmente é o menos utilizado; entretanto, é sempre interessante conhecer as
possibilidades que esse loop pode proporcionar ao algoritmo.

6
TEMA 3 – LOOP FOR

O loop for é o terceiro loop que vamos estudar. Esse é mais utilizado,
devido à característica de possuir todos os parâmetros de um loop direto, em seu
cabeçalho.
O formato padrão do loop for é apresentado a seguir:

for(<inicialização>;<condição>;<incremento>){
<comandos>
}

Os três campos são bem definidos, no loop for:

1. Inicialização: inicialização da variável que controla o loop.


2. Condição: a condição que, enquanto for verdadeira, irá executar
repetidamente os comandos.
3. Incremento: consiste na alteração de valor que a variável de controle
receberá, após uma iteração.

Exemplo 1:
1 for(i=0;i<10;i++){
2 Serial.println(i);
3 }

Nesse primeiro exemplo, podemos separar cada campo do cabeçalho da


seguinte forma:

1. Inicialização: i = 0.
2. Condição: i < 10.
3. Incremento: i++.

A variável i começa com o valor zero; em seguida, é feita a verificação de


se i < 10 e, caso a condição seja verdadeira, o comando Serial.println(i) será
executado. Após esse comando, chegar-se-á ao fim do for na linha 3. Nessa hora,
será aplicado o incremento e, em seguida, será verificada a condição, que, se
continuar verdadeira, o comando da linha 2 executará novamente e isso se
repetirá enquanto a condição for verdadeira.
Então, resumindo,

7
1. i = 0: variável i começa com um valor inicial zero.
2. i < 10: verifica-se se a condição é verdadeira – nesse caso, é verdadeira.
3. Executa-se o comando Serial.println(i).
4. Incrementa-se o valor de i, ou seja, o valor de i aumenta em 1.
5. Volta-se ao passo 2.
6. Caso a condição seja falsa, sai-se do loop.

Perceba que, com esse loop, é possível controlar exatamente quantas


vezes serão executados os comandos. Então, se em uma aplicação for necessária
a execução de algum comando por uma quantidade de vezes fixa, deve-se usar
o for. No exemplo 2, será utilizado esse loop no Arduino (Figura 6).

Figura 6 – Exemplo 2: uso do Arduino com servomotor

Crédito: Charles Way Hun Fung/Tinkercad Screenshots Reprinted Courtesy Of Autodesk, Inc.

8
Figura 7 – Uso do loop for

Nesse segundo exemplo (Figuras 6-7), fazemos uso de um dispositivo


chamado servomotor, que é controlado por sinais enviados pelo microcontrolador:
dependendo do sinal enviado, o motor se posiciona em determinado ponto.
Para fazer uso do servomotor, devemos utilizar a biblioteca Servo.h, que
fornece um conjunto de funções próprias para o uso de servomotores. O eixo
desses motores gira em 180º em cada sentido, horário e anti-horário.
Analisando o código do exemplo 2, a função setup() possui o comando:
servo.attach(9), a qual indica que o servomotor está no pino 9 do Arduino. Em
seguida, na função loop() há dois laços for. O primeiro loop tem a variável de
controle pos, que varia de 0 a 180, enviando cada valor para o motor por
intermédio do comando servo.write(pos) em intervalos de 15 ms – função
delay(15). No loop seguinte acontece a operação oposta: a variável pos começa
com o valor inicial de 180 e varia até 0, enviando cada um dos valores para o
motor em intervalos de 15 ms.

9
Uma observação sobre esse exemplo é que o motor é um dispositivo
mecânico e tem um tempo de resposta muito maior que o microcontrolador.
Devido a isso, é importante o uso da função delay para fazer o motor receber os
comandos do microcontrolador e ter um tempo para produzir a resposta.

TEMA 4 – ESTRUTURA DE REPETIÇÃO NO SCRATCH

O Scratch fornece algumas estruturas que comportam as estruturas de


repetição que são apresentadas na Figura 8.

Figura 8 – Comandos de repetição no Scratch: (a) repetição em quantidade


específica; (b) repetição por condição

(a) (b)

A Figura 8 apresenta dois tipos de repetição. A estrutura de repetição


apresentada em (a) faz a repetição por uma quantidade definida de vezes,
semelhantemente a um loop for. O código a seguir representa o uso para acender
e apagar um LED (Figura 9).

Figura 9 – Código equivalente à repetição apresentada na Figura 8 (a)

A ideia é a mesma do loop for: o laço irá incrementar a variável até chegar
ao valor determinado, executando os comandos. O loop apresentado em 8 (b) é
baseado em uma condição; para isso, deve-se criar uma variável para o controle
do laço. A seguir é apresentado um exemplo do uso desse loop (Figura 10).

10
Figura 10 – Piscando um LED usando loop

Crédito: Charles Way Hun Fung/Tinkercad Screenshots Reprinted Courtesy of Autodesk, Inc.

Figura 11 – Exemplo de pisca-LED usando Scratch

A Figura 10 apresenta um LED conectado no pino 13 no Arduino. Em


seguida há a Figura 11, na qual temos um algoritmo em Scratch que faz o LED
piscar dez vezes. Perceba que, nesse algoritmo, há uma variável de controle

11
chamada X, que varia de 0 a 9 (enquanto X < 10) – nesse loop, acendendo o LED
por 1 segundo e apagando o LED por outro segundo.
Outra estrutura de repetição que existe é a contagem da Figura 12.

Figura 12 – Bloco de contagem

Essa estrutura tem um formato semelhante à estrutura for e a repetição é


realizada com contagem crescente ou decrescente, mudando o valor da variável
conforme a quantidade apresentada no campo por. A variável que será usada
para a variação é apresentada no campo para e a variação de começo e fim pode
ser acrescentada logo a seguir, no intervalo de valor inicial a valor final, indicado
como 1 a 10 no exemplo da Figura 12.
Como exemplo, vamos utilizar o mesmo circuito da Figura 6, circuito do
Arduino com um servomotor. A seguir, podemos fazer um programa em Scratch
que faz o motor girar 180° no sentido anti-horário e, depois, 180° no sentido
horário.

Figura 13 – Programa em Scratch para controle de servomotor

Na Figura 13, os loops são controlados pela variável pos, esta variando de
0 a 180, incrementando de 1 em 1 o valor de pos no primeiro loop. No segundo
loop, a variação é de 180 a 0, decrementando de 1 em 1 o valor de pos.
12
TEMA 5 – EXEMPLO

Faremos a leitura de um sensor de temperatura, uma leitura a cada 100


ms, mostrando a média de 10 leituras no monitor serial a cada 1 segundo. Para
fazer essas leituras, foi montado o circuito a seguir (Figura 14).

Figura 14 – Leitura do sensor de temperatura

Crédito: Charles Way Hun Fung/Tinkercad Screenshots Reprinted Courtesy of Autodesk, Inc.

O código da Figura 15 apresenta uma resolução para fazer dez leituras e


depois mostrar a média de valores na serial.

Figura 15 – Código de solução do exemplo

13
O sensor de temperatura utilizado no exemplo da Figura 15 é o TMP36,
que está conectado com o pino da esquerda em 5 V e o pino da direita no terra
(GND). O pino do meio é uma saída analógica que está conectada no pino
analógico zero do Arduino.
Nesse exemplo foram declaradas duas variáveis do tipo float, temperatura
e temp_media, que são a temperatura medida e a temperatura média,
respectivamente. A variável temperatura recebe o valor baseado no valor
analógico lido do sensor, a cada 100 ms. A função map faz um remapeamento do
valor da variável analógica de um valor entre 0 a 1.023, para valores de -40 a 125,
o que corresponde à conversão para graus Celsius.
O loop for é controlado pela variável i, esta variando de 0 a 9 (i < 10).
Durante essa condição verdadeira, a variável temp_media irá somar todos os
valores de temperatura adquiridos. O operador += indica que irá se somar o valor
atual de temp_media com o valor de temperatura e esse valor resultante irá
substituir o valor atual de temp_media. Após o final do loop, os valores somados
acumulados em temp_media são divididos por 10, ou seja, o número de valores
armazenados, e mostrará na serial esse valor como é mostrado o monitor serial
na Figura 16.

Figura 16 – Monitor serial resultante

Na simulação, foi realizada a variação da temperatura manualmente.

14
REFERÊNCIAS

ALVES, W. P. Linguagem e lógica de programação. 1. ed. São Paulo: Érica,


2014.

ASCENCIO, A. F. G. Fundamentos da programação de computadores. 1. ed.


São Paulo: Prentice Hall, 2002.

FORBELLONE, A. L. V. Lógica de programação: a construção de algoritmos e


estrutura de dados. 3. ed. São Paulo: Prentice Hall, 2005.

MCROBERTS, M. Arduino básico. 1. ed. São Paulo: Novatec, 2011.

OLIVEIRA, C. L. V. Arduino descomplicado: aprenda com projetos de eletrônica


e programação. 1. ed. São Paulo: Érica, 2017.

15

Você também pode gostar