Neste projeto vamos empregar um sensor para verificar a temperatura do ambiente e enviar a leitura para um Arduino, que se encarregará de interpretar o valor lido e então exibir em um display LCD a temperatura medida em graus Celsius (ºC).

Para tal usaremos o sensor TMP36, que é um sensor de baixo custo, bastante comum e muito empregado em circuitos que envolvam controle de temperatura para realização de processos diversos.

Outros modelos de sensores podem ser empregados, como o TMP35 ou TMP37 bastando para isso realizar pequenas alterações no programa de acordo com as características de cada componente.

Algumas das aplicações mais comuns do TMP36 incluem:

• Sistemas de controle ambiental
• Proteção térmica de circuitos
• Controle de processos industriais
• Alarmes de incêndio
• Monitoramento de sistemas de potência
• Gerenciamento térmico de CPU

entre muitas outras que podemos imaginar.

Algumas características do sensor TMP36

A seguir temos listadas algumas das características técnicas do sensor TMP36, retiradas de seu datasheet:

• Saída Analógica: O TMP36 gera uma saída analógica proporcional à temperatura medida. A tensão de saída aumenta linearmente com o aumento da temperatura.
• Precisão: Boa precisão em relação à medição de temperatura. Sua precisão é de cerca de ±2°C.
• Alimentação: Alimentado com uma baixa tensão, tipicamente entre 2,7V e 5,5V
• Faixa de Operação: O sensor pode medir temperaturas em uma ampla faixa, geralmente de -40°C a 125°C.
• Tensão de Referência: Ele gera uma tensão de saída proporcional à temperatura, onde 0°C é representado como 0,5V. Para cada grau Celsius de aumento na temperatura ocorre um aumento de 10 mV na tensão de saída.

Para fazer a leitura da temperatura, a tensão de saída do TMP36 é conectada a um conversor analógico para digital (ADC) no microcontrolador (ou outro circuito). O microcontrolador (no caso, o Arduino) lê a tensão e, por meio de cálculos simples (explicados adiante), converte essa tensão medida em mV para uma temperatura correspondente em graus Celsius.

Mais informações sobre esse sensor podem ser obtidas no Datasheet do TMP36.

Vejamos os materiais que serão necessários para construir esse circuito e testá-lo.

Lista de Materiais

Vamos precisar dos seguintes componentes para montar o circuito do projeto:

• 01 Sensor de Temperatura TMP36
• 01 Arduino Uno (ou compatível)
• 01 Display LCD 16×2
• 01 Resistor de 220 Ω
• 01 Potenciômetro de 10 kΩ
• 01 Matriz de Contatos
• Fios diversos

O Circuito

A figura a seguir mostra as ligações dos componentes, criada com o auxílio de um software de simulação de circuitos – Tinkercad.

Diagrama Esquemático

E a seguir temos o diagrama esquemático do circuito, com detalhes de como os componentes são interligados.

Sensor TMP36 e visor LCD no Arduino – Diagrama Esquemático

Código-fonte

Na sequência temos o código que foi usado para programar o microcontrolador, com uma explicação detalhada logo após.

#include <LiquidCrystal.h>

// Inicializar a biblioteca com os números dos pinos digitais
LiquidCrystal lcd(12, 11, 2, 3, 4, 5);

// Variáveis para leitura e interpretação das leituras do TMP36
const int TEMP=0;
int val = 0;
float celsius=0.0;

void setup()
{
    // Configurar o número de colunas e linhas do LCD:
    lcd.begin(16, 2);

    // Texto a ser mostrado no LCD (texto fixo, primeira linha):
    lcd.print("Temp. °C");
}

void loop()
{
    // Posicionar o cursor na coluna 0 e linha 1 (segunda linha):
    lcd.setCursor(0, 1);

    // Ler o valor enviado pelo sensor
    val = analogRead(TEMP);

    // Calcular e ajustar a temperatura em graus Celsius
    celsius = map(((val - 20) * 3.04), 0, 1023, -40, 125); 

    // Imprimir no LCD a temperatura
    lcd.print(celsius);
}

Funcionamento do código

1. Declarações iniciais

• TEMP é uma constante que representa o pino analógico ao qual o sensor TMP36 está conectado (no caso, o pino 0).
• val é uma variável que será usada para armazenar o valor enviado pelo sensor TMP36
• celsius é a variável que armazenará a temperatura (já convertida) em graus Celsius.

2. Função setup()

3. Função loop()

celsius = map(((val - 20) * 3.04), 0, 1023, -40, 125);

map(valor, de_min, de_max, para_min, para_max);

Resultado

Assim que o circuito é ligado, o sensor inicia a detecção da temperatura ambiente e então o valor é lido pelo Arduino, que o converte e mostra a temperatura correspondente no mostrador LCD, como ilustra a imagem a seguir (retirada do simulador Tinkercad):

Temperatura sendo exibida em um display LCD a partir de um sensor TMP36

Variando a temperatura no sensor o valor exibido no LCD muda de acordo.

É isso aí! Nos próximos artigos vamos explorar mais circuitos interessantes e úteis com microcontroladores, sensores e outros componentes eletrônicos. Até!

O post Sensor de Temperatura TMP36 com Arduino e visor LCD 16×2 apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Um display de LEDs é um componente utilizado para exibir informação em um painel por meio do emprego de múltiplos segmentos de LEDs que emitem luz, acionados por tensões entre 2 e 5VCC geralmente.

Esse tipo de display pode exibir caracteres alfanuméricos, apenas números, ou ainda símbolos, além de formas geométricas e pontos em alguns modelos.

O tipo de display de LED mais simples é o Display de Sete Segmentos que, como o próprio nome diz, é composto por sete segmentos (LEDs) que podem ser acionados individualmente; geralmente, há também um oitavo segmento, que aciona um LED para representação de um ponto decimal.

A figura a seguir mostra um display de sete segmentos típico, que possui também um LED extra para representar o ponto decimal:

Figura 01 – Display de LED de Sete Segmentos

Neste tutorial vou mostrar como acionar um display de 7 segmentos típico, criando um contador numérico de 0 a 9, usando o Arduino.

Diagrama esquemático

Na figura a seguir temos o diagrama esquemático do circuito que vamos utilizar:

Lista de componentes

Precisaremos dos seguintes componentes para elaborar o circuito:

• 1 Arduino Uno (ou Mega)
• 8 Resistores de 220Ω
• 1 Display de LED de sete segmentos, catodo comum (pode ser utilizado anodo comum, porém deverão ser feitas alterações simples no circuito e no código)
• Matriz de contatos
• Fios (jumpers) diversos.

Código do sketch

Abaixo temos o código do programa que será executado neste circuito:

// Matriz de bits para representar os números de 0 a 9:
int numero[11][8] = { // 11 linhas, 8 colunas
 { 1,1,1,1,1,1,0,0 }, //0
 { 0,1,1,0,0,0,0,0 }, //1
 { 1,1,0,1,1,0,1,0 }, //2
 { 1,1,1,1,0,0,1,0 }, //3
 { 0,1,1,0,0,1,1,0 }, //4
 { 1,0,1,1,0,1,1,0 }, //5
 { 0,0,1,1,1,1,1,0 }, //6
 { 1,1,1,0,0,0,0,0 }, //7
 { 1,1,1,1,1,1,1,0 }, //8
 { 1,1,1,0,0,1,1,0 }, //9
 { 0,0,0,0,0,0,0,1 } //ponto decimal
};

// Array de configuração dos pinos digitais associados a cada segmento:
const int segmentos[8] = { 2,3,4,5,6,7,8,9 };
// 2 = segmento a
// 3 = segmento b
// 4 = segmento c
// 5 = segmento d
// 6 = segmento e
// 7 = segmento f
// 8 = segmento g
// 9 = ponto decimal

void setup() {
 // Configurar os pinos de cada segmento para saída:
 for (int i = 0; i <= 7; i++) {
   pinMode(segmentos[i], OUTPUT);
 }
}

void loop() {
 // Displays de catodo comum: acendem com valor 1 nos pinos digitais
 // chamar função mostraNumero, que exibe os números em sequência a cada 0,5 segundo (500ms):
 for (int i = 0; i <=10; i++) {
   mostraNumero(i);
   delay(500);
 }
}
// Função mostraNumero, que acende os LEDs correspondentes para exibir os números:
void mostraNumero(int valor) { // valor é a linha (número a mostrar)
   int pino = 2; // começar contagem no pino 2
   for (int i = 0; i < 8; i++) {
       digitalWrite(pino, numero[valor][i]); // fixa na linha e aciona os bits de cada coluna (0 ou 1)
       pino++;
   }
}

Funcionamento do Código

Matriz de Bits

A primeira parte do código é uma matriz chamada numero. Essa matriz é usada para representar os números de 0 a 9 e um ponto decimal (usando o último elemento da matriz). A matriz é uma matriz bidimensional com 11 linhas e 8 colunas, na qual cada linha representa um dígito (0 a 9 e o ponto decimal, com 8 bits), e cada coluna representa um segmento do display de 7 segmentos.

Sendo assim, cada elemento da matriz (numero[i][j]) é um valor binário (0 ou 1) que determina se um determinado segmento do display deve estar aceso (1) ou apagado (0) para exibir o número correspondente.

Configuração dos Pinos

Na sequência temos a configuração dos pinos digitais associados a cada segmento do display de 7 segmentos, usando um array de números. Os pinos serão configurados como saída usando a função pinMode na função setup().

Função setup()

Dentro da função setup(), todos os pinos digitais associados aos segmentos são configurados como saída, para que seja possível controlá-los.

Função loop()

A função loop() é onde o programa principal é executado continuamente. Nesse caso, ele exibe os números de 0 a 9 e o ponto decimal em sequência a cada 500 milissegundos (0,5 segundos). Isso é feito chamando a função mostraNumero(i) em um loop for que varia de 0 a 10.

Função mostraNumero(int valor)

Esta função recebe um valor inteiro que representa o número que você deseja exibir. O valor é usado como índice para acessar a matriz numero e determinar quais segmentos do display de 7 segmentos devem ser acesos ou apagados para exibir o número correspondente.

O loop for dentro da função mostraNumero percorre cada coluna da matriz numero (cada segmento do display) e usa a função digitalWrite para definir o estado (ligado ou desligado) de cada segmento com base nos valores na matriz numero.

Visualização

Veja o circuito montado em ação, realizando a contagem de números de 0 a 9 (e o ponto decimal também):

Arduino

Se preferir, assista a um vídeo que mostra os procedimentos descritos em ação:

É isso aí! Nos próximos tutoriais vamos explorar mais a fundo o uso de displays de sete segmentos, incluindo displays de dois ou mais dígitos, e também o uso de bibliotecas do Arduino para esse componente.

Até!

O post Como usar um display de LED de sete segmentos com Arduino apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Em nosso projeto anterior com Arduino, mostramos como é possível controlar a velocidade de um motor DC usando a técnica de PWM (Pulse Width Modulation). Agora, vamos mostrar como controlar a direção de rotação do motor, função extremamente importante, por exemplo, para controlar a direção de movimentação de um robô ou veículo qualquer.

Para tal, utilizaremos um circuito especializado chamado de “Ponte H“. A figura a seguir mostra a operação básica de uma ponte H:

Operação básica de uma ponte H Imagem: Wikimedia Commons

Uma ponte H possui quatro modos de operação:

• Aberto: O motor não gira (motor desligado)
• Freio: Motor não gira (parado)
• Para frente: Motor gira em uma direção
• Para trás: Motor gira na direção oposta.

Neste projeto usaremos o chip L293D, que consiste em duas pontes H full (quatro half bridges).

Lista de materiais

• 1 Arduino (Uno, Mega, etc)
• 1 Motor DC
• 1 chip L293D (ponte H)
• 1 Fonte de alimentação entre 4,5 e 36V para o motor
• Matriz de contatos
• Fios diversos

Diagrama esquemático do circuito

A seguir temos o diagrama esquemático do circuito a ser montado:

Visão do circuito

A figura a seguir ilustra a conexão entre os componentes em uma matriz de contatos (breadboard):

Código-fonte do sketch

A seguir temos o código-fonte utilizado no projeto para que o motor gire para um lado e depois para outro:

const int HABILITA = 11;
int Pino1A = 8;
int Pino2A = 7;
void setup() {
  pinMode(HABILITA, OUTPUT);
  pinMode(Pino1A, OUTPUT);
  pinMode(Pino2A, OUTPUT);
  digitalWrite(HABILITA, LOW);
}
void loop() {
  digitalWrite(Pino1A, HIGH);
  digitalWrite(Pino2A, LOW);
  digitalWrite(HABILITA, HIGH);
  delay(3000);
  digitalWrite(HABILITA, LOW);
  delay(2000);
  digitalWrite(Pino1A, LOW);
  digitalWrite(Pino2A, HIGH);
  digitalWrite(HABILITA, HIGH);
  delay(3000);
  digitalWrite(HABILITA, LOW);
  delay(2000);
}

Começamos criando uma constante de nome HABILITA e atribuindo-lhe o valor 11, correspondente ao pino do Arduino conectado ao pino 1 do L293D (habilita os canais 1 e 2 do controlador H).

Na sequência, criamos duas variáveis, Pino1A e Pino2A, que corresponderão aos pinos 8 e 7, onde o motor será conectado.

Na função de setup() configuramos os três pinos para saída (OUTPUT).

Na função principal de loop() fazemos uso da função digitalWrite() para ativar ou desativar o sinal nos pinos de controle do motor.

Quando o Pino1A está em nível alto e o Pino2A em nível baixo, o motor irá girar em uma direção; invertendo os níveis lógicos, o motor gira na direção oposta.

O pino HABILITA recebe nível lógico alto ou baixo quando queremos ativar ou desativar o circuito, respectivamente. Esse pino deve ser colocado em nível HIGH apenas após termos configurado o nível lógico nos pinos do motor.

Também usamos a função delay() para ajustar o tempo em que o motor fica girando em cada direção, ou parado.

É isso aí! Em nosso próximo projeto vamos utilizar um shield de motor para controlar a direção e velocidade de rotação de motores DC.

Até!

Anterior: Controlando a velocidade de rotação de um motor DC com Arduino

O post Controlando direção de rotação de um motor DC com Arduino e Ponte H apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste projeto, vamos iniciar a construção de um detector de vazamento de gás hidrogênio usando um sensor MQ-8 e um Arduino.

O gás hidrogênio, H₂, é o elemento número 1 na tabela periódica dos elementos, e é a substância mais leve que existe no Universo. E é altamente inflamável!

Nas CNTP (condições normais de temperatura e pressão), é um gás sem cheiro, sem gosto e sem cor, de modo que não é possível detectar sua presença apenas com nossos sentidos.

Encontra inúmeras aplicações industriais e tem sido pesquisado como possível fonte de energia alternativa em diversas áreas, como por exemplo em aplicações especiais na indústria automobilística, na forma de células de hidrogênio.

Evidentemente, por suas características físicas e químicas, se trata de uma substância perigosa, pois pode provocar explosões e incêndios se houver vazamento do gás e faiscamento, e portanto, é importante que seja monitorada a presença do elemento em um ambiente.

Vamos trabalhar aqui com um sensor MQ-8, que permite detectar a presença de gás hidrogênio. Não se trata de um sensor de nível industrial, mas ele serve perfeitamente para aprendermos como funciona esse tipo de circuito e aplicação, e a importância desse tipo de medida de segurança.

Sensor de gás hidrogênio MQ-8

Componentes

Os componentes que empregaremos no projeto são:

• Módulo de Sensor de Gás Hidrogênio MQ-8
• Arduino (Uno, Mega, etc)
• Um Buzzer (para sinalização)
• LED (para sinalização)
• Matriz de Contatos (Breadboard)
• Conectores diversos

Para gerar o gás hidrogênio que será usado nos testes vamos usar:

• Erlenmeyer  (preferencialmente) ou outro recipiente de vidro, como um copo grande.
• 5 g de hidróxido de sódio (NaOH), (uma colher de chá de soda cáustica)
• 200 ml de água
• Tiras ou pedaços pequenos de alumínio (por exemplo, uma latinha de refrigerante cortada. Cuidado para não se machucar!!!)
• Óculos de proteção
• Luvas de látex ou de nitrilo

ATENÇÃO: MUITO CUIDADO ao realizar testes com o gás hidrogênio, pois se trata de um gás altamente inflamável e explosivo. USE luvas e óculos de segurança, e teste o circuito em local bem arejado, preferencialmente em ambiente externo.

Vamos estudar agora as características do sensor MQ-8.

Sensor MQ-8 de Gás Hidrogênio

O conjunto MQ é uma série de sensores de gases de baixo custo. Existem sensores disponíveis para detecção de vários tipos de gases, com alguns listados na tabela a seguir:

O sensor MQ-8 que utilizaremos neste projeto é um sensor de custo bastante baixo e de fácil obtenção, podendo ser adquirido em lojas e sites especializados em eletrônicos, sites de leilões e sites de produtos da China em geral.

Trata-se de um sensor semicondutor para gás hidrogênio, do tipo sensor químico de metal-óxido, que utiliza como material sensível o SnO₂ (dióxido de estanho), o qual possui baixa condutividade elétrica em ambiente com ar sem hidrogênio presente. Quando um sensor de metal-óxido, como SnO₂, é aquecido a uma determinada temperatura no ar, oxigênio é absorvido na superfície do cristal e um potencial de superfície é formado, inibindo o fluxo de elétrons. Quando essa superfície é exposta a gases redutíveis, como moléculas de hidrogênio e outros gases (como metilmercaptana – CH₃SH – e álcool etílico – C₂H₅OH), o potencial de superfície diminui e a condutividade elétrica do sensor aumenta consideravelmente, de acordo com o aumento da concentração do gás.

Esse sensor encontra aplicações diversas tais como alarme de vazamento de gás doméstico, alarme de gases inflamáveis industriais e detetor portátil de gás, entre outras.

Este tipo de sensor é classificado como um sensor direto. Em um sensor direto uma característica elétrica é afetada em um elemento sensível. Os classificamos em:

• Dispositivos condutométricos: sofrem alteração de resistência ou impedância
• Dispositivos amperométricos: sofrem alteração na corrente elétrica que atravessa o sensor
• Dispositivos potenciométricos: sofrem alteração na tensão elétrica entre um par de eletrodos.

Sensores químicos diretos usam diversos fenômenos de reações químicas que afetam diretamente uma característica elétrica mensurável, como resistência elétrica, tensão, corrente ou capacitância. Esse tipo de sensor necessita de algum tipo de condicionamento de sinal elétrico, mas não tem a necessidade de um transdutor (conversor de formas de energia).

