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.

“UAV” é uma sigla que significa “Unmanned Aerial Vehicle“, ou, em português, Veículo Aéreo Não-Tripulado (VANT). Trata-se de um tipo de aeronave que não possui um piloto a bordo para guiá-la. Esse tipo de equipamento é controlado remotamente – ou seja, pilotado a partir de uma estação terrestre. Em alguns casos, seu voo é totalmente autônomo, por meio do emprego de planos de voo pré-programados ou ainda sistemas de controle mais complexos.

De forma bem técnica, todo UAV é um drone, mas nem todo drone é um UAV. Atualmente, podemos usar ambos os termos de forma intercambiável, sendo que o termo “drone” é muito mais popular devido ao seu emprego na mídia, em filmes, na TV, etc.; já o termo UAV é mais empregado pelas Forças Armadas.

UAV SkyGuardian

Porém, especialistas na indústria postulam que os UAVs precisam especificamente possuir capacidade de voo autônomo, mas os drones não.

Um outro termo muito comum associado a estas tecnologias é o acrônimo UAS – Unmanned Aircraft Systems (Sistemas de Aeronave Não-Tripuladas), que se refere ao conjunto formado pelo UAV ou drone mais a pessoa que controla o voo e o sistema que conecta ambos. Assim, temos que o UAV é uma parte de um UAS.

Drone comum

Os UAVs foram desenvolvidos a princípio para aplicações militares e atualmente são amplamente empregados em tarefas de reconhecimento, vigilância ou ataque. Já os drones encontram múltiplas aplicações no mundo civil, como fotografia aérea, entrega de mercadorias, vigilância, entretenimento, e muitas outras.

Pequeno histórico dos UAVs

1792 – A forma mais antiga de UAVs existiu na forma de balões. Os irmãos Montgolfier, na França, foram os primeiros a realizarem experimentos com balões e a enviar aerostatos não tripulados em preparação para voos tripulados. Durante a Guerra Civil Americana (1861 – 1865), o exército da União lançou balões não-tripulados contendo dispositivos incendiários para causar incêndios nas linhas de batalha dos Confederados.

1918 – A empresa Dayton-Wright Airplane Co. constrói o Torpedo Aéreo Kettering, contando com Orville Wright (dos irmãos Wright) como consultor, além de Elmer Ambrose Sperry como designer dos sistemas de controle e orientação. Uma vez lançado, um pequeno giroscópio a bordo guia a aeronave até seu destino usando um sistema vácuo/pneumático, um sistema elétrico e um altímetro/barômetro aneroide.

1942 – Uma aeronave Interstate BQ-4/TDR, carregando uma câmera a bordo é guiada com sucesso até um navio alvo a partir de uma aeronave de controla, a 50 km de distância.

Interstate BQ-4/TDR

1951 – O UAV Ryan Firebee é projetado para ser um alvo de artilharia movido a jato. Ele evolui para um sistema de vigilância não-tripulado nos anos 1960, sendo rebatizado como AQM-34, e realizando mais de 34.000 missões ISR sobre o sudeste asiático durante a guerra do Vietnã.

1983 – O BQM1BR foi o primeiro UAV fabricado no Brasil, pela CBT (Companhia Brasileira de Tratores), sendo um dispositivo de propulsão a jato, para emprego como alvo aéreo.

1989 – Abraham Karem, na General Atomics apresenta o UAV Gnat 750. Equipado com câmeras de vídeo, ele realiza missões de reconhecimento aéreo sobre a Bósnia, sendo controlado do solo por pessoal na Albânia. Este UAV é precursor do famoso RQ-1/MQ-1 Predator, e suas variantes.

General Atomic GNAT 750

1998 – O Northrop Grumman RQ-4 Global Hawk, inicialmente projetado pela empresa Ryan Aeronautical, fornece uma ampla visão geral  – de grande altitude – e vigilância persistente usando um radar de abertura sintética de alta resolução (SAR) e sensores infravermelhos / eletro-ópticos de longo alcance.

2012 – A Lei de Reforma e Modernização da FAA de 2012 define o prazo de 30 de setembro de 2015 para que a agência estabeleça regulações permitindo o uso de UAVs comerciais no espaço aéreo dos Estados Unidos.

2014 – A BP (British Petroleum) obtém a primeira aprovação Federal para voar veículos aéreos não-tripulados sobre o território dos Estados Unidos, com propósitos comerciais. A fabricante de UAVs AeroVironment usa sua aeronave para inspecionar dutos da BP, estradas e equipamentos próximo à Baía de Prudhoe, no Alasca.

Referências

Stem Works – Microwave Journal – Outubro de 2014.

O post O que é um UAV – Unmanned Aerial Vehicle apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Olá pessoal! Vamos criar mais um projetinho usando Arduino? Vamos construir um pequeno alarme de distância!

Neste projeto vamos empregar o sensor ultrassônico de distância HC-SR04 para criar um alarme sonoro e visual, que será acionado quando um objeto for detectado a uma determinada distância do sensor, que pode ser ajustada via código.

O alarme consistirá na emissão de um tom sonoro de frequência específica por meio de um buzzer, além de um sinal luminoso utilizando-se um LED colorido. É possível usar um pequeno alto-falante no lugar do buzzer, porém nesse caso o volume sonoro gerado deve ser menor.

Lista de Materiais:

• Arduino
• Sensor ultrassônico HC-SR04
• LED de qualquer cor
• Resistor de 220Ω
• Buzzer (ou alto-falante pequeno)
• Matriz de Contatos
• Jumpers diversos

Circuito

O diagrama esquemático a seguir detalha o circuito que devemos construir:

Diagrama Esquemático criado com Fritzing

