Início / Projetos Arduino / Projetos Squids / Básico / Projeto 37 - Selecionando músicas de Natal com push button

---

Projeto 37 - Selecionando músicas de Natal com push button

Angelo Luis Ferreira | 23/04/2018 Acessos: 21.079

Objetivo

Neste projeto vamos apresentar um circuito que irá gerar três melodias de natal, onde será possível selecionar a música que se deseja tocar. Para isso, utilizaremos um sonorizador (buzzer, disco piezo elétrico ou auto falante) e botões (push button) que serão utilizados como seletores. O projeto contará também com um controlador de volume de som (potenciômetro) e um led sinalizador.

No projeto não vamos utilizar o conceito tone() para gerar sons, onde demonstraremos uma forma alternativa para gerar notas musicais com frequência e duração definidas. (Forma alternativa ao conceito tone() apresentado no projeto 35.)

Vamos utilizar também neste exemplo, o conceito de compilação de arquivos tipo header file, que são arquivos com extensão .h. Estes arquivos permitem a reutilização do código em outros projetos, além de possibilitar uma maior organização e otimização da estrutura do programa.

Header file: Em programação de computadores, um arquivo cabeçalho (em inglês: header file) é um arquivo, ou seja, uma biblioteca que contêm uma coletânea de funções reutilizáveis separadas do código fonte principal.

Sonorizadores:  O buzzer e o disco são sonorizadores piezoelétricos. Quando se aplica um sinal elétrico em uma determinada frequência, o dispositivo piezoelétrico produz uma nota musical. As notas variam de acordo com a frequência utilizada. (O ouvido humano pode ouvir sons nas frequências entre 20 e 20.000 Hz).

Aplicação

Para fins didáticos e criação de sons com Arduino.

Componentes necessários

Referência	Componente	Quantidade	Imagem	Observação
Protoboard	Protoboard 830 pontos	1		No mínimo utilizar protoboard com 830 pontos
Jumpers	Kit cabos ligação macho / macho	1
Buzzer	Buzzer ativo 5V 12mm	1		Utilize um buzzer ou um disco piezoelétrico
Led 5mm	LED 5mm	1		1 LED alto brilho ou difuso (qualquer cor) Você poderá utilizar também LEDs de 3 mm na cor que desejar.
Resistor	Resistor	1		1 Resistor 150Ω Se precisar usar outros valores, calcule o resistor apropriado para o led utilizado
Push Button	Push button 6X6X5mm	3
Potenciômetro	Potenciômetro	1		O valor do potenciômetro aumenta quando giramos o eixo do componente na direção do polo negativo para o polo positivo. Obs.: Se não possuir potenciômetro de 1KΩ você poderá utilizar um de outro valor, até 10kΩ.
Arduino UNO R3	Arduino UNO	1		Você poderá utilizar uma placa Arduino UNO original ou similar

Montagem do Circuito

Conecte os componentes no Protoboard como mostra a figura abaixo. Verifique cuidadosamente os cabos de ligação antes de ligar seu Arduino. Lembre-se que o Arduino deve estar totalmente desconectado da força enquanto você monta o circuito. Neste projeto você poderá utilizar um buzzer ou um disco piezoelétrico na montagem do circuito. Se possível, teste com os dois componentes.

Atenção

1. O buzzer tem polaridade. Portando, cuidado para não ligar o buzzer invertido. Se você retirar o adesivo superior do buzzzer poderá ver um sinal de positivo (+). Este sinal mostra onde está o pino positivo do componente que deverá estar conectado ao potenciômetro (neste projeto) ou a uma porta digital do Arduino e o polo negativo ao GND.

2. Lembre-se que o LED também tem polaridade: o terminal maior tem polaridade positiva e o lado do chanfro tem polaridade negativa.

2.1. Portanto, faça a conexão do Arduino no terminal positivo do led (anodo) e o GND no terminal negativo (catodo).

2.2. Para evitar danos ao led é necessário a inclusão de um resistor no circuito. Como o resistor é um limitador da corrente elétrica, ele poderá estar conectado no anodo (terminal maior) ou no catodo (terminal menor) do led, tanto faz.

3. Determinamos o valor do resistor através da tabela prática: Tabela prática de utilização de leds 3mm e 5mm. Entretanto, o mais correto é sempre verificar o datasheet do fabricante do LED para você ter os exatos valores de tensão e corrente do mesmo.