Tente usar sempre o módulo de sensor, e não o sensor por si só, caso contrário você terá de criar o circuito de controle do sensor, que já vem embutido no módulo, facilitando assim muito o desenvolvimento do projeto (e diminuindo seu custo).

Características gerais:

• Faixa de detecção vai de 100 a 1000 ppm de H₂.
• Resistência de Carga: Ajustável
• Tensão de alimentação: 5.0 V AC ou DC
• Consumo: <= 900 mW
• Tensão de saída: de 2,5 V a 4.0 V (em 1000 ppm H₂)
• Resistência do aquecedor: 31 kΩ ±5% (temperatura ambiente)
• Temperatura de operação: -10°C a +50°C

Pinagem do MQ-8

A seguir temos a pinagem do sensor MQ-8 e suas respectivas funções.

• Pino 1: VCC
• Pino 2: AOUT (saída analógica)
• Pino 3: DOUT (saída digital)
• Pino 4: GND

Modo de operação do sensor MQ-8

Os pinos VCC e GND fornecem alimentação ao sensor. O pino AOUT é o pino de saída analógica, cujo valor é proporcional à quantidade de gás detectada. Caso a tensão detectada neste pino ultrapasse um valor limite (threshold), o pino DOUT (saída digital) vai para nível 1, e é essa mudança de nível lógico que vamos detectar com o Arduino, para sinalizar que o nível de gás hidrogênio no ambiente ultrapassou o limite estabelecido ou aceitável.

O módulo possui também um potenciômetro para ajuste da sensibilidade do nível de detecção.

Curva de Sensibilidade do MQ-8

O gráfico a seguir mostra a curva de sensibilidade do sensor de gás MQ-8 com relação a diversos gases. Note que o hidrogênio é o gás primordial detectado por esse sensor, mas ele também apresenta uma certa sensibilidade a outros gases:

Por exemplo, esse sensor também é capaz de detectar gases como etanol e GLP (gás liquefeito de petróleo, mistura doméstica de butano e propano), embora com muito menor sensibilidade.

Agora que já sabemos como funciona o sensor MQ-8, vamos partir para a construção do circuito eletrônico de detecção de gás usando o Arduino. Essa será nossa tarefa na parte 02 do projeto!

O post Sensor MQ-8 de Gás Hidrogênio e Arduino – Funcionamento apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Uma das funções mais conhecidas e utilizadas em programação para Arduino é a função delay(), que permite pausar o programa por um período de tempo especificado, na forma de um parâmetro com o valor em milissegundos desejados.

A função delay() aceita um número inteiro como argumento, o qual representa o tempo em milissegundos que o programa deverá esperar até poder executar a próxima linha de código – ou seja, tempo de pausa.

Por exemplo, para criar uma pausa de 5 segundos você pode simplesmente escrever:

delay(5000);

Porém, apesar de ser muito popular, nem sempre a função delay() é a mais adequada para seu sketch. Um problema sério pode surgir com o emprego dessa função: o Bloqueio de Execução.

Bloqueio de Execução: Ao ser invocada, a função delay() bloqueia a execução do programa, pelo período de tempo especificado, e nenhuma outra instrução pode ser executada durante esse período. Desta forma, enquanto o programa espera o final do delay, ele fica totalmente ocioso.

Desta forma, durante uma chaamda à função delay(), o programa não consegue detectar entrada de sinais, processar dados e nem alterar o status de saída de pinos.

O problema é que muitas vezes precisamos executar rotinas específicas durante esse tempo de pausa.

Para evitar esses problemas, muitas vezes recomendamos empregar a função millis() em lugar da função delay().

A função millis() retorna o número de milissegundos decorridos desde que o programa foi iniciado (ou seja, desde que o Arduino foi ligado).

Esta função permite verificar o relógio do sistema regularmente, de modo que sempre é possível saber o tempo decorrido – e assim calcular intervalos de tempo que podemos pausar, mas sem bloquear a execução de códigos necessários no sketch.

Exemplos

1. Suponha que você queira pausar o programa por um certo período de tempo, como por exemplo 3 segundos. Para fazer isso com delay basta executar a instrução:

delay(3000);

Para realizar a mesma tarefa com millis(), você pode escrever algo como isto:

unsigned long agora = 0;

void setup() {
  Serial.begin(9600);
}

void loop() {

  Serial.println("Mensagem escrita a cada 3 segundos");
  // Criar a pausa de 3 segundos
  agora = millis()
  while(millis() < agora + 3000) {
    // Pausa de 3 segundos. Nada a fazer
  }
}

Como podemos ver, o código é maior e mais trabalhoso, porém realiza a pausa de 3 segundos com muita precisão.

2. Digamos agora que você deseja executar uma instrução por um período de tempo específico, mas sem bloquear a execução de outras funções no programa, como a detecção de interrupções. Por exemplo, acender um LED por 4 segundos e depois apagá-lo, mas ainda assim continuar executando outras tarefas durante esse tempo. Para tal, experimente o código a seguir:

/*
Adaptado do exemplo "Blink without Delay"
Código original em Domínio Público
http://www.arduino.cc/en/Tutorial/BlinkWithoutDelay
*/

const int LED = 9;
int estadoLED = LOW;

unsigned long tempoAnterior = 0; // Armazena o último momento em que o LED foi atualizado
const long PERIODO = 4000;

void setup() {
  Serial.begin(9600);
  pinMode(LED, OUTPUT);
}

void loop() {
  unsigned long tempoAtual = millis();

  if (tempoAtual - tempoAnterior >= PERIODO) {
    tempoAnterior = tempoAtual;

    if (estadoLED == LOW) {
      estadoLED = HIGH;
    } 
    else {
      estadoLED = LOW;
    }

    digitalWrite(LED, estadoLED);
  }

  Serial.println("Executado sem interferir no acendimento do LED");
}

Esse código resolve nosso problema de bloqueio do programa, pois é possível executar outras funções enquanto o LED estiver apagado ou aceso pelos 4 segundos determinados. O programa conta o tempo para alterar o estado do LED, e permite que outras rotinas sejam executadas enquanto isso.

Referências

Adafruit: Ditch the Delay

DZone – IoT Zone: Arduino: Using millis() Instead of delay()