Conectamos o pino de Trigger do sensor ao pino digital 8 do arduino, o pino de eco ao pino digital 7, e vamos acionar o buzzer e o LED por meio dos pinos digitais 4 e 3, respectivamente. Note que acrescentamos um resistor de 220Ω para limitação de corrente no LED, de modo a evitar que se danifique quando se acender.

Código-fonte

A seguir temos o código do Arduino para a aplicação do sensor de distância, comentado:

/* Acionando alarme com Sensor Ultrassônico HC-SR04
Por Fábio dos Reis
www.bosontreinamentos.com.br */

// Definir os números dos pinos
const int trigger = 8;
const int eco = 7;
const int buzzer = 4;
const int led = 3;

// Definir as variáveis
long duracao;
float dist;

void setup() {
 pinMode(trigger, OUTPUT); // Configura o pino trigger como saída
 pinMode(eco, INPUT); // Configura o pino eco como entrada.
 pinMode(buzzer, OUTPUT); // Configura o pino de acionamento do buzzer
 pinMode(led, OUTPUT); // Configura o pino de acionamento do LED
 digitalWrite(led, LOW); // Desliga LED ao iniciar a placa.
 digitalWrite(buzzer, LOW); // Desliga buzzer ao iniciar a placa.
}

void loop() {
 // Limpa o trigger
 digitalWrite(trigger, LOW);
 delayMicroseconds(5);

 // Configurar o trigger para nível alto para transmissão de sinais
 digitalWrite(trigger, HIGH);
 delayMicroseconds(10); // tempo para envio do sinal
 digitalWrite(trigger, LOW);

 // Inicia contagem de tempo e lê o pino de eco
 duracao = pulseIn(eco, HIGH);

 // Calcular a distância
 dist = duracao * 0.034 / 2;

 // Acionar buzzer e LED se objeto detectado estiver a menos de 10cm do sensor:
 if (dist <= 10) {
   tone(buzzer, 700);
   digitalWrite(led, HIGH);
 }
 else {
   noTone(buzzer);
   digitalWrite(led, LOW);
 }
 // Aguardar 100ms antes da próxima leitura para evitar interferência
 delay(100);
}

A explicação detalhada de como funciona o sensor ultrassônico HC-SR04 pode ser consultada aqui.

Para acionar o buzzer usamos a função tone(), que gera um tom de frequência determinada a ser enviado a um dos pinos do Arduino. E, para parar a execução do som, samos a função noTone().

Como testar o circuito

Testar o circuito é bem simples: basta aproximar um objeto do sensor de ultrassom, e observar que o buzzer é acionado, juntamente com o LED, quando o objeto chegar a 10cm ou menos de distância, e o “alarme” pára quando o obstáculo se afasta além dos 10 centímetros.

Você pode fazer modificações diversas no circuito, como por exemplo alterar a distância de disparo do alarme, ou ainda tentar modificar o circuito para que o buzzer reproduza sons de diferentes frequências dependendo da distância do obstáculo ao sensor.

O post Acionando um alarme com buzzer e LED usando sensor HC-SR04 e Arduino apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Projeto: Criando um Servidor Web com Arduino e Ethernet Shield

Vamos colocar em prática a teoria mostrada na lição anterior sobre o shield ethernet no Arduino, criando um projeto simples com um Arduino Uno (outras placas também funcionam) e um Shield Ethernet: um Servidor Web, sistema que aceita solicitações de clientes e permite enviar dados como resposta. Por exemplo, podemos ter um sensor medindo a temperatura do ambiente, e consultar os valores medidos pela Internet ou rede local, usando um navegador que acessa o  Servidor Web configurado.

Neste tutorial vamos mostrar como usar um shield Ethernet e a classe EthernetServer para configurar um servidor de rede (web) com Arduino.

Lista de materiais

Vamos precisar de :

• 1 Shield Ethernet
• Arduino (Uno, Mega, etc)
• Cabo de Rede
• Roteador da sua rede local
• PC com navegador para testes

A seguir podemos ver o Shield Ethernet conectado a um Arduino Uno:

A Classe EthernetServer

A função desta classe é criar um objeto servidor que irá escutar (aguardar solicitações) requisições de conexão de clientes em uma porta específica, e então servir a esses clientes um serviço quando essa conexão é efetuada.

O primeiro passo para configurar um servidor web com Arduino e shield Ethernet é criar um objeto servidor, usando a sintaxe a seguir:

EthernetServer servidor = EthernetServer(porta);

Onde porta é o número da porta de comunicações na qual o servidor escutará. O padrão é a porta 80 para o serviço web.

Devemos inicializar a biblioteca Ethernet passando como parâmetro, no mínimo, o MAC address do shield Ethernet, como segue:

Ethernet.begin(mac);

Também é possível passar outros parâmetros de rede, com o ip, máscara de subrede e gateway padrão, caso utilizamos IP fixo, por exemplo:

Ethernet.begin(mac, ip, gateway, subrede);

O servidor será inicializado quando necessário invocando-se o método begin:

servidor.begin();

Classe EthernetCLient

Para começar a ouvir, é necessário também criar um objeto cliente, o qual irá representar o cliente real com o qual o servidor irá se comunicar. Para isso, usamos a classe EthernetClient, como segue:

EthernetClient cliente = servidor.available();

Esse objeto cliente retorna o valor falso (0) se não houver nenhum cliente disponível no momento.

Para fechar a conexão com um cliente, após a transmissão dos dados requisitados, por exemplo, usamos o método stop():

cliente.stop();

Consulte a descrição completa das funções de cliente e servidor no Arduino para saber mais sobre como usar essas classes.

Enviar e receber dados de um cliente

Usamos as funções print(), println() e write() para enviar dados a um cliente. Para receber (ler) dados do cliente, usamos o método read().