Obs.: Resistores iguais ou superiores a 150 Ω poderão ser utilizados em LEDs de todas as cores para um circuito com tensão igual ou inferior a 5V.

3.1. Valores utilizados para nossos projetos: LEDs difusos ou de alto brilho: Vermelho, Laranja e Amarelo: 150 Ω | Led Verde e Azul: 100 Ω  (No nosso projeto utilizamos um resistor de 150 Ω)

4. Monte os botões (push button) sem os resistores, pois através da programação vamos habilitar o resistor pull-up interno do arduino. Desta forma, quando o botão estiver pressionado, o Arduino retornará "LOW" ou "0". Assista o vídeo Arduino: Botão e Resistor de Pull Up Interno

 4.1. Os resistores pull-up e pull-down garantem um nível lógico estável quando por exemplo uma tecla não está pressionada. Geralmente utiliza-se um resistor de 10KΩ para esse propósito. A seguir é exibida a ligação desses resistores no circuito para leitura de tecla do botão:

Atenção: Observe que neste projeto não utilizaremos o resistor de 10K pois vamos habilitar o resitor pull-up interno do Arduino através da programação - veja o projeto Projeto 02b - Led apaga com push button pressionado (pull-up interno do Arduino).

5. Observe que nesse projeto o potenciômetro foi montado como um reostato, onde utilizamos apenas 2 terminais do componente:

5.1. Veja como deve ser a montagem do potenciômetro para este projeto:

5.2. Desta forma o potenciômetro funciona como um resistor variável e não pode ser controlado pela IDE do Arduino. Girando o eixo no sentido horário (da saída do arduino para a entrada do buzzer) aumentaremos o volume do som, e ao contrário, diminuímos o volume do som. Isto acontece pois girando o eixo do reostato aumentaremos ou diminuímos a tensão no buzzer, variando de 0 a 5V. Para saber mais sobre a diferença entre potenciômetro e reostato leia o tutorial: Potenciômetro ou reostato: qual a diferença?

6. A montagem do nosso projeto foi realizada em um protoboard com linhas de alimentação não contínuas, onde acrescentamos jampers para a ligação. Verifique se o seu protoboard possui linhas de alimentação contínuas ou separadas.

Observação: No exemplo acima, utilizamos um buzzer. Você poderá substituir o buzzer por um disco piezoelétrico para ter um efeito semelhante. O cabo vermelho (positivo) deverá estar conectado ao potenciômetro e o cabo preto (negativo) conectado ao GND (ground).

Código do Projeto (Sketch)

1) Faça o dowload e abra o arquivo projeto37.ino no IDE do Arduino:  DOWNLOAD - projeto37.ino

Ou se preferir, copie e cole o código abaixo no IDE do Arduino:

/*******************************************************************************
*
*    Projeto 37 - Músicas de natal com buzzer e seletor
*       (Based on a project and code by Dipto Pratyaksa)
*                   http://squids.com.br/arduino
*
*******************************************************************************/

#include "notas.h"

const int pinBuzzer = 9;
int compasso = 900;

// Jingle Bells

int melody[] = {
  NOTE_E5, NOTE_E5, NOTE_E5,
  NOTE_E5, NOTE_E5, NOTE_E5,
  NOTE_E5, NOTE_G5, NOTE_C5, NOTE_D5,
  NOTE_E5,
  NOTE_F5, NOTE_F5, NOTE_F5, NOTE_F5,
  NOTE_F5, NOTE_E5, NOTE_E5, NOTE_E5, NOTE_E5,
  NOTE_E5, NOTE_D5, NOTE_D5, NOTE_E5,
  NOTE_D5, NOTE_G5
};

int tempo[] = {
  8, 8, 4,
  8, 8, 4,
  8, 8, 8, 8,
  2,
  8, 8, 8, 8,
  8, 8, 8, 16, 16,
  8, 8, 8, 8,
  4, 4
};

// We wish you a merry Christmas