O post Como substituir a função delay() por millis() no Arduino apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste projeto vamos simular um sistema de iluminação inteligente, controlando o acendimento de uma lâmpada comum (automação residencial) com um sensor de movimento infravermelho (PIR), o qual irá detectar o movimento de uma pessoa no ambiente, e seu apagamento de duas formas: automático, após um tempo determinado, ou imediato após o toque em um sensor capacitivo, que fará o papel de um Smart Switch.

Lista de materiais

• Arduino (Uno, Nano, Mega, etc)
• Lâmpada (LED, CFL ou Incandescente)
• Soquete para lâmpada
• Sensor PIR (Passive Infrared) HC-SR501
• Sensor de Toque Capacitivo TTP223B
• Módulo de Relé 5V KY-019 ou similar
• Matriz de Contatos
• Cabo 1,5 mm² ou mais grosso
• Fios diversos para breadboard
• Tomada (plugue padrão)
• Fita isolante
• Alicate de corte
• Decapador de fios (opcional)

Diagrama Esquemático

A figura a seguir mostra o diagrama esquemático do circuito que será criado:

Visão Matriz de Contatos

A ilustração a seguir mostra a conexão entre os componentes empregados no projeto:

Código-Fonte do Projeto

A seguir temos o código-fonte do projeto a ser carregado no Arduino:

const int TOQUE = 2;
const int PIR = 8;
const int LAMP = 10;
int estToque;
int estPIR;
unsigned long tempoAtual = 0;

void setup() {
  pinMode(TOQUE, INPUT);
  pinMode(PIR, INPUT);
  pinMode(LAMP, OUTPUT);
  attachInterrupt(digitalPinToInterrupt(TOQUE),apaga,RISING);
  Serial.begin(9600);
}

void loop() {
  tempoAtual = millis();
  estPIR = digitalRead(PIR);
  if (estPIR == HIGH) {
    digitalWrite(LAMP, HIGH);
    Serial.println("Lâmpada acesa");
    while (millis() < tempoAtual + 10000) {
      if (estPIR == false) {
        break;
      }
    }
    digitalWrite(LAMP, LOW);
    estPIR = false;
    Serial.println("Lâmpada apagada por tempo");
  }
}

void apaga() {
  estToque = digitalRead(TOQUE);
  if (estPIR == HIGH) {
    if (estToque == HIGH) {
      digitalWrite(LAMP, LOW);
      estPIR = false;
      Serial.println("Lâmpada apagada por toque");
    }
  }
  delay(1000);
}

Neste código usamos uma interrupção no Arduino para detectar quando o sensor de toque capacitivo é ativado, permitindo assim apagar a lâmpada em qualquer momento, por meio da chamada à função apaga(). Além disso, usamos a função millis() para temporizar o circuito, em vez de simplesmente usarmos a função delay() (que é limitada).

Usamos o Monitor Serial para visualizar mensagens relativas ao estado da lâmpada – a saber, se ela foi acesa, se foi apagada pela passagem do tempo limite, ou se foi apagada por intervenção do usuário (toque no sensor capacitivo). 

Testando o circuito

ATENÇÃO: Tome muito cuidado ao manipular o circuito após ter sido conectado na tomada da rede elétrica, , pois existe o risco de choque elétrico, que pode ser fatal. Certifique-se de ter isolado muito bem todas as conexões que envolvem o relé e a lâmpada.

Para testar o circuito basta alimentar o Arduino e conectar o plugue na tomada. Espere cerca de um minuto até o sensor se aclimatar com os níveis de infravermelho do ambiente, e então é só se movimentar na frente do PIR, o que deve fazer com que a lâmpada se acenda automaticamente.

A imagem abaixo mostra o circuito montado em uma matriz de contatos, já conectado e pronto para testes:

Tocando no nosso smart switch – o sensor de toque capacitivo –  a lâmpada deve se apagar imediatamente, não sendo acesa novamente por algum tempo mesmo que você se movimente na frente do sensor de novo – para que haja tempo de sair do recinto sem que a lâmpada seja acesa novamente.

Se o sensor de toque não for ativado, a lâmpada se apagará automaticamente após decorrido o tempo configurado no código (10 segundos aqui – mude à vontade para realizar seus testes).

O post Controle de Lâmpada com Sensor PIR e Sensor de Toque com Arduino apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste artigo vamos mostrar como usar um sensor de toque capacitivo com Arduino para disparar o acionamento de uma carga qualquer, como uma lâmpada ou um motor.

Usaremos o módulo de sensor TTP223B, que é um circuito sensor de toque muito comum e de baixo custo, o qual permite detectar toques em uma superfície demarcada em sua placa. Ao tocar na região demarcada, a saída do circuito é ativada, indo ao nível alto, por 12 segundos, e voltando logo após ao nível baixo.

A imagem a seguir mostra o módulo do sensor de toque capacitivo TTP223B:

Sensor de Toque Capacitivo TTP223B

Aplicações

Permite substituir um interruptor mecânico por um interruptor digital

Especificações técnicas

• Circuito integrado: TTP223B
• Tensão de Operação: 2V – 5,5VDC
• Tensão de Saída (nível alto): 0,8V
• Tensão de Saída (nível baixo): 0,3V
• Sensibilidade ajustável por capacitância externa (0-50 pF)
• Temperatura de Operação: -20ºC a +70ºC

Funcionamento do Sensor

Este é um dispositivo que utiliza o seu corpo como parte do circuito. Ao tocar na área sensível do módulo, a capacitância do circuito é alterada e essa alteração é detectada, fazendo com que o estado da saída do circuito seja modificado.

Este sensor capacitivo possui três pinos de conexão:

• SIG – Sinal de Saída
• VCC – Alimentação +VCC
• GND – Terra / Negativo

E uma superfície marcada denominada “Sensor”, que ao ser tocada com um dedo faz com que o sensor detecte o toque e gere um sinal de nível alto, que aparece no pino SIG. Este sinal é enviado para processamento no Arduino – em nosso caso, vamos conectar o pino SIG do sensor ao pino 9 de entrada digital do microcontrolador.

Lista de Materiais:

• 01 Arduino
• 01 Módulo de Sensor Capacitivo Touch TTP223B
• 01 LED (cor a seu gosto)
• 01 Resistor de 220 ohms
• 01 Matriz de Contatos
• 01 Cabo USB e fios de conexão variados

Diagrama Esquemático

A seguir temos o diagrama esquemático do circuito a ser montado:

Código

Na sequência, temos o código-fonte do programa que será carregado no Arduino para controlar o circuito:

const int SENSOR = 4;
const int LED = 11;
int est;

void setup() {
  pinMode(SENSOR, INPUT);
  pinMode(LED, OUTPUT);
}

void loop() {
  est = digitalRead(SENSOR)
  if (est == HIGH) {
    digitalWrite(LED, HIGH);
  }
  else {
    digitalWrite(LED,LOW);
  }
  delay(500);
}

Testando o Circuito

As imagens a seguir mostram o circuito criado em ação. Ao tocar no sensor, o LED é aceso, e ao tirar o dedo o LED se apaga:

LED apagado

LED aceso ao tocar no sensor capacitivo

É isso aí! No próximo tutorial vamos combinar sensor capacitivo com um sensor de presença infravermelho. Até!

O post Sensor de Toque Capacitivo com Arduino apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Uma interrupção é um sinal enviado por um dispositivo de hardware que temporariamente interrompe a tarefa que a CPU está executando no momento, para que o dispositivo em si seja atendido. Logo após, o programa retoma seu processamento do ponto onde havia parado.

As interrupções são realizadas em nível de hardware, quando temos um evento externo sendo acionado, como por exemplo o pressionamento de um botão, e assim um sinal é enviado para o microcontrolador (ou microprocessador). Este processamento será executado imediatamente, interrompendo o que quer que a CPU esteja realizando no momento.

Neste artigo vamos apresentar e aprender a usar as interrupções externas em programação para Arduino

Rotinas de Interrupção em Arduino

Um programa normal para Arduino consiste em duas rotinas principais: setup() e loop().

Quando empregamos interrupções, criamos uma (ou mais) função adicional, tecnicamente chamada de ISR – Interrupt Service Routine (Rotina de Serviço de Interrupção). Esta função é invocada toda vez que uma interrupção é gerada no circuito.

Assim, o programa passaria a ter uma estrutura como esta:

void setup() {
}

void loop() {
}

void isr() {
}

Note que a rotina de interrupção retorna void, ou seja, não retorna nada, apenas executa uma tarefa. Seu nome deve ser escolhido de acordo com a função que irá desempenhar. É possível ter mais de uma rotina de interrupção, dependendo da placa usada.

Em que momento exatamente esta rotina será chamada? Isso ocorre quando determinados pinos mudam seu estado – ou seja, ocorre a interrupção. Se um pino estiver em um nível lógico baixo, por exemplo, e mudar para alto, a interrupção é disparada, e o programa chama a rotina isr().

Note que apenas alguns pinos especiais são capazes de disparar interrupções, e esses pinos variam dependendo da versão do Arduino utilizada. Por exemplo, nos Arduinos Uno, Nano e Mini apenas os pinos digitais 2 e 3 podem ser usados para trabalhar com interrupções.

A tabela a seguir mostra diversos modelos de Arduino e seus respectivos pinos de interrupção:

Exemplo de Código com Interrupção

O exemplo a seguir ilustra o emprego de interrupções em Arduino:

const int LED = 9;
const int pinoInterrupcao = 2;
volatile int est = LOW;

void setup() {
  pinMode(LED, OUTPUT);
  pinMode(pinoInterrupcao, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(pinoInterrupcao), piscar, CHANGE);
}

void loop() {
  digitalWrite(LED, est);
}

void piscar() {
  est = !est;
}

Neste código, devemos conectar um botão ao pino 2, de interrupção. Toda vez que o botão for pressionado, o estado do pino muda, o que gerará uma interrupção. Assim, o LED será aceso ou apagado, dependendo de seu estado anterior.

A interrupção gerada chama a rotina piscar(), que possui o código que será executado toda vez que o botão for pressionado.

Para configurar a interrupção, nós usamos a função interna attachInterrupt(). Vamos falar sobre ela na sequência.

Função attachInterrupt()

Permite usar interrupções em pinos digitais.

Sintaxe:

attachInterrupt(pinoInterrupção, funçãoISR, modo);

Parâmetros:

• pinoInterrupção – Vetor de Interrupção. Qual pino irá gerar a interrupção (não é o número do pino!)
• funçãoISR – Função a ser chamada quando uma interrupção ocorrer
• modo – Modo de disparo da interrupção

Os modos de disparo são os seguintes:

• CHANGE – Interrupção é disparada quando o pino muda de estado
• FALLING – Interrupção é disparada quando o pino vai do estado HIGH para LOW
• HIGH – Interrupção é disparada quando o pino está no nível HIGH. Este modo somente está disponível para Arduinos baseados em chip ARM, como o Due, Zero ou MKR1000.
• LOW – Interrupção é disparada quando o pino está no nível LOW
• RISING – Interrupção é disparada quando o pino vai do estado LOW para HIGH

Relembremos no exemplo mostrado anteriormente o momento em que esta função é executada:

attachInterrupt(digitalPinToInterrupt(pinoInterrupcao), piscar, CHANGE);

Neste exemplo passamos o pino de interrupção usando uma outra função, digitalPinToInterrupt(), que toma um número de pino passado como argumento e retorna o número da interrupção associada, se houver. No caso, o pino passado é o pino 2, que equivale à interrupção 0 do Arduino Uno. Alternativamente, poderíamos ter passado diretamente o número 0, sem usar esta função auxiliar:

attachInterrupt(0, piscar, CHANGE);

Note que para isso é necessário saber os números das interrupções, e não os números dos pinos das placas, que são distintos entre si.

A palavra piscar indica qual rotina será executada quando a interrupção ocorrer. Ela deve ser codificada fora da rotina loop(), e recomenda-se que seja uma função curta e simples, que execute somente o que é estritamente necessário durante a interrupção. Outro ponto importante é que esta função não deve retornar nenhum valor, e nem pode receber valores de entrada (parâmetros). Mas pode usar variáveis, desde que sejam globais.

Finalmente, usamos o modo CHANGE, que significa que sempre que houver mudança de estado no pino (H -> L ou L -> H), a interrupção será disparada.

Note que a função attachInterrupt() deve ser declarada na rotina de setup() do programa.

Variável volatile

Um ponto importante a notar é que empregamos a variável de nome est na interrupção, para armazenar o estado do LED, e esta variável foi declarada como volatile:

volatile int est = LOW;

A palavra volatile é uma palavra-chave da linguagem C que se aplica a variáveis. Significa que o valor da variável não está totalmente sob o controle do programa em si. em nosso caso, significa que o valor do estado pode mudar, devido a uma ocorrência que o programa não pode prever, que no caso é o pressionamento do botão por um usuário.

Além disso, ao usarmos a palavra volatile nos prevenimos de problemas de compilação que possam ocorrer, como por exemplo o risco que existe do compilador simplesmente eliminar esta variável da memória ao compilar o programa, pois ela não é usada diretamente nas rotinas de loop() e setup(). Compiladores costumam fazer isso, para eliminar variáveis não utilizadas e, assim, economizar espaço em memória.

É isso aí! Existem outras formas de trabalhar com interrupções no Arduino, como por exemplo o uso de registradores e máscaras de registrador. Como são formas mais avançadas, as estudaremos em uma outra lição.

Até mais!

Referências

https://www.arduino.cc/reference/en/language/functions/external-interrupts/attachinterrupt/

O post Como usar Interrupções com Arduino apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Existem diversas funções que podem ser usadas para inserir temporização em um programa que rode na plataforma Arduino. Com essa temporização é possível pausar a execução do programa por um tempo determinado ou contar a passagem do tempo entre dois momentos específicos.

As funções de temporização disponíveis são:

• delay()
• delayMicroseconds()
• micros()
• millis()

Vamos estudar cada uma delas separadamente, com um pequeno programa de exemplo para testá-las.

Função delay()

A função delay() pausa a execução do programa por um intervalo de tempo especificado em milissegundos, cujo valor é passado como um parâmetro. Um segundo possui 1000 milissegundos.

Sintaxe:

delay(tempo);

O parâmetro tempo é o número de milissegundos (ms) de pausa. O tipo de dado aceito é unsigned int.

Essa função possui alguns contras em sua utilização. Por exemplo, durante o tempo de pausa não ocorre a leitura de valores em sensores, cálculos matemáticos e nem tampouco a manipulação de pinos – ou seja, o arduino simplesmente “congela” pelo tempo definido na função.

No geral, não se recomenda o emprego da função delay() para pausas a partir de algumas dezenas de milissegundos, exceto para aplicações realmente muito simples.

As interrupções não são desabilitadas durante a pausa de delay(), assim como a comunicação serial em RX.
Uma alternativa mais interessante é o uso da função millis().

Exemplo

Vamos fazer piscar um LED conectado ao pino 9 do Arduino, mantendo-o aceso por 2 segundos e apagado por 1 segundo:

int pino = 9;

void setup() {
  pinMode(pino, OUTPUT);
}

void loop() {
  digitalWrite(pino, HIGH);
  delay(2000);
  digitalWrite(pino, LOW);
  delay(1000);
}

Função delayMicroseconds()

A função delayMicroseconds() pausa a execução do programa por um intervalo de tempo especificado em microssegundos, cujo valor é passado como um parâmetro.

Sintaxe:

delayMicroseconds(tempo);

O parâmetro tempo é o número de microssegundos de pausa. O tipo de dado aceito é unsigned int.

Essa função funciona de forma bastante precisa em temporização a partir de 3μs; em períodos menores ela pode não ter precisão adequada. O maior valor utilizável é 16383 μs (atualmente).

Exemplo

Vamos gerar uma sequência numérica a ser exibida no monitor serial, imprimindo um número a cada cerca de 7 microssegundos:

int valor = 0;

void setup() {
  Serial.begin(9600);
}

void loop() {
  delayMicroseconds(7);
  valor += 1;
  Serial.println(valor);
}

Função micros()

A função micros() retorna o número de microssegundos decorridos desde que a placa do Arduino começou a executar o programa atual – ou seja, o tempo em execução da aplicação.
Esse número é incrementado durante cerca de 70 minutos, sendo zerado após passado esse tempo.

Em placas de Arduino de 16 MHz (como o Arduino Nano), a função possui resolução de 4μs – ou seja, o valor retornado é um múltiplo de 4. Já em placas Arduino de 8 MHz (como o LilyPad), a resolução da função micros() é de 8μs.

Sintaxe:

tempo = micros();

A variável tempo recebe o número de microssegundos (μs) decorridos desde o início do programa. O tipo de dado retornado é unsigned long.

Exemplo

Vamos mostrar no monitor serial o tempo decorrido desde que a aplicação foi iniciada, e fazer acender um LED conectado ao pino 9 do Arduino, quando esse tempo ultrapassar 5 segundos (equivalente a 5 milhões de microssegundos):

int pino = 9;
unsigned long tempo;

void setup() {
  Serial.begin(9600);
  pinMode(pino, OUTPUT);
}

void loop() {
  Serial.print("Tempo decorrido: ");
  tempo = micros();
  Serial.println(tempo);
  if (tempo > 5000000) { 
    digitalWrite(pino, HIGH);
  }
}

Função millis()

A função millis() retorna o número de milissegundos decorridos desde que a placa do Arduino começou a executar o programa atual – ou seja, o tempo em execução da aplicação.
Esse número é incrementado durante cerca de 50 dias, sendo zerado após passado esse tempo.

Sintaxe:

tempo = millis();

A variável tempo recebe o número de milissegundos (ms) decorridos desde o início do programa. O tipo de dado retornado é unsigned long.

Exemplo

Vamos mostrar no monitor serial o tempo decorrido desde que a aplicação foi iniciada, e fazer acender um LED conectado ao pino 9 do Arduino, quando esse tempo atingir exatos 5 segundos (equivalente a 5.ooo ms):

int pino = 9;
unsigned long tempo;

void setup() {
  Serial.begin(9600);
  pinMode(pino, OUTPUT);
}

void loop() {
  Serial.print("Tempo decorrido: ");
  tempo = millis();
  Serial.println(tempo);
  if (tempo > 5000) { 
    digitalWrite(pino, HIGH);
  }
}

É isso aí! Nesta lição vimos como trabalhar com eventos temporais no Arduino, empregando para isso suas funções de temporização.

Até a próxima!

O post Programação para Arduino – Funções de Temporização apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Em programação, uma estrutura chamada de desvio condicional tem por finalidade tomar uma decisão de acordo com o resultado de uma determinada condição (chamada de teste lógico), e então executar um bloco de códigos específico, o qual irá depender do resultado desse teste.

Nesta lição estudaremos os desvios condicionais simples, composto e encadeado em programação para Arduino, conhecidos como condicional if , condicional if else. e condicional if else if

O condicional simples if permite executar um bloco de instruções caso o resultado do teste lógico retorne o valor verdadeiro (true), e não realiza nenhuma ação caso o teste lógico retorne o valor falso (false).

Já o condicional composto if else permite executar um bloco de instruções caso o resultado do teste lógico retorne o valor verdadeiro (true), e um bloco de instruções diferente caso o teste lógico retorne o valor falso (false).

O condicional encadeado nada mais é do que o encadeamento de estruturas de decisão compostas em um algoritmo. Essa estrutura é empregada em situações nas quais é preciso verificar condições de teste sucessivas, onde uma ação será executada caso um conjunto anterior de ações seja satisfeito.

Sintaxe

A sintaxe do condicional if no arduino é a seguinte:

if (teste lógico) {
  bloco de código executado se teste lógico retornar verdadeiro
}

A sintaxe do condicional if else no arduino é a seguinte:

if (teste lógico) {
  bloco de código executado se teste lógico retornar verdadeiro
}
else {
  bloco de código executado se teste lógico retornar falso
}

Note que o bloco else deve vir imediatamente após a chave de fechamento do bloco if, ou ocorrerá um erro ao tentar executar o código.

E, finalmente, a sintaxe do condicional if else if no arduino é mostrada a seguir:

if (teste lógico 01) {
  bloco de código executado se teste lógico 01 retornar verdadeiro
}
else if (teste lógico 02) {
  bloco de código executado se teste lógico 02 retornar verdadeiro
}
else {
  bloco de código final, executado se nenhum teste retornar verdadeiro
}

Note que podemos ter quantos blocos else if forem necessários. Porém, se o algoritmo começar a se tornar muito complicado, recomenda-se empregar uma estrutura switch case em seu lugar.

Vejamos agora alguns exemplos da aplicação dos desvios condicionais em programação para Arduino.

Exemplo 01: Condicional Simples no Arduino

Vejamos um exemplo de aplicação do condicional simples if no Arduino. Vamos construir um circuito que consiste em um LEDs conectados à uma saída digitais do microcontrolador, o qual será aceso de acordo com um valor digitado no monitor serial. Se o valor fornecido for o número 1, o LED se acenderá e permanecerá aceso por 3 segundos; caso contrário, o LED não se acenderá.

A seguir, temos o diagrama esquemático do circuito a ser utilizado:

E a seguir, o código-fonte de nosso projeto:

const int LED = 8;

void setup() {
  Serial.begin(9600);
  pinMode(LED, OUTPUT);
}

void loop() {
  if (Serial.available()) {
    char valor = Serial.read();
    if (valor == '1') {
      digitalWrite(LED, HIGH);
      delay(3000);
      digitalWrite(LED, LOW);
    }
  }
}

Exemplo 02 – Condicional Composto no Arduino

Vejamos agora um exemplo de aplicação do condicional composto if else no Arduino. Vamos acrescentar um LED ao circuito anterior, os quais serão acesos de acordo com um valor numérico digitado no monitor serial.  Se o valor fornecido for igual a 1, o primeiro LED se acenderá e o outro permanecerá apagado; para qualquer outro valor digitado, o segundo LED será aceso e o primeiro será apagado.

A seguir, temos o diagrama esquemático do circuito a ser utilizado:

E a seguir, o código-fonte de nosso projeto:

const int LED1 = 8;
const int LED2 = 7;

void setup() {
  Serial.begin(9600);
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT)
}

void loop() {
  if (Serial.available()) {
    char valor = Serial.read();
    if (valor == '1') {
      digitalWrite(LED1, HIGH);
      digitalWrite(LED2, LOW);
    }
    else {
      digitalWrite(LED1, LOW);
      digitalWrite(LED2, HIGH);
    }
  }
}

Exemplo 03: Condicional Encadeado no Arduino

E agora uma aplicação do condicional encadeado em Arduino. Construiremos um circuito com quatro LEDs conectados às saídas digitais do microcontrolador, os quais serão acesos de acordo com um valor numérico distinto fornecido por meio do monitor serial (de 1 a 4). Se um valor diferente for digitado, nenhum LED permanecerá aceso.

Abaixo temos o diagrama esquemático do circuito a ser utilizado:

E a seguir, o código-fonte de nosso projeto:

const int LED1 = 7;
const int LED2 = 8;
const int LED3 = 9;
const int LED4 = 10;

void setup() {
  Serial.begin(9600);
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);
  pinMode(LED4, OUTPUT);
}

void loop() {
  if (Serial.available()) {
    char LED = Serial.read();
    if (LED == '1') {
      digitalWrite(LED1, HIGH);
      digitalWrite(LED2, LOW);
      digitalWrite(LED3, LOW);
      digitalWrite(LED4, LOW);
    }
    else if (LED == '2') {
      digitalWrite(LED1, LOW);
      digitalWrite(LED2, HIGH);
      digitalWrite(LED3, LOW);
      digitalWrite(LED4, LOW);
    }
    else if (LED == '3') {
      digitalWrite(LED1, LOW);
      digitalWrite(LED2, LOW);
      digitalWrite(LED3, HIGH);
      digitalWrite(LED4, LOW);
    }
    else if (LED == '4') {
      digitalWrite(LED1, LOW);
      digitalWrite(LED2, LOW);
      digitalWrite(LED3, LOW);
      digitalWrite(LED4, HIGH);
    }
    else {
      Serial.print("Valor ");
      Serial.print(LED);
      Serial.println(" incorreto.");
      digitalWrite(LED1, LOW);
      digitalWrite(LED2, LOW);
      digitalWrite(LED3, LOW);
      digitalWrite(LED4, LOW);
    }
  }
}

É isso aí! Vimos nesta lição com empregar as estruturas de decisão condicional if / else if / else em programação para Arduino. Na próxima lição estudaremos a estrutura de decisão Switch Case em Arduino.

O post Programação para Arduino – Condicional if else apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.