Código de exemplo (simplificados)

EthernetServer servidor = EthernetServer(80);
void setup() {
  Ethernet.begin(mac, ip, gateway, subrede);
  servidor.begin();
}
void loop() {
  EthernetClient cliente = servidor.available();
  if (cliente) {
    Serial.print(cliente.read());  // Ler dados do cliente e enviar para o monitor serial
  }
}

No exemplo, criamos um objeto EthernetServer de nome servidor, inicializando-o com o número da porta que será utilizada, no caso a porta 80 (padrão HTTP).

Na função de setup() inicializamos a biblioteca Ethernet, passando os dados de endereço mac, ip, gateway e máscara de subrede.

Na função loop() criamos o objeto EthernetClient, de nome cliente, que recebe o retorno do método servidor.available(), o qual verifica se o servidor está disponível. Caso esteja, será impressa no monitor serial um dado lido proveniente do cliente de rede.

O método available() retorna o valor 0 (zero) caso não haja um cliente disponível. Caso haja, o objeto cliente o representará.

Vejamos o código completo para a criação de um servidor web simples, que inclui a geração de um cabeçalho HTTP de resposta e o envio de uma página HTML ao cliente (navegador em um computador ou outro dispositivo)

Código para o servidor Web

Abaixo temos o código completo do sketch de nosso servidor web com Arduino:

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
EthernetServer servidor(80);

void setup() {
 Serial.begin(9600);
//Desativando o SD Card:
 pinMode(4, OUTPUT);
 digitalWrite(4, HIGH);
 
 Ethernet.begin(mac);
 servidor.begin();
 
 Serial.print("IP do servidor: ");
 Serial.println(Ethernet.localIP());
 Serial.print("Gateway: ");
 Serial.println(Ethernet.gatewayIP());
}

void loop() {
 EthernetClient cliente = servidor.available();
 if (cliente) {
   boolean linha_atual_branca = true;
   while (cliente.connected()) {
     if (cliente.available()) {
       char c = cliente.read();
       Serial.write(c);
 
       if (c == '\n' && linha_atual_branca) {
         // Criando o cabeçalho HTTP:
         cliente.println("HTTP/1.1 200 OK");
         cliente.println("Content-Type: text/html");
         cliente.println("Connection: close");
         cliente.println("Refresh: 5");
         cliente.println();
         // Código da página Web a ser exibida:
         cliente.println("<!DOCTYPE html>");
         cliente.println("<html lang='pt-br'>");
         cliente.println("<head>");
         cliente.println("<meta charset='UTF-8'>");
         cliente.println("<title>Servidor Web com Arduino</title>");
         cliente.println("</head>");
         cliente.println("<body>");
         cliente.println("<hr>");
         cliente.println("<p>Bem-vindo à Bóson Treinamentos em Tecnologia!</p>");
         cliente.println("<hr>");
         cliente.println("</body>");
         cliente.println("</html>");
         break;
       }
     if (c == '\n') {
       // Iniciando uma nova linha
       linha_atual_branca = true;
     }
     else if (c != '\r') {
       // Há um caractere na linha atual
       linha_atual_branca = false;
     }
   }
 }
 // Tempo para o navegador receber os dados
 delay(1);
 // Fechar a conexão:
 cliente.stop();
 }
}    

Após carregar o sketch no Arduino, abrimos o monitor serial para verificar se um endereço IP foi atribuído corretamente ao shield ethernet:

Veja que foi atribuído o IP 192.168.1.109 ao shield ethernet. Vamos agora abrir um navegador no computador e acessar o endereço do nosso servidor web:

Note que também é possível usar um endereço IP fixo no servidor web, bastando para isso acrescentar a seguinte linha ao nosso código (logo após a declaração do endereço MAC), fornecendo o IP desejado, com seus números separados por vírgulas, como no exemplo:

IPAddress ip(192, 168, 1, 10);

E então alterar a instrução:

Ethernet.begin(mac);

para

Ethernet.begin (mac, ip);

Desta forma, será usado o IP fornecido no código, em vez de um endereço IP obtido a partir de um servidor DHCP na rede – o qual pode mudar de tempos em tempos, dificultando a tarefa de acessar o Arduino pela rede.

No próximo tutorial vamos mostrar como é possível enviar comandos a um Arduino a partir de um navegador, por meio da configuração do servidor Web.

O post A classe EthernetServer – Configurando um servidor web com Arduino apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste tutorial vamos mostrar como funciona o sensor ultrassônico de distância HC-SR04 e como usá-lo para detectar a distância de objetos com um Arduino.

Sensor Ultrassônico

Um sensor de ultrassom funciona emitindo um pulso sonoro em uma frequência acima da faixa audível pelo ser humano (aproximadamente 20.000 Hz), o qual viaja pelo ar até atingir um obstáculo, sendo então refletido de volta e detectado pelo sensor.

Desta forma, conhecendo-se a velocidade de propagação do som no ar e medindo o tempo entre a transmissão e a recepção do pulso sonoro, é possível calcular a que distância se encontra o objeto que refletiu o som.

O sensor considerado (HC-SR04) é um módulo de baixo custo que opera na faixa dos 40 kHz (40.000 Hz), e possui um alcance de detecção de cerca de 2cm até 4m de distância, de acordo com seu datasheet.

Sensor de distância por ultrassom HC-SR04

Esse módulo sensor possui quatro pinos:

• VCC – Alimentação do sensor (5V)
• GND – Comum (Ground)
• Trig – Trigger (disparo), pino usado para transmitir um pulso de ultrassom
• Echo – Eco, pino que recebe e detecta o pulso de ultrassom refletido por um obstáculo

Características do HC-SR04