int wish_melody[] = {
  NOTE_B3, 
  NOTE_F4, NOTE_F4, NOTE_G4, NOTE_F4, NOTE_E4,
  NOTE_D4, NOTE_D4, NOTE_D4,
  NOTE_G4, NOTE_G4, NOTE_A4, NOTE_G4, NOTE_F4,
  NOTE_E4, NOTE_E4, NOTE_E4,
  NOTE_A4, NOTE_A4, NOTE_B4, NOTE_A4, NOTE_G4,
  NOTE_F4, NOTE_D4, NOTE_B3, NOTE_B3,
  NOTE_D4, NOTE_G4, NOTE_E4,
  NOTE_F4
};

int wish_tempo[] = {
  4,
  4, 8, 8, 8, 8,
  4, 4, 4,
  4, 8, 8, 8, 8,
  4, 4, 4,
  4, 8, 8, 8, 8,
  4, 4, 8, 8,
  4, 4, 4,
  2
};

// Santa Claus is coming to town

int santa_melody[] = {
  NOTE_G4,
  NOTE_E4, NOTE_F4, NOTE_G4, NOTE_G4, NOTE_G4,
  NOTE_A4, NOTE_B4, NOTE_C5, NOTE_C5, NOTE_C5,
  NOTE_E4, NOTE_F4, NOTE_G4, NOTE_G4, NOTE_G4,
  NOTE_A4, NOTE_G4, NOTE_F4, NOTE_F4,
  NOTE_E4, NOTE_G4, NOTE_C4, NOTE_E4,
  NOTE_D4, NOTE_F4, NOTE_B3,
  NOTE_C4
};

int santa_tempo[] = {
  8,
  8, 8, 4, 4, 4,
  8, 8, 4, 4, 4,
  8, 8, 4, 4, 4,
  8, 8, 4, 2,
  4, 4, 4, 4,
  4, 2, 4,
  1
};

int bot_1 = 0;
int bot_2 = 0;
int bot_3 = 0;

int som = 0;

void setup(void) {
  pinMode(pinBuzzer, OUTPUT); // Buzzer
  pinMode(13, OUTPUT); // Led indicador quando toca a nota
  pinMode(2, INPUT_PULLUP); // push buttom 1
  pinMode(3, INPUT_PULLUP); // push buttom 2
  pinMode(4, INPUT_PULLUP); // push buttom 3

  Serial.begin(9600);
}

void loop() {
  bot_1 = digitalRead(2);
  bot_2 = digitalRead(3);
  bot_3 = digitalRead(4);
  if (bot_1 == 0) {
    sing(1);
  } else if (bot_2 == 0) {
    sing(2);
  } else if (bot_3 == 0) {
    sing(3);
  }
}

void sing(int s) {
  // intera as notas da melodia:
  som = s;
  if (som == 3) {
    Serial.println(" 'We wish you a Merry Christmas'");
    int size = sizeof(wish_melody) / sizeof(int);
    for (int estaNota = 0; estaNota < size; estaNota++) {
    
      // Tomamos 1 segundo divido pelo tipo da nota para calcular a duração
      //ex.  semínima = compasso / 4
      int notaTempo = compasso / wish_tempo[estaNota];

      buzz(pinBuzzer, wish_melody[estaNota], notaTempo);

      // para distinguir melhor as notas, defimos um tempo mínimo entre ela
      int pausaNotas = notaTempo * 1.30;
      delay(pausaNotas);

      // interrompe a melodia:
     buzz(pinBuzzer, 0, notaTempo);
    }

  } else if (som == 2) {
    Serial.println(" 'Santa Claus is coming to town'");
    int size = sizeof(santa_melody) / sizeof(int);
    for (int estaNota = 0; estaNota < size; estaNota++) {
       
      // Tomamos 1 segundo divido pelo tipo da nota para calcular a duração
      //ex.  semínima = compasso / 4
      int notaTempo = compasso / santa_tempo[estaNota];

      buzz(pinBuzzer, santa_melody[estaNota], notaTempo);

      // para distinguir melhor as notas, defimos um tempo mínimo entre ela
      int pausaNotas = notaTempo * 1.30;
      delay(pausaNotas);

      // interrompe a melodia:
      buzz(pinBuzzer, 0, notaTempo);

    }
  } else {

    Serial.println(" 'Jingle Bells'");
    int size = sizeof(melody) / sizeof(int);
    for (int estaNota = 0; estaNota < size; estaNota++) {
      
      // Tomamos 1 segundo divido pelo tipo da nota para calcular a duração
      //ex.  semínima = compasso / 4
      int notaTempo = compasso / tempo[estaNota];

      buzz(pinBuzzer, melody[estaNota],notaTempo);

      // para distinguir melhor as notas, defimos um tempo mínimo entre ela
      int pausaNotas = notaTempo * 1.30;
      delay(pausaNotas);

      // interrompe a melodia:
      buzz(pinBuzzer, 0, notaTempo);
    }
  }
}

