Decisões com if e else no firmware

Uma comparação pergunta se uma relação é verdadeira ou falsa. Em C/C++, seu resultado é um valor booleano: true ou false.

Com valores inteiros de tipos compatíveis, use:

• == igual a
• != diferente de
• < menor que
• <= menor ou igual a
• > maior que
• >= maior ou igual a

Por exemplo, se temperatura vale 25, temperatura >= 20 resulta em true; temperatura < 20 resulta em false. Uma comparação não muda o valor da variável: ela apenas responde à pergunta feita pelo operador.

O sinal de igualdade aparece em duas tarefas diferentes:

• contador = 3; é uma atribuição: grava 3 na variável.
• contador == 3 é uma comparação: verifica se o valor atual é 3 e produz true ou false.

A comparação tem dois sinais de igual. Ao revisar uma expressão que deveria apenas verificar um valor, confira esse detalhe: trocar == por = pode alterar a variável e ainda permitir que o código seja compilado.

Considere int nivel = 7;. As seis primeiras linhas apenas comparam; a última altera a variável.

Associe cada operador ao significado da comparação. Os operadores que contêm = incluem a igualdade no teste.

Agora avalie resultados que não estão resolvidos no código. Considere int leitura = 12; e determine a sequência de valores booleanos, na ordem das expressões:

1. leitura < 12
2. leitura <= 12
3. leitura != 9
4. leitura > 15

A primeira dupla mostra a diferença entre excluir e incluir exatamente o limite 12.

Complete apenas o operador que verifica se leitura é igual a 12. A variável não deve ser alterada.

Uma decisão, dois caminhos

Use if quando um comando deve ocorrer somente se a condição for verdadeira. A condição fica entre parênteses e o bloco que ela controla fica entre chaves.

Acrescente else quando houver uma alternativa para o caso falso. O firmware executa um dos blocos e, depois, continua na primeira instrução após as chaves.

Considere valor já definido como um inteiro. Esta decisão comanda o LED integrado.

Leia o código de cima para baixo:

• Se valor >= 10 resultar em true, executa digitalWrite(..., HIGH).
• Se resultar em false, ignora o primeiro bloco e executa o bloco do else: digitalWrite(..., LOW).
• As chaves deixam explícito quais instruções pertencem a cada ramo, mesmo que hoje cada bloco tenha apenas uma linha.