As principais características do sensor HC-SR04 são as seguintes, de acordo com seu datasheet: 

Funcionamento do HC-SR04

O sensor ultrassônico consiste em dois componentes distintos – um circuito que gera e emite o sinal e outro que detecta o sinal refletido de volta. Além disso, o HC-SR04 possui um pequeno microcontrolador responsável por determinar o intervalo de tempo entre o envio e o recebimento do sinal sonoro. Esse intervalo de tempo corresponde a um valor de tensão elétrica: quanto maior o tempo, maior a tensão.

Para gerar o ultrassom o pino Trig deve ser colocado em nível alto por um intervalo de tempo de alguns microssegundos, o que permitirá enviar uma sequência de pulsos sonoros, viajando na velocidade do som e que serão detectados eventualmente pelo pino Echo. O pino Echo retorna a duração de tempo em microssegundos (μs) dos pulsos recebidos.

Por exemplo, suponha que um obstáculo esteja localizado a 20cm de distância do sensor. A velocidade do som no ar é de 340 m/s, ou 0,034 cm/μs, ou ainda aproximadamente 29,4 μs por centímetro percorrido. Assim, as ondas sonoras terão de viajar por cerca de 588 μs entre o sensor e o obstáculo, de acordo com a fórmula:

t = s/v

Onde t é o tempo, s é o espaço percorrido pela onda de ultrassom e v é sua velocidade de propagação no ar.

Ou seja:

T = 20cm / 0,034cm/μs = 588,23 μs

Na prática, o tempo total de viagem do pulso, medido ida e volta, será o dobro desse valor. Em nosso exemplo, o tempo total decorrido entre a transmissão do pulso de ultrassom e seu recebimento será de:

588,23 μs x 2 = 1176,46 μs

Assim, para obter a distância real até o objeto, devemos dividir o valor medido por 2. Desta maneira, a fórmula para determinação da distância até o objeto será:

s = t x 0,034 / 2

Ou ainda:

s = microssegundos / 29,4 / 2

Aplicando as fórmulas em nosso exemplo:

s = 1176,46 x 0,034 / 2 = 20 cm

ou

s = 1176,46 / 29,4 / 2 = 20 cm

Podemos usar qualquer uma dessas fórmulas em nosso programa.

Funcionamento do sensor de distância HC-SR04

Resumindo o funcionamento:

1. Configuramos em nível baixo (LOW) os pinos Trig e Echo quando o módulo é inicializado
2. Transmitimos um pulso em nível alto (HIGH) por pelo menos 10 μs ao pino Trig, que equivale a oito ondas quadradas de 40 kHz.
3. Esperamos a captura da saída da borda de subida pelo pino Echo (valor HIGH). Simultaneamente, iniciar um timer para começar a contar o tempo (função pulseIn no Arduino).
4. Capturar a borda de descida no pino Echo, e ao mesmo tempo, ler o contador, que indica o tempo de deslocamento do sinal ultrassônico.
5. Finalmente, aplicando a fórmula ao valor lido, calculamos a distância até o obstáculo, e então tomamos uma decisão sobre o que fazer (acender um LED, emitir um alarme sonoro, etc).

A seguir podemos visualizar o diagrama de temporização do sensor (retirado de seu datasheet):

Diagrama de Temporização do sensor HC-SR04 (Fonte: Datasheet da ElecFreaks)

Aplicações de sensores ultrassônicos

Os sensores de ultrassom são empregados em uma variedade de aplicações, em diversas áreas, como:

• Medição de distância (nosso objetivo aqui)
• Medição de profundidade ou espessura
• Visualização de imagens
• Polimento e limpeza
• Solda ultrassônica

entre outras. Neste artigo empregaremos um sensor de ultrassom de baixo custo para detectar e medir a distância de um objeto (obstáculo).

Montando o circuito

Para este projeto precisaremos dos seguintes componentes:

• Sensor HC-SR04
• Arduino
• Fios e matriz de contatos

A figura a seguir mostra a conexão dos componentes usando a breadboard. Basicamente, ligamos o pino 8 do Arduino ao pino Trig do sensor, o pino 7 ao pino Echo, e conectamos VCC e GND aos pinos correspondentes no microcontrolador:

 Código do sketch

A seguir temos o código do Arduino para a aplicação do sensor de distância, comentado:

/*
Sensor Ultrassônico HC-SR04
Fábio dos Reis
www.bosontreinamentos.com.br */

// Definir os números dos pinos
const int trigger = 8;
const int eco = 7;

// Definir as variáveis
long duracao;
float dist;

void setup() {
 pinMode(trigger, OUTPUT); // Configura o pino trigger como saída
 pinMode(eco, INPUT); // Configura o pino eco como entrada.
 Serial.begin(9600); // Inicia a comunicação serial
}

void loop() {
 // Limpa o trigger
 digitalWrite(trigger, LOW);
 delayMicroseconds(5);

 // Configurar o trigger para nível alto para transmissão de sinais
 digitalWrite(trigger, HIGH);
 delayMicroseconds(10); // tempo para envio do sinal
 digitalWrite(trigger, LOW);

 // Inicia contagem de tempo e lê o pino de eco
 duracao = pulseIn(eco, HIGH);

 // Calcular a distância
 dist = duracao * 0.034 / 2;

 // Mostrar a distância no monitor serial
 if (dist >= 400 || dist <= 2) {
   Serial.println("Valor fora do alcance");
 }
 else {
   Serial.print("Distancia em cm: ");
   Serial.println(dist);
 }

 // Aguardar 100ms antes da próxima leitura para evitar interferência
 delay(100);
}

Explicando o código:

• Primeiramente definimos os pinos de trigger e eco, que serão respectivamente os pinos 8 e 7.
• Criamos então duas variáveis: duracao, para armazenar a duração do pulso lido pelo sensor, e dist, onde será armazenado o valor da distância calculada até o objeto.
• Na função setup() configuramos os modos de operação dos pinos, sendo modo de saída para o pino trigger e entrada para o pino de eco. Inicializamos também o monitor serial.
• Na função principal, loop(), começamos limpando o trigger ao colocá-lo em nível baixo por cerca de 5 us (suficiente).
• Em seguida, colocamos o trigger em nível alto por 10 us (função delayMicroseconds), para que seja gerado o sinal ultrassônico e enviado, e então colocamos o pino de volta ao nível LOW.
• Os pulsos de ultrassom são enviados, batem em um obstáculo e são refletidos de volta (eco). Devemos agora ler o valor detectado no pino de eco, usando para isso a função do Arduino pulseIn (veja quadro abaixo a respeito dessa função).
• Calculamos a distância usando a fórmula dist = duracao * 0,034 / 2
• E finalmente mostramos a distância calculada no monitor serial (ou realizamos outra tarefa). Caso a distância do objeto seja maior ou igual a 4m (400cm) ou menor ou igual a 2cm (limites de detecção do sensor), será exibida a mensagem “Valor fora do alcance”.
• Aguardamos 100 ms antes do próximo ciclo de detecção (varie à vontade esse valor, para obter mais ou menos leituras por segundo; idealmente, não use um valor abaixo de 60 ms para que não haja interferência entre os sinais enviados e recebidos pelo sensor).

pulseIn(pino, valor)

pulseIn(pino, valor, timeout)

int pino = 10;
unsigned long duracao;
void setup()
{
  pinMode(pino, INPUT);
  Serial.begin(9600);
}
void loop()
{
  duracao = pulseIn(pino, HIGH);
  Serial.println(duracao);
}

É isso aí! Nos próximos projetos vamos explorar mais o sensor de distância HC-SR04. Até! 

O post Usando um Sensor Ultrassônico de Distância HC-SR04 com Arduino apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Uma das formas mais importantes de comunicação disponíveis com o Arduino é o padrão Ethernet. Trata-se de um protocolo de comunicação em redes que permite que dispositivos variados, como PCs, smartphones, roteadores, arduinos, etc., se comuniquem por meio do envio e recebimento de pacotes (frames / quadros, para ser mais exato), que são fluxos de dados organizados.

Cada dispositivo em uma rede possui seu próprio endereço IP, que é um endereço numérico que permite identificar cada dispositivo e dessa forma, se comunicarem entre si usando diferentes protocolos (padrões de software).

Shield Ethernet

No Arduino é bastante simples realizar essa comunicação via padrão Ethernet, com o uso de um Shield Ethernet e sua biblioteca correspondente. A imagem a seguir mostra um shield ethernet típico:

O Shield Ethernet na plataforma Arduino utiliza o chip WIZnet W5100 Ethernet, que fornece a pilha de rede TCP/IP, habilitando o dispositivo a se comunicar através de uma rede comum, tanto local quanto via Internet.

Esse shield possui um conector para cabo de rede RJ45, e sua taxa de transferência máxima é de 100 Mbps, podendo operar também em 10 Mbps (10/100).

Além disso, ele traz um slot para cartão microSD, que permite ler e armazenar dados no próprio shield (obviamente inserindo um cartão SD e executando a biblioteca SD).

Um shield ethernet realiza, basicamente, o papel que uma placa de rede executa em um computador comum. Antes de mostrarmos como funciona e como configurar esse shield, vamos discutir alguns termos relacionados a redes de computadores, que serão importantes no entendimento do processo de comunicação do Arduino.

Conceitos básicos de Redes

• Ethernet: Tecnologia de rede que permite a dispositivos enviarem dados entre si por meio de uma rede com fios, por meio de um endereço físico (identificação de hardware).
• Endereço MAC: Media Access Control / Controle de Acesso ao Meio, trata-se de um identificador (endereço) único que é atribuído aos dispositivos de rede, de modo que cada dispositivo seja identificado de forma única e possam assim se comunicar com outros dispositivos. Cada shield Ethernet para Arduino possui seu próprio endereço MAC, que nunca se repete.
• Protocolo de Rede: Um protocolo é uma linguagem de comunicação padronizada que permite que dispositivos troquem informações entre si (“conversem”). Para que essa comunicação seja possível, os dispositivos devem usar o mesmo protocolo, como se fosse a mesma “linguagem”. Um protocolo muito comum é o protocolo HTTP, que permite configurar um servidor Web (que podemos fazer com Arduino!).
• TCP/IP: Trata-se de uma pilha ou suíte de protocolos específica, ou seja, um grupo de protocolos que trabalham em conjunto para fornecer conectividade de rede a dispositivos. TCP significa “Protocolo de Controle de Transmissão”, e IP significa “Protocolo de Internet”, e esses dois são os protocolos mais importantes da pilha, que na verdade contém mais de 50 protocolos diferentes, cada um com uma função bem definida.
• Endereço IP: O IP é um endereço lógico, ou seja, não associado fisicamente a um dispositivo, mas que permite que os dispositivos de identifiquem em uma rede como a Internet.
• Gateway: Um gateway, também chamado de Gateway Padrão, é basicamente o endereço IP da porta de um roteador conectada à rede interna, a qual permite o roteamento (encaminhamento) dos pacotes para uma outra rede, geralmente a Internet.

Shield Ethernet encaixado no Arduino

A Biblioteca Ethernet

A biblioteca Ethernet, necessária para que seja possível utilizar o shield correspondente, é distribuída juntamente com o IDE do Arduino e permite a comunicação do Arduino com uma rede.