void buzz(int pin , int frequencia, float dur) {
  
  digitalWrite(13, HIGH);
   
  int delayValor = 1000000 / frequencia / 2; // calcula o delay entre transições
  //// 1 second's worth of microseconds, divided by the frequency, then split in half since
  //// there are two phases to each cycle

  int numCiclos = frequencia * dur / 1000; // calcula o número de ciclos adequado
  //// multiply frequency, which is really cycles per second, by the number of seconds to
  //// get the total number of cycles to produce

  for (int i = 0; i < numCiclos; i++) { // para definir a duração da nota
    digitalWrite(pin, HIGH); // buzzer em HIGH para emprurrar o diafragama do buzzer
    delayMicroseconds(delayValor); // espera o valor calculado do delay
    digitalWrite(pin, LOW); // buzzer em LOW para puxar o diafragama do buzzer
    delayMicroseconds(delayValor); // espera o valor calculado do delay
    }

  digitalWrite(13, LOW);
} 

 2) Obtenha o header file notas.h e coloque na mesma pasta do sketch no IDE do Arduino:  DOWNLOAD - notas.h

Atenção: o arquivo notas.h deverá estar na mesma pasta onde está o sketch principal:

3) No IDE do Arduino, faça a verificação e o upload para o microcontrolador.

Atenção: Observe que deverá aparecer uma aba com o header file notas.h, como mostra a figura acima. Para visualizar ou alterar o código no IDE basta clicar sobre a aba notas.h.

Vídeo

Como o projeto deve funcionar

1. Ao iniciar o programa, você poderá selecionar a música desejada pressionando um dos botões seletores.

2. Se desejar aumentar ou diminuir o volume, basta girar o eixo do potenciômetro para a direita (aumentar) ou para a esquerda (diminuir).

3. Após finalizar a melodia, o programa aguardará até que seja pressionado um botão seletor para tocar nova música ou repetir a música anterior.

4. Através do monitor serial do IDE, você poderá visualizar os nomes das músicas selecionadas.

Gerar sons em um dispositivo piezoelétrico

1. Neste projeto não vamos utilizar a função tone(pin, frequência, duração) para gerar sons em um sonorizador piezoelétrico.

2. Portanto, para criarmos um onda quadrada de cerca de 50%, vamos utilizar um truque onde ligamos e desligamos o buzzer em frações de microsegundos (delayMicroseconds), conforme mostra padrão abaixo:

digitalWrite(pin, HIGH); // buzzer em HIGH para emprurrar o diafragama do buzzer
delayMicroseconds(delayValor); // espera o valor calculado do delay

digitalWrite(pin, LOW); // buzzer em LOW para puxar o diafragama do buzzer
delayMicroseconds(delayValor); // espera o valor calculado do delay 

Desta forma, para gerarmos um tom,  criamos uma onda quadrada de cerca de 50% no estado lógico HIGH e 50% no estado lógico LOW, onde podemos definir que:

. A variável delayValor determina o tempo em microsegundos entre as fases do efeito piezoelétrico, ou seja, quanto maior o tempo em micro segundos, menor a frequência gerada no buzzer. A imagem abaixo mostra as duas fases de um sonorizador piezoelétrico, onde o dirafragma (metal) irá vibrar gerando ondas sonoras. Leia Transdutor Piezoelétrico.

Explicando o Código do Projeto

 1. Primeiro definimos e declaramos as constantes e as variáveis do projeto.

1.1. Observe que utilizamos as constantes e variáveis tipo "int". Veja na tabela abaixo as diferenças nos tipos de constantes e variáveis:

1.2. Através da diretiva #include incluímos o "header file" notas.h para ser compilado junto ao sketch (não utilize ponte e vírgula no final de uma diretiva #include).

1.2.1. A diretiva #include é utilizada para incluir bibliotecas externas em um sketch. Isso dá ao programador acesso a um grande grupo de bibliotecas C padrão (grupos de funções pré definidas) e também bibliotecas específicas para o Arduino. Como exemplo, o nosso header file que criamos denominado notas.h.

1.2.2. O header file notas.h, que você poderá encontrar em Tabela Notas Musicais, irá definir todas as notas musicais em várias escalas. No arquivo encontraremos um conjunto de várias diretivas #define cujo os tokens são as notas musicais com seus valores de frequência correspondentes necessários para gerar o som.

Observação: As letras A, B, C, D, E, F e G são utilizadas para as notas lá, si, dó, ré, mi, fá e sol, respectivamente (fonte: Wikipédia). Por exemplo, C2, frequência de 65 Hz, é o Dó na escala musical 2, e GS1 por exemplo, tem frequência de 52Hz e significa Sol sustenido (S) na escala musical 1.

1.3. Declaramos a constante tipo inteira pinBuzzer como 9, referindo-se à conexão do buzzer com a porta digital 9 do Arduino.

1.4. Declaramos a constante tipo inteira compasso como 900. Este valor poderá ser alterado, fazendo com que a melodia seja tocada de forma mais rápida (<900) ou mais lenta (>900).

Observação: Você poderá criar valores de compasso diferentes para cada música. Neste exemplo utilizamos o valor do compasso igual para as três músicas.

1.5. Definimos o array tipo inteiro melody[] para a música "Jingle Bells" com todas as notas musicais na ordem que deverão ser tocadas. É importante salientar que as frequências desta notas são obtidas no arquivo notas.h.

1.5.1. Para a música "We wish you a merry Christmas" o array será wish_melody[] e para "Santa Claus is coming to town" o array será santa_melody[].

1.6. Definimos o array tipo int tempo[] para a música "Jingle Bells" com os valores relativos aos tempos (ou duração) das notas musicais, definidas como:

Observação importante: O número de elementos do array tempo[] deve ser o mesmo do array melody[].

1.6.1. Para a música "We wish you a merry Christmas" o array será wish_tempo[] e para "Santa Claus is coming to town" o array será santa_tempo[].

1.7. Repetimos as definições das arrays wish_melody[],  santa_melody[],  wish_tempo[] e santa_tempo[] para as demais músicas, "We wish you a merry Christmas" e "Santa Claus is coming to town".

1.8. Definimos as variáveis bot_1, bot_2 e bot_3 iguais a zero. Estas variáveis são referentes aos valores de leitura dos botões (push bottons).

1.9. Definimos a variável som igual a zero.

2. Através da estrutura void setup(), definimos:

2.1. Definimos como saída do controlador Arduino (OUTPUT) a porta digital 9 conectada ao buzzer (pinBuzzer).

2.1.1. Atenção: Como estamos utilizando um potenciômetro (reostato) para ajustar o volume de som, a saída do controlador deverá estar ligada ao potenciômetro que se ligará ao sonorizador (buzzer).

2.2. Definimos a porta digital 13 como saída do Arduino (OUTPUT) onde deverá estar conectado ao polo positivo do led.

2.2. Definimos as portas digitais 2, 3 e 4 como entrada do controlador Arduino (INPUT_PULLUP) conectadas aos botões (push buttons).

2.2.1. INPUT_PULLUP habilita o resistor pull-up interno do Arduino, eliminando a necessidade de colocarmos um resistor de 10K ligado ao VCC (5V).

2.3. A função Serial.begin() serve para dizer ao Arduino que será coletado dados para o computador a partir da porta serial e o cabo USB. O número entre os parênteses significa qual é a taxa de dados que a placa vai se comunicar com o computador. Utilizaremos a taxa padrão de 9600bps (bits-per-second).

3. Através da estrutura void loop(), obtemos:

3.1. Através da função digitalRead() fazemos as leituras dos botões 1, 2 e 3 para verificarmos qual são seus estados lógicos.

3.1.1. Quando utilizamos o resistor pull-up interno do Arduino, o estado lógico do push botton será Zero (LOW) quando acionado e 1 (HIGH) quando em estado normal.

3.2. Através da instrução if (bot_ == 0) verificamos qual botão está acionado, ou seja, LOW ou zero. Se acionado o programa irá chamar a função sing() 1, 2, ou 3, dependendo de qual botão foi pressionado.

4. Através da função void sint() que criamos, obteremos:

4.1. Através da função sing(int s), que traz o valor 1, 2 ou 3 como variável inteira, definimos o valor da variável som.

4.2. Através da instrução if (som= ) definimos qual música irá tocar. Se som = 3, por exemplo, obteremos:

4.2.1. Através da função Serial.println() escrevemos o nome da música no monitor serial, que no exemplo será "We wish oou a Marry Crhistmas".

4.2.2. Definimos que a variável size = sizeof(wish_melody) / sizeof (int), ou seja, a variável size será igual ao número de notas musicais do array wish_melody (nesta música são 30 notas musiciais).

4.2.3. O operador sizeof conta o número total de bytes ocupados no array wish_melody  Dividido pelo número de bytes de uma variável, contados pela função sizeof(int), teremos o total de notas musicais dentro do array.

Observação: O número de bytes de uma variável int é sempre 2. Portanto, sizeof (int) = 2.

4.2.4.  Através da instrução for (int esta_nota = 0 ;  esta_nota < size; esta_nota++), rodamos todas as notas da melodia definida.

4.2.5.  Através da expressão int notaTempo = compasso / wish_tempo[estaNota] definimos a variável notaTempo (duração da nota musical) onde teremos o compasso dividido pelo tempo de cada nota. Portanto, quanto maior o compasso maior será a duração de cada nota, ou seja, a melodia será executada de forma mais lenta.

4.2.5. O programa chama a função buzz() que irá fazer com que o buzzer toque as notas musicais de acordo com a frequência e a duração de cada nota.

4.2.5.1. A função buzz() levará os valores da frequência e a duração de cada nota musical da melodia.

4.2.6. Definimos um delay de 30% do valor da variável notaTempo (duração da nota musical) para distinguir melhor as notas durante a execução da música. Este valor poderá ser alterado da forma que você achar mais adequada.

4.2.7. O programa chama novamente a função buzz() agora com valor zero para frequência, interrompendo assim a melodia.

5. Através da função void buzz() que criamos, obteremos:

 5.1. Através da função digitalWrite(13, HIGH) acendemos o led, ou seja, definimos o estado lógico do led como 1.

5.2. Definimos o valor da variável delayValor com o o tempo em microsegundos de cada fase do sonorizador piezoelétrico.

5.2.1. A variável delayValor é calculada como: A quantidade de microsegundos em 1 segundo, que equivale a 1000000, dividido pela frequência em HZ e divido por 2, pois existem duas fases no sonorizador piezoelétrico (uma fase para empurrar o metal e outra para puxar o metal, criando o som). Variando os valores das fases do sonorizador obteremos as diferentes notas musicais.

Observação: Este método de criação de som pode ser substituído pela função tone(pino, frequência e duração) que já calcula os valores automaticamente para as duas fases do sonorizador. Veja Referência Arduino - tone() e o projeto 35.

5.3. Calculamos  o número de ciclos (fases do sonorizador) para cada nota. Isto definirá a duração de cada nota.

5.3.1. A variável numCiclos é calculada como a frequência, que é o número de ciclos por segundo, multiplicada pela duração em segundos. Como a duração, definida pela variável dur, está em microsegundos, vamos dividir então por 1000. Portanto numCiclos = frequencia * (dur / 1000).

Observação: Este método de criação de som pode ser substituído pela função tone(pino, frequência e duração) que já calcula os valores automaticamente para as duas fases do sonorizador. Veja Referência Arduino - tone() e o projeto 35.

5.4. Através da instrução for (int i = 0; i < numCiclos; i++) fazemos com que o sonorizador piezoelétrico vibre de acordo com a frequência e duração de cada nota musical.

5.4.1. A função digitalWrite(pin, HIGH) faz com que ocorra uma flexão positiva no metal do sonorizador.

5.4.2. A função digitalWrite(pin, LOW) faz com que ocorra uma flexão negativa no metal do sonorizador.

5.4.3. A função delayMicroseconds(delayValor) definirá a frequência da vibração, ou seja, quanto ciclos por segundo o nosso sonorizador irá vibrar, gerando um tempo de espera entre as fases.

5.4.4. A variável numCiclos irá definir a duração de cada nota musical, ou seja, quantas vibrações na mesma frequência irão acontecer.

5.5. O led é apagado através da função digitalWrite(13, LOW).

Comentários