Ao fazer projetos com microcontroladores, você deve conhecer as instruções que controlam o fluxo de um programa ou saltos. para isso, existem várias instruções condicionais que serão estudadas neste artigo. A maioria das automações e circuitos inteligentes modernos fazem uso dessas instruções. Daí a importância de conhecê-los e entender como eles funcionam e como podem ser usados. Programadores como Bill Gates e muitos outros, recomendo que todos devem aprender a processadores de programa e microcontroladores, como isso se desenvolve a lógica de bom senso e inteligência.
MIC034S
Todas as instruções de um microcontrolador podem ser classificadas em 3 classes principais:
1 - instruções de salto condicional.
2 - Instruções de memória (movimentos variáveis).
3 - Instruções Aritméticas e Lógicas.
No presente artigo iremos estudar e implementar as instruções do salto condicional. Na Figura 1 podemos ver a placa Arduino Uno e na Figura 2 do IDE ou ambiente de desenvolvimento, que pode ser baixado a partir do site Arduino. Usaremos essas ferramentas de hardware e software para desenvolver os exemplos apresentados neste artigo.
INSTRUÇÕES DE SALTO CONDICIONAL.
Normalmente as instruções dentro de um microcontrolador, são executadas sequencialmente, isto é, executando uma após a outro, e assim por diante. Mas na maioria dos circuitos que usam microcontroladores, você precisa quebrar essa sequência, de modo a fazer projetos inteligentes.
A lógica da programação é muito semelhante ao comportamento humano. Por exemplo, se estiver chovendo, é provável que a maioria das pessoas, pegue um guarda-chuva, se vai sair. Ou se uma pessoa estiver com sede, procure água para beber. Nos microcontroladores, a lógica é muito semelhante.
Por exemplo, para medir a temperatura ambiente de um lugar. Se for muito quente, ligar um ventilador, mas se for muito frio, acender um aquecedor. Neste artigo, veremos como podemos emular ou imitar o comportamento humano em microcontroladores. Para isso, é necessário conhecer as instruções de controle de fluxo ou instruções de salto condicionais que podem ser executados em um microcontrolador e para melhor compreender o funcionamento dos comandos condicionais, é necessário conhecer os principais componentes de um microcontrolador.
PRINCIPAIS PARTES DE UM MICROCONTROLADOR.
Na Figura 3 podemos ver as principais partes de um microcontrolador. A seguir, uma lista dessas partes:
1 - CPU (Central Processing Unit) é responsável pelo processamento das instruções.
2 - Memória do programa. Onde as instruções que a CPU deve executar são armazenadas.
3 - Memória de dados (RAM). Onde os dados do programa são armazenados.
4 - Portos de Entrada / Saída. Onde podemos tirar ou inserir dados.
5 - memória EEPROM. Para armazenamento permanente de dados.
Na Figura 4 podemos ver um mapa conceitual das partes de um microcontrolador. Neste mapa podemos ver que um microcontrolador é formado principalmente pela CPU ou Unidade Central de Processamento e Memórias. Ao mesmo tempo, a CPU é formado pela unidade de busca, decodificação e execução de instruções eo ALU ou unidade lógica e aritmética.
As memórias são formadas por: Memória de programa, memória RAM, portas de entrada / saída e memória EEPROM. Podemos entender a Figura 4, como as partes de um microcontrolador.
A Figura 5 mostra como essas partes estão inter-relacionadas ou conectadas. A CPU está diretamente conectada à memória do programa, a fim de buscar, decodificar e executar as instruções. Também podemos observar que a CPU se conecta à memória RAM e às portas de entrada / saída.
A Figura 6 mostra como as instruções são armazenados na memória do programa, que são executadas sequencialmente e, geralmente, sempre repetida em um loop ou laço, ou seja, quando a última instrução é executada, o programa é reiniciado.
A Figura 7 mostra uma instrução condicional, isto é, se o sensor de leitura é maior do que 16, armazenados na variável de ponto de ajuste na memória de dados, as instruções 3 e 4 são executadas, mas se for inferior, não há tais instruções elas não são executadas. Aqui nós estamos usando uma instrução condicional.
Tomada de decisão baseada em uma condição.
Todas as declarações condicionais são compostas de 3 partes:
1 - instrução.
2 - Condição de teste.
3 - O bloco de código que será executado se a condição for atendida.
A figura 8 mostra partes de uma declaração condicional.
A seguinte é uma lista de instruções utilizadas para testar uma condição:
if
if else
for
while
do while
Para a condição de que é necessário o uso de um operador para realizar o teste de algum valor, geralmente ler a partir de uma porta de entrada / saída ou armazenados numa variável em memória. Os principais operadores são:
== (igualdade)
! = (Diferença)
<(Menor que)
> (Maior que)
<= (Menor ou igual)
> = (Maior ou igual a)
&& (AND lógico)
|| (OU lógico)
blocos de código para executar, tipicamente ligam ou desligam atuadores conectados aos pinos de saída. Vamos estudar cada uma das declarações condicionais, que podem ser usadas ??em um microcontrolador. Nos títulos das instruções apresentadas neste artigo, digite a palavra em letras maiúsculas (IF, WHILE, ETC), só para destacar o nome da instrução, mas para escrever no editor (IDE), você deve fazê-lo com letras minúsculas ( if, while, etc.), como usado na linguagem Arduino é C / C ++ e todas as instruções de saltos condicionais são escritas em letras minúsculas.
A Instrução IF (se)
A instrução if pode ser entendido como: "se alguma coisa acontecer, fazer isso". Por exemplo, considere a seguinte declaração:
if (temperatura> 16)
{
Bloco de código para executar.
}
Esta instrução condicional está dizendo que, se a temperatura for superior a 16 graus Celsius, execute o bloco de código.
A Figura 9 mostra um fluxograma, onde um diodo emissor de luz acende-se, se a leitura do sensor de temperatura é maior do que 16 graus Celsius. O código para este exemplo seria:
if (temperatura > 16)
{
digitalWrite(led, HIGH);
}
Com este exemplo, podemos ver as infinitas possibilidades de testar os valores de variáveis numéricas. Os exemplos neste artigom pode ser encontradod no menu: Arquivo-> exemplos-> 05.Control. Ver Figura 10.
A INSTRUÇÃO SE ENTÃO (se ... else).
Esta instrução permite executar um bloco de código, caso a condição seja cumprida e outro bloco de código se a condição não for atendida. Por exemplo, o programa a seguir acende um LED, se a temperatura for superior a 30 graus Celsius, mas se isso não for atendido, desligue o LED. Esta instrução pode ser entendida como: "Se a condição for atendida, faça isso, caso contrário, faça outra coisa".
A Figura 11 mostra o diagrama de fluxo.
if(temperatura > 16)
{
digitalWrite(led, HIGH);
}
else
{
digitalWrite(led, LOW);
}
O exemplo seguinte de instrução condicional if..else, pode ser encontrado no menu: File-> Examples-> 05.Control-> IfStatementConditional
const int analogPin = A0; // pin that the sensor is attached to const int ledPin = 13; // pin that the LED is attached to const int threshold = 400; // an arbitrary threshold level that's in the range of the analog input void setup() { // initialize the LED pin as an output: pinMode(ledPin, OUTPUT); // initialize serial communications: Serial.begin(9600); } void loop() { // read the value of the potentiometer: int analogValue = analogRead(analogPin); // if the analog value is high enough, turn on the LED: if (analogValue > threshold) { digitalWrite(ledPin, HIGH); } else { digitalWrite(ledPin, LOW); } // print the analog value: Serial.println(analogValue); delay(1); // delay in between reads for stability }
O programa anterior, configura um pino analógico como uma entrada e um pino de saída para controlar um LED. O programa lê o pino analógico e o armazena na variável analogValue. Se este valor for maior que o dado à variável de limiar, o LED acende. Caso contrário, o LED se apaga. A Figura 12 mostra o circuito eletrônico para testar este programa.
A INSTRUÇÃO COMUTE / CASO (switch / case).
Esta instrução é baseada no operador de igualdade (==) e é usada para valores numéricos. O seguinte é um exemplo desta instrução. Se a temperatura variável for igual a 7, o LED fica vermelho. Se a variável for igual a 12, ligue o LED verde. Se a variável for igual a 32, ligue o LED azul.
switch (temperatura) {
case 7:
digitalWrite(redLED, HIGH);
break;
case 12:
digitalWrite(greenLED, HIGH);
break;
case 32:
digitalWrite(blueLED, HIGH);
break;
}
O seguinte exemplo pode ser encontrado no menu: File-> Examples-> 05.Control-> SwitchCase. Neste exemplo, conectamos uma resistência variável à luz ou LDR à porta analógica 0. O programa lê o sensor e o mapeia para 4 valores (0, 1, 2 e 3). Coloque o circuito em um local claro. Agora você pode mover a mão sobre o sensor ou o LDR e pode ver os resultados no monitor serial. Este é um bom exemplo do switch ... case statement. O circuito eletrônico para testar este programa pode ser visto na Figura 13.
// these constants won't change. They are the lowest and highest readings you // get from your sensor: const int sensorMin = 0; // sensor minimum, discovered through experiment const int sensorMax = 600; // sensor maximum, discovered through experiment void setup() { // initialize serial communication: Serial.begin(9600); } void loop() { // read the sensor: int sensorReading = analogRead(A0); // map the sensor range to a range of four options: int range = map(sensorReading, sensorMin, sensorMax, 0, 3); // do something different depending on the range value: switch (range) { case 0: // your hand is on the sensor Serial.println("dark"); break; case 1: // your hand is close to the sensor Serial.println("dim"); break; case 2: // your hand is a few inches from the sensor Serial.println("medium"); break; case 3: // your hand is nowhere near the sensor Serial.println("bright"); break; } delay(1); // delay in between reads for stability }
O exemplo seguinte pode ser encontrado no menu: File-> Examples-> 05.Control-> SwitchCase2. Neste exemplo, usamos o Monitor Serial para demonstrar ou testar o uso da instrução de comutação. O monitor serial é encontrado no menu: Ferramentas-> Monitor Series. Abra o monitor serial e envie qualquer caractere. Os caracteres a, b, c, d e e acenderão algum LED. Qualquer outro caractere desligará os LEDs. O circuito usado para testar este programa pode ser visto na Figura 14.
void setup() { // initialize serial communication: Serial.begin(9600); // initialize the LED pins: for (int thisPin = 2; thisPin < 7; thisPin++) { pinMode(thisPin, OUTPUT); } } void loop() { // read the sensor: if (Serial.available() > 0) { int inByte = Serial.read(); // do something different depending on the character received. // The switch statement expects single number values for each case; in this // example, though, you're using single quotes to tell the controller to get // the ASCII value for the character. For example 'a' = 97, 'b' = 98, // and so forth: switch (inByte) { case 'a': digitalWrite(2, HIGH); break; case 'b': digitalWrite(3, HIGH); break; case 'c': digitalWrite(4, HIGH); break; case 'd': digitalWrite(5, HIGH); break; case 'e': digitalWrite(6, HIGH); break; default: // turn all the LEDs off: for (int thisPin = 2; thisPin < 7; thisPin++) { digitalWrite(thisPin, LOW); } } } }
A INSTRUÇÃO FOR (para).
A instrução for é usada para executar blocos de código várias vezes (loops). O número de vezes que o bloco de código é repetido é controlado por um contador. As partes da instrução for são 5, que listamos na lista a seguir:
1 - Instrução.
2 - Inicialização do contador.
3 - A condição ou até quantas vezes o bloco de código é repetido.
4 - O incremento do contador.
5 - O bloco de código.
Como podemos ver, esta instrução é especializada para repetir a execução de um bloco de código, certo número de vezes. Por exemplo, o programa a seguir executará o Bloco de Código 18 vezes.
for (int counter = 0; counter < 18; counter ++)
{
Bloco de código
}
O exemplo seguinte pode ser encontrado no menu: File-> Examples-> 05.Control-> ForLoopIteration. Neste exemplo, podemos ver o uso da instrução for. O circuito usado para testar este programa pode ser visto na Figura 15. O que este programa faz é: primeiro ligar as luzes sequencialmente em uma direção, do pino mais baixo para o mais alto, então na outra direção, a mais alto ao mais baixo. Algo muito parecido com as luzes do popular carro fantástico.
int timer = 100; // The higher the number, the slower the timing. void setup() { // use a for loop to initialize each pin as an output: for (int thisPin = 2; thisPin < 8; thisPin++) { pinMode(thisPin, OUTPUT); } } void loop() { // loop from the lowest pin to the highest: for (int thisPin = 2; thisPin < 8; thisPin++) { // turn the pin on: digitalWrite(thisPin, HIGH); delay(timer); // turn the pin off: digitalWrite(thisPin, LOW); } // loop from the highest pin to the lowest: for (int thisPin = 7; thisPin >= 2; thisPin--) { // turn the pin on: digitalWrite(thisPin, HIGH); delay(timer); // turn the pin off: digitalWrite(thisPin, LOW); } }
O INSTRUÇÃO WHILE (while)
A instrução while pode ser entendido como: "enquanto a condição for verdadeira, execute o bloco de código". A diferença entre a instrução if ea instrução enquanto, é que se, se a condição for verdadeira, execute o bloco de código uma vez enquanto a instrução while, execute o bloco de código, tantas vezes quanto necessário até a condição ser cumprida . Quando a condição é falsa, o programa pula e sai da instrução while. Por exemplo, esta instrução pode ser útil em uma fechadura eletronica e se o usuário não inserir a chave correta, o ciclo se repete. O seguinte é um exemplo:
while (userKey! = currentKey) {
Bloco de código WrongKey ();
}
Enquanto a chave é diferente, o bloco de código será executado: WrongKey.
O exemplo a seguir pode ser encontrado no menu: Arquivo-> exemplos-> 05.Control-> WhileStatementConditional. Este exemplo mostra como usar a instrução while para calibrar o valor de um sensor analógico. Quando o programa entra no loop principal, lê o valor do LDR (fotorresistor) conectado na entrada analógica 0. Mas se o botão ligado à entrada digital 2 for pressionado, o programa chama a rotina de calibragem(). Essa rotina verifica os níveis mais alto e mais baixo do sensor. Quando o botão é liberado, o programa continua no loop principal. Esta técnica permite, atualizar os valores máximos e mínimos de uma mudança quando as condições de luz local ou ambiente.
A Figura 16 mostra o diagrama elétrico e a Figura 17, como ele pode ser montado em uma placa de ensaio.
Conecte o sensor ao pino analógico 0, com um resistor de 10Kohms ao terra. Conecte o botão ao pino digital 2, com um resistor ao terra. Conecte o LED ao pino digital 9 através de um resistor de 330 Ohms. O seguinte é o programa.
const int sensorPin = A0; // pin that the sensor is attached to const int ledPin = 9; // pin that the LED is attached to const int indicatorLedPin = 13; // pin that the built-in LED is attached to const int buttonPin = 2; // pin that the button is attached to // These variables will change: int sensorMin = 1023; // minimum sensor value int sensorMax = 0; // maximum sensor value int sensorValue = 0; // the sensor value void setup() { // set the LED pins as outputs and the switch pin as input: pinMode(indicatorLedPin, OUTPUT); pinMode(ledPin, OUTPUT); pinMode(buttonPin, INPUT); } void loop() { // while the button is pressed, take calibration readings: while (digitalRead(buttonPin) == HIGH) { calibrate(); } // signal the end of the calibration period digitalWrite(indicatorLedPin, LOW); // read the sensor: sensorValue = analogRead(sensorPin); // apply the calibration to the sensor reading sensorValue = map(sensorValue, sensorMin, sensorMax, 0, 255); // in case the sensor value is outside the range seen during calibration sensorValue = constrain(sensorValue, 0, 255); // fade the LED using the calibrated value: analogWrite(ledPin, sensorValue); } void calibrate() { // turn on the indicator LED to indicate that calibration is happening: digitalWrite(indicatorLedPin, HIGH); // read the sensor: sensorValue = analogRead(sensorPin); // record the maximum sensor value if (sensorValue > sensorMax) { sensorMax = sensorValue; } // record the minimum sensor value if (sensorValue < sensorMin) { sensorMin = sensorValue; } }
INSTRUÇÃO EXECUTE... ENQUANTO (do ... while)
A instrução do... while, é semelhante à instrução while, exceto com a diferença de que ela força o programa a executar, pelo menos uma vez, o bloco de código que está entre os colchetes da instrução do. Vamos ver um exemplo:
do
{
currentKey = ReadKeyboard();
} while (userKey ¡= currentKey);
Este código garante que pelo menos uma vez seja lido o teclado (keyboard). O uso de while ou do ... while depende das necessidades da aplicação ou projeto.
Como tudo na vida, com a prática podemos obter bons resultados. Não se preocupe se no início o programa não é o que idealizou. Verifique com o monitor serial o programa e redefina ou melhore o programa.