A tabela a seguir fornece uma descrição simplificada de algumas das funções mais comuns da biblioteca Ethernet, pertencentes às classes Ethernet, EthernetClient, EthernetServer e EthernetUDP:

Ethernet.begin(mac)
Ethernet.begin(mac, ip)
Ethernet.begin(mac, ip, gateway)
Ethernet.begin(mac, ip, gateway,subnet)

Server(port)

Server.begin()

Server.write()

Server.available()

Server.print()

Server.println()

Client(ip. porta)

Client.connect()

Client.connected()

Client.write()

Client.print()

Client.println()

Client.available()

Client.read()

Client.flush()

Client.stop()

EthernetUDP.begin(port)

EthernetUDP.read(packetBuffer,
MaxSize)

EthernetUDP.write(mensagem)

EthernetUDP.beginPacket(ip. port)

EthernetUDP.endPacket()

EthernetUDP.parsePacket()

Ethernet.available()

Nas próximas partes desse tutorial, vamos mostrar como utilizar o shield Ethernet e as bibliotecas listadas acima para criar diversas aplicações de rede com o Arduino, como por exemplo um servidor Web e um cliente de rede local.

Próximo: Projeto – Criando um Servidor Web com Arduino e um Shield Ethernet

O post Como usar um Shield Ethernet no Arduino apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Anteriormente mostramos como tocar notas musicais específicas usando o Arduino, inclusive com a reprodução de uma escala musical pré-determinada. Neste novo projeto, vamos aplicar essas técnicas para reproduzir uma melodia bastante conhecida, a Ode à Alegria, parte da Nona Sinfonia de Beethoven. É uma melodia simples, portanto indicada para esta tarefa. Posteriormente iremos alterar nosso código para tocar músicas mais complexas e mais longas.

A figura abaixo mostra a partitura da melodia que iremos reproduzir:

Circuito

A figura a seguir mostra o circuito a ser utilizado, que é o mesmo que empregamos no projeto anterior, “tocando uma escala musical com Arduino“:

Precisaremos apenas de um Arduino (qualquer versão), um alto-falante ou buzzer, e um resistor de 150Ω, além de fios conectores e uma matriz de contatos pequena.

Código

Neste programa precisamos incluir o arquivo de cabeçalho pitches.h, o qual já utilizamos em um projeto anterior, e que contém o mapeamento das frequências das notas musicais para um nome de constante. Porém, aqui, eu modifiquei o conteúdo do arquivo, eliminando a palavra “NOTE” que aparece em cada nome de nota, e deixando apenas o padrão _XY, com X sendo o nome da nota em notação musical, e Y o número da oitava. Assim por exemplo, a nota NOTE_C4 será representada apenas por _C4. Fiz isso para simplificar  e diminuir o tamanho do código, pois ele terá muitas dezenas de notas, e pode ficar confuso.

Vamos ao código da aplicação:

#include "pitches.h"
int falante = 8;
float bpm = 80;
int T;
int minima, seminima, seminimaAumentada, colcheia;
int nota[] = {
 _B4, _B4, _C5, _D5, _D5, _C5, _B4, _A4, _G4, _G4, _A4, _B4, _B4, _A4, _A4,
 _B4, _B4, _C5, _D5, _D5, _C5, _B4, _A4, _G4, _G4, _A4, _B4, _A4, _G4, _G4,
 _A4, _A4, _B4, _G4, _A4, _B4, _C5, _B4, _G4, _A4, _B4, _C5, _B4, _A4, _G4, _A4, _D4,
 _B4, _B4, _C5, _D5, _D5, _C5, _B4, _A4, _G4, _G4, _A4, _B4, _A4, _G4, _G4
};

/* Tempos: 
1 = colcheia
2 = seminima
3 = seminima + colcheia
4 = minima
*/

int tempo[] ={
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1, 4,
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1, 4,
 2, 2, 2, 2, 2, 1, 1, 2, 2, 2, 1, 1, 2, 2, 2, 2, 2,
 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1, 4
};

void setup() {
 minima = round((1 / (bpm / 60)) * 1000 * 2);
 seminima = round((1 / (bpm / 60)) * 1000);
 seminimaAumentada = round((1 / (bpm / 60)) * 1500);
 colcheia = round((1 / (bpm / 60)) * 500);
 // Serial.begin(9600); // para debug
}
void loop() {
 // Tocar cada nota durante o tempo especificado:
 for (int i = 0; i < 62; i++) {
   switch (tempo[i]) {
   case 1:
     T = colcheia;
     break;
   case 2:
     T = seminima;
     break;
   case 3:
     T = seminimaAumentada;
     break;
   case 4:
     T = minima; 
     break;
 }
 /* Visualizando os tempos (para debug):
 Serial.println(minima);
 Serial.println(seminima);
 Serial.println(seminimaAumentada);
 Serial.println(colcheia);
 */
 tone(falante, nota[i], T);
 delay(T);
 }
}

Explicando o código

Neste código usaremos as seguintes variáveis:

• falante – Variável para armazenar o número do pino onde está conectado o alto-falante ou buzzer. 
• bpm – Nesta variável vamos armazenar um número que indicará o andamento da música (sua “velocidade”). bpm significa “batidas por minuto”.
• T – A variável T receberá o valor do tempo que deve ser aplicado a cada nota durante sua execução (duração da nota).
• minima, seminima, seminimaAumentada, colcheia – Essas variáveis determinam o valor da duração para cada tipo de nota, pois algumas notas possuem duração mais longa do que outras.

Também criaremos dois arrays (vetores) para armazenar as notas e seus respectivos tempos de duração:

• O array nota[] contém as notas da melodia a ser reproduzida, na sequência correta, como fizemos no artigo sobre escalas musicais no Arduino.
• O array tempo[] armazenará um número que será usado para calcular a duração de cada nota tocada, também na sequência correta de reprodução da melodia. Assim, a primeira posição deste array possui a duração da nota na primeira posição no array nota[], e assim sucessivamente.

No array tempo[] utilizamos números para representar as durações das notas tocadas. Em nosso código, o número 1 simboliza uma colcheia, o valor 2 representa uma seminima, o valor 3 uma semínima aumentada ( 1 tempo e 1/2), e o valor 4 representa uma mínima (2 tempos).

Na rotina de setup é calculado o valor de tempo em milissegundos de cada tipo de nota, de acordo com o andamento (variável bpm). A duração de cada nota depende do andamento da música, que é dado pelo valor armazenado em bpm. Assim, valores maiores de bpm farão a música ser executada mais rapidamente, e vice-versa.

Na rotina de loop usamos uma estrutura de decisão Switch / Case para determinar a duração a ser aplicada a cada nota tocada, de acordo com o valor armazenado no array tempo[] e com a duração de cada tipo de nota, calculada na rotina de setup.

E, finalmente, chamamos a função tone() para executar a nota na posição i do array nota[], usando a duração T determinada, e a função delay() na sequência faz o Arduino aguardar a nota ser executada antes de reproduzir a próxima nota da música.

Após carregar o código, basta esperar alguns instantes e a melodia da Ode à Alegria (Ode to Joy) de Beethoven será reproduzida no alto-falante.

É isso aí!

Até a próxima!

O post Tocando uma melodia com o Arduino: Ode à Alegria, de Beethoven apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Em um projeto anterior mostramos como tocar sons utilizando o Arduino. Agora, vamos mostrar como selecionar as frequências a serem reproduzidas para que sejam tocadas notas musicais com Arduino específicas – assim, poderemos criar sequências melódicas e tocar músicas simples.

Ao reproduzirmos sequências de música dessa forma com o Arduino, é interessante o uso de um arquivo de definição que mapeie as diversas frequências sonoras para os nomes das notas musicais. Assim, é muito mais fácil escrever as melodias a serem reproduzidas, e isso também torna o código mais limpo e fácil de manter.

As notas musicais são representadas por letras, que representam o tom (frequência) de cada nota. Assim, para as notas de Dó a Si usamos as seguintes letras como representação:

• C = Dó
• D = Ré
• E = Mi
• F = Fá
• G = Sol
• A = Lá
• B = Si

Também podemos ter algumas notas intermediárias, meio tom acima (“sustenido”, representado por #) ou meio tom abaixo (“bemol”, representado pelo símbolo ♭). Por exemplo, um som de frequência intermediária entre um dó e um ré pode ser representado por C# (dó sustenido) ou ainda por D♭ (ré bemol). Na prática, pode existir uma minúscula diferença entre essas notas, mas para todos os efeitos vamos considerá-las como iguais.

O IDE do Arduino inclui um arquivo de cabeçalho, de nome “pitches.h“,  que efetua o mapeamento das frequências (em Hertz) com as notas musicais correspondentes, de modo que não é necessário criar essa mapeamento – devemos apenas entender como o arquivo é estruturado e como utilizá-lo.

Para incluir o arquivo pitches.h em um projeto devemos copiá-lo para a pasta do sketch, fechar o IDE e abri-lo de novo, e então incluir o seguinte comando no início de seu sketch:

#include "pitches.h"

Você pode baixar o arquivo pitches.h clicando aqui.

Ao copiarmos o arquivo e incluirmos essa linha de comandos em um sketch, será aberto uma nova aba no IDE, ao lado do arquivo principal de código, como podemos ver na ilustração a seguir:

E a seguir temos o conteúdo completo do arquivo pitches.h, que é bastante simples, consistindo na definição de uma constante para cada nota musical, seguida do valor de sua frequência sonora:

/*************************************************
 * Public Constants
 *************************************************/

#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093
#define NOTE_CS7 2217
#define NOTE_D7 2349
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
#define NOTE_CS8 4435
#define NOTE_D8 4699
#define NOTE_DS8 4978

Por exemplo, a nota Lá central, que possui uma frequência de 440 Hz, é definida no arquivo com a linha:

#define NOTE_A4 440

Desta forma, sempre que quisermos reproduzir essa nota específica, podemos usar a constante de nome NOTE_A4 no código. O número que vem logo após o nome da nota (“4”, no caso) se refere à oitava da nota reproduzida – podemos reproduzir sons até a 8ª oitava usando esse arquivo de definições.

Podemos também realizar alterações no arquivo, para incluir notas de frequências mais altas ou ainda trocar os nomes das constantes, se assim o desejarmos.

O Circuito

Para exemplificar a reprodução das notas, vamos usar um circuito bem simples, que consiste em um pequeno alto-falante ou buzzer conectado ao Arduino, como podemos ver no esquemático a seguir:

Este circuito consiste apenas em um Arduino, um alto-falante e um resistor. O resistor, em série com o alto-falante, é muito importante para limitar a corrente que circulará no circuito, pois os pinos do Arduino só podem fornecer no máximo 40 mA, e se uma corrente maior do que isso for exigida, poderá ocasionar danos ao seu microcontrolador.

O valor do resistor pode ser calculado usando-se a Lei de Ohm. Sabemos que R = U / I, sendo que o valor da tensão fornecida pelo Arduino é de 5V, e a corrente máxima, como citado, é de 40mA. Portando, o valor mínimo do resistor deverá ser:

R = 5 / 0,04 = 125Ω

Como o alto-falante possui resistência interna, geralmente de 8Ω, então o resistor em série precisará ter, na verdade, 125Ω – 8Ω = 117Ω. Este valor não existe comercialmente, de modo que teremos de usar o valor mais próximo encontrado no mercado, que é de 150Ω.

Tocando as notas musicais em sequência

Vamos agora criar uma pequena aplicação que permita reproduzir notas selecionadas em sequência. Não vamos prestar atenção ao tempo das notas no momento, pois isso será abordado em nosso próximo tutorial. Usaremos a função tone() para reproduzir as notas desejadas.

Suponha que você queira tocar as seguintes notas no Arduino, nesta ordem:

C D E F G A B C

Ou seja, uma escala de uma oitava de dó a dó. Para executá-la, basta escolher a oitava desejada (altura do som) e então usar os nomes das constantes definidas no arquivo de cabeçalho para reproduzi-las.

Digite o código a seguir em seu programa principal para tocar essa escala sequencialmente:

#include "pitches.h"

int falante = 7;
int tempo = 500;
// Array com as notas na ordem em que devem ser tocadas:
int notas[] = {
 NOTE_C4, NOTE_D4, NOTE_E4, NOTE_F4, 
 NOTE_G4, NOTE_A4, NOTE_B4, NOTE_C5 
};

void setup() {
 // nada a fazer aqui
}
void loop() {
 // Tocar cada nota do array durante o tempo especificado:
 for (int i = 0; i < 8; i++) {
   tone(falante, notas[i], tempo);
   delay(tempo);
 }
}

Neste exemplo, criamos um array para armazenar as notas, de modo que para tocá-las na sequência basta iterar pelo array, executando o tom de cada uma de suas posições com a função tone(). Note que acrescentei uma chamada à função delay() dentro do laço for.

Essa chamada é para que haja tempo da função tone() terminar de tocar a nota passada a ela, pois como esa função pode ser executada em segundo plano, corremos o risco do laço for iterar e chamar a função tone() novamente, tocando outro som antes do som anterior ter finalizado, e assim cumulativamente até que o som tocado não seja mais inteligível.

A função delay() deve executar uma pausa com a mesma duração do som tocado.

Note também que o som gerado é uma onda quadrada, pois o Arduino não é capaz de gerar ondas sinusoidais, do tipo que ouvimos no mundo real. Por isso, o timbre do som irá lembrar aquelas melodias de videogames de 8 bits, dos anos 80.

Para gerar sons mais realistas precisamos de um circuito conversor digital-analógico (DAC), o qual está presente por padrão apenas no Arduino Due. Para outros modelos, será necessário construir o circuito – o que faremos em uma lição futura.

Você pode experimentar alterar as notas tocadas trocando-as ou acrescentando mais notas no array, lembrando sempre de ajustar o laço for de acordo, pois ele deve iterar pelo número de itens presentes no array. Caso queira acrescentar uma pausa (momento de silêncio), basta usar o valor 0 (zero) na posição desejada dentro do array.

É isso aí! No próximo tutorial vamos fazer o Arduino tocar uma música inteira, além de implementar um controle de volume simples em nosso circuito.

Até!

O post Tocando notas musicais com o Arduino apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste projetinho vamos fazer com que o Arduino produza sons em diferentes frequências, de acordo com valores medidos a partir de um sensor de luminosidade (LDR) conectado a uma entrada analógica.

A ideia é que, de acordo com a intensidade da luz que incide sobre o sensor, seja gerado um sinal de uma frequência diferente, a ser reproduzido em um alto-falante pequeno ou buzzer, como uma espécie de Theremin, porém acionado por luz.

Lista de Componentes:

• 1 Arduino Uno
• 1 resistor 4,7 kΩ
• 1 resistor 150 Ω
• 1 alto-falante ou buzzer
• 1 LDR (Light-Dependent Resistor)
• fios diversos
• matriz de contatos

Circuito esquemático:

Na figura a seguir podemos ver o esquemático do circuito que construiremos:

Circuito na matriz de contatos:

O circuito montado em uma matriz de contatos pode ser visto na ilustração a seguir:

Código:

Usaremos a função tone() do Arduino para gerar o sinal sonoro a ser reproduzido. Essa função recebe três parâmetros: pino de saída, frequência do tom e tempo de reprodução. Para saber mais sobre a função tone() leia nosso artigo sobre funções tone() e notone() no Arduino.

Vamos ao código utilizado na programação do Arduino:

int leitura;
float tom;
int altoFalante = 8;
int tempo = 10;
void setup() {
 // Serial.begin(9600);
}
 
void loop() {
 // efetuar leitura do sensor:
 leitura = analogRead(A0);
 /*Serial.println(leitura);
 delay(60);*/
 // mapear o resultado da leitura do sensor para faixa de tons desejada:
 tom = map(leitura, 70, 1000, 30, 2500);
 // alterar o tom, tocando por 10 ms:
 tone(altoFalante, tom, tempo);
}

Usamos a função map() para mapear os valores lidos na entrada analógica para valores de frequência que serão reproduzidos pela função tone(). No caso, os valores lidos se encontram na faixa de 70 a 1000 aproximadamente (usamos as funções Serial para descobrir esses valores), e são dependentes dos resistores utilizados no divisor de tensão conectado à entrada A0. E mapeamos esses valores para a faixa de 30 a 2500 Hz, que correspondem aos sons que serão reproduzidos. Você pode experimentar com outros valores de frequências, até o limite da audição humana (20 Hz a 20.000 Hz)!.

Para testar, carregue o código no microcontrolador e aproxime / afaste sua mão do sensor LDR para variar a luminosidade que incide sobre ele. Você ouvirá o som produzido no alto-falante variado sua frequência de acordo.

É isso aí! Até o próximo projeto!

O post Tocar sons no Arduino baseados em entrada de sensor de luz apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.