Não coloque ponto e vírgula entre if (condição) e {. As chaves devem vir logo em seguida.

Complete as duas partes que tornam esta uma decisão completa: a condição do if e a palavra que inicia o caminho falso.

Sem else, uma condição falsa simplesmente não executa o bloco do if. Ela não cria, por conta própria, um comando LOW.

Suponha que o LED já foi comandado para HIGH antes deste trecho e que valor vale 3.

Trecho executado depois de o LED já estar em HIGH.

Uma faixa numérica é definida por dois limites. Para verificar se valor está dentro da faixa de 10 a 20, incluindo as pontas, as duas comparações precisam ser verdadeiras:

(valor >= 10) && (valor <= 20)

• && significa “e”: exige as duas condições verdadeiras.
• || significa “ou”: basta uma condição verdadeira.
• ! significa “não”: inverte o resultado de uma condição.

Use parênteses em cada comparação. Eles deixam claro o que está sendo comparado e tornam a condição mais fácil de revisar.

Há três formas úteis de descrever a mesma região numérica:

• Dentro, de 10 a 20 inclusive: (valor >= 10) && (valor <= 20).
• Fora dessa faixa: (valor < 10) || (valor > 20).
• Não dentro da faixa: !((valor >= 10) && (valor <= 20)).

No último caso, os dois pares de parênteses mostram que ! nega o resultado da condição inteira, e não apenas uma das comparações.

Três formas de expressar regras para o mesmo valor.

Em uma condição composta, C/C++ avalia primeiro o operando à esquerda. Só então decide se precisa avaliar o operando à direita.

• Com &&, se a parte esquerda for false, o resultado já será false. A parte direita é ignorada.
• Com ||, se a parte esquerda for true, o resultado já será true. A parte direita é ignorada.

Esse comportamento é chamado de curto-circuito. Quando não há curto-circuito, o operando direito é avaliado normalmente.

Para cada expressão, determine o que acontece com o operando da direita. Considere somente as comparações mostradas: não é necessário executar código na placa.

Para evitar uma divisão por zero, coloque a verificação do divisor à esquerda de &&. Se denominador for zero, denominador != 0 resulta em false; assim, a divisão à direita é ignorada.

Quando o denominador não é zero, o lado esquerdo é true e a divisão pode ser avaliada.

Condição usada antes de acender o LED quando a média inteira for maior que 3.

Complete a parte esquerda da condição. Ela deve impedir que soma / divisor seja avaliada quando divisor valer zero.

Quando há alternativas mutuamente exclusivas, encadeie if, else if e else. A cadeia é examinada de cima para baixo e executa somente o primeiro bloco cuja condição for verdadeira. Depois disso, os demais ramos são ignorados.

Para classificar leitura em relação à faixa inclusiva de 20 a 80:

• abaixo de 20;
• de 20 a 80, incluindo os limites;
• acima de 80.

O segundo teste pode ser apenas leitura <= 80: para alcançá-lo, o primeiro (leitura < 20) já foi falso. Logo, nesse ponto, sabemos que leitura >= 20.

O else final não possui condição: ele atende qualquer valor que não tenha sido aceito pelos testes anteriores. As chaves deixam explícito qual comando pertence a cada ramo.

Até aqui, você usou uma cadeia if / else if / else para escolher um único ramo. Nela, assim que uma condição é verdadeira, as alternativas seguintes são ignoradas.

Já vários if separados são decisões independentes: cada condição é testada, mesmo que uma anterior tenha sido verdadeira. Por isso, mais de um bloco pode escrever no mesmo LED durante uma passagem por loop().

Quando a regra pede apenas uma classificação — por exemplo, abaixo, dentro ou acima de uma faixa — prefira a cadeia exclusiva. Use if independentes somente quando cada ação puder ocorrer junto das demais.

Observe dois if independentes. Para valor = 12, as duas condições são verdadeiras. A execução segue de cima para baixo: primeiro o LED recebe HIGH; depois recebe LOW.

O comando final é, portanto, LOW, pois é a última escrita executada. Isso não apaga o fato de que o primeiro ramo também foi percorrido.

Dois testes independentes escrevem no mesmo LED.

Considere que o LED começou com comando LOW antes desses testes. Para valor = 12, qual rastreamento está correto?

Uma tabela separa o caminho percorrido do estado final. Considere o comando inicial LOW e o código com os dois if independentes da tela anterior.

Agora o LED recebe um comando inicial conhecido antes de duas decisões independentes.

Nesta prática, use somente o LED integrado do Uno R3 e a alimentação USB. O programa classifica um valor inteiro como abaixo da faixa, dentro da faixa inclusiva ou acima dela. O LED acende somente no ramo central.

Os ramos “abaixo” e “acima” comandam LOW. Portanto, um LED apagado confirma que o valor está fora da faixa, mas não informa sozinho qual desses dois ramos ocorreu. Antes de olhar a placa, use o valor atribuído e as condições para prever o caminho.

Crie um sketch local, substitua o conteúdo pelo código abaixo e grave-o no seu Uno R3. Em cada tentativa, altere somente a atribuição de valorTeste, salve, compile e grave novamente.

Todos os ramos enviam um comando explícito ao LED. Assim, o resultado de cada gravação não depende de um comando anterior.

O valor inicial 15 está entre 10 e 20, incluindo os limites. Depois de confirmar esse caso, teste um valor por vez: altere a linha de valorTeste, salve, compile, grave e observe o LED.

Antes de consultar o gabarito ou gravar cada versão, complete a condição do ramo central. Ela deve aceitar os dois limites e os valores entre eles.

Regra a implementar: acenda o LED integrado somente quando modo for igual a 1 e valor estiver de 20 a 30, incluindo 20 e 30. Em qualquer outro caso, apague o LED.

Há somente dois comandos finais possíveis: HIGH ou LOW. Por isso, uma condição composta seguida de if e else expressa a regra sem criar ramos concorrentes.

Antes de escrever, transforme a frase em testes: igualdade para o modo; >= para o limite inferior; <= para o superior.