O módulo DFPlayer Mini apresenta-se como uma opção diferencial para aqueles que desejam adicionar estímulos sonoros em circuitos e projetos, pois este componente suporta aplicações tanto de forma autônoma, controlando funções diretamente com uma bateria e alguns botões ao circuito, quanto por comunicação RX/TX, o meio mais utilizado para quem trabalha com sistemas embarcados como placas ESP32, NodeMCU, Arduino, Raspberry, etc. Percepções auditivas fazem parte do funcionamento de muitos sistemas eletrônicos do nosso dia a dia, servindo como forma de alertar, auxiliar, e até mesmo orientar em determinadas situações, afinal, quem nunca utilizou  um smartphone como despertador, se guiou pela voz de um GP, ou até mesmo ouviu o alarme de um carro disparar. Nesta postagem, iremos explorar o funcionamento do módulo DFPlayer vinculado a uma placa ESP32, elaborando exemplos de programações através da plataforma Arduino IDE e fazer o controle via Mobile do sistema.

Componentes

          Para concluir as atividades desse post, tenha em mãos os seguintes componentes:

1 - Placa DOIT ESP32 - ESP-WROOM-32 - WiFi / Bluetooth;
1 - Led Difuso RGB - 5mm;
3 - Resistor 1K - 1/4W - 5%;
2 - Chave Táctil KFC-A06 - 6x6x4,3 mm - 4 Terminais - SMD;
1 - Kit Jumper Macho Macho;
1 - Protoboard 400 Pontos;
1 - DFPlayer Mini MP3;
1 - Fonte 12V - 5V/3,3V p/ Protoboard;
1 - Conversor AC/DC 90~240 VAC - 5VDC/1A - JP4;
1 - Mini Alto Falante 0,5 W 8R 40mm.

          Você pode compra-los clicando nos links acima ou visitando nosso site: www.curtocircuito.com.br.


Pinagem

          Antes de iniciar a construção de um circuito, iremos conhecer algumas das funções e especificações técnicas atribuídas ao módulo DFPlayer mini. Analisando a imagem abaixo, serão encontrados modos de controle AD, I/O e serial, que também irá atuar na comunicação com plataformas serial/UART, saídas DAC de 24 bits e SPK, alimentação de 3,2 á 5 V,  e um leitor micro SD com capacidade máxima de 32 GB, aceitando arquiteturas de sistema FAT16 e FAT 32.

Em cada pino do módulo DFPlayer encontra-se diversas opções voltadas a configuração e controla do mesmo.


          O módulo também dispõe de uma taxa de amostragem de 8 / 11.025 / 12/16 / 22.05 / 24/32 / 44.1 / 48 KHz, suporte para faixa dinâmica 90dB, dados classificados por pasta, suportando até 100 pastas com 255 arquivos de áudio em cada, 30 níveis de volume, e 6 níveis de equalização (0  - Normal, 1 - Pop, 2 - Rock, 3 - Jazz, 4 - Classic, 5 - Bass).


Controle Autônomo

          Além da clássica opção RX/TX aplicada em sistemas embarcados, e da transmissão direta via USB, o módulo DFPlayer apresenta uma boa variedade de opções voltadas a comunicação e controle, se adaptando a necessidade de cada usuário. No exemplo a seguir, iremos explorar a construção de um projeto simples, controlando o ajuste do volume e a escolha da faixa musical diretamente nos terminais IO, sem que haja a necessidade de utilizar qualquer placa microcontroladora. As chaves tácteis na imagem abaixo irão executar determinadas funções de acordo com o tipo toque, se pressiona-lo rapidamente a música irá avançar ou recuar, se segura-lo poderá ajustar o volume. Como opções de saídas para áudio temos os terminais DAC, que serão atribuidas a aplicações que envolvam amplificadores, interações com fones de ouvido ou modos viva-voz, e SPK, que servirão para conexões direta com alto-falantes de até 3W, e no caso do modelo Mini Alto Falante 0,5 W, podemos conecta-lo diretamente ao SPK_1 e SPK_2.

O DFPlayer dispõe de um modo autônomo, possibilitando um controle de suas funções, sem que haja a necessidade de um microcontrolador.

IO_1 - Dminui e Recua    IO_2 - Aumenta e Avança


          Lembre-se de inserir um cartão de memória micro SD com algum arquivo de áudio ao leitor, e alimentar o circuito com 3,2V á 5V, utilizando baterias, pilhas, ou uma fonte para Protoboard


Conecte o alto-falante, alimente o circuito com 3,3V á 5 V, e pressione os botões para testar o funcionamento do circuito.
 

ESP32 e DFPlayer 

          Como foi dito anteriormente, as programações a seguir serão desenvolvidas na plataforma Arduino IDE, vinculando o controle do módulo a uma placa Doit ESP32. Portanto, caso seja seu primeiro contato com este tipo de plataforma, acesse o site Arduino.cc e instale a versão mais recente do software. Após instalar o programa, acesse Arquivos >> Preferências >> URL's Adicionais para Gerenciadores de Placas, e adicione o seguinte link a lista de dispositivos: http://arduino.esp8266.com/stable/package_esp8266com_index.json


Antes de utilizar a IDE do Arduino, adicione a URL correspondente ao ESP32.

Adicione uma vírgula entre cada URL.


          Primeiramente, iremos construir um teste de conexão simples, acionando a leitura do primeiro arquivo de áudio presente no cartão micro SD. Na montagem do circuito elétrico, conecte o alto-falante nos terminais SPK, os pinos RX e TX do módulo no TX2 e RX2 do ESP32 (respectivamente), e um resistor de pull-down entre o pino RX do DFPlayer e o GND do protoboard.


A comunicação entre o DFPlayer e o ESP32 será estabelecida através dos pinos RX e TX, que deverão ser conectados em seus opostos (RX2-TX, TX2-RX).


          No desenvolvimento da programação a seguir será necessário instalar a biblioteca DFRobotDFPlayerMini.h, que poderá ser facilmente encontrada através do gerenciador de bibliotecas da própria IDE do Arduino, clicando em Sketch >> Incluir Biblioteca >> Gerenciar Bibliotecas.


Os exemplos a seguir irão utilizar como base a biblioteca DFRobot.


          Na maioria dos casos, é comum encontrar tutoriais que utilizem SoftwareSerial na configuração serial do módulo, porém, no caso do ESP32 esse tipo de biblioteca não irá funcionar, mesmo que alguns comandos seriais funcionem normalmente, não será possível trabalhar com Serial1 e Serial2. Para solucionar essa questão, iremos trabalhar com a biblioteca HardwareSerial, configurando os pinos e parâmetros de comunicação dos controladores UARTs (Receptor/Transmissor Assíncrono Universal) do ESP32, que são portas seriais de Hardware com a função de realizar troca de dados entre diferentes componentes. 

          Na programação a seguir faremos um breve teste, verificando o funcionamento do módulo através da biblioteca DFRobotDFPlayerMini.h e a comunicação HardwareSerial.

// Projeto Curto Circuito - ESP32 & DFPlayer: Teste de Conexão
// ---- Bibliotecas ----
#include <Arduino.h>
#include "DFRobotDFPlayerMini.h"

HardwareSerial mySoftwareSerial(1); // UART1 (0), UART2 (1), UART3 (2).

DFRobotDFPlayerMini myDFPlayer; // Cria a variável "myDFPlayer"


void setup()
{
  mySoftwareSerial.begin(9600, SERIAL_8N1, 16, 17);  // velocidade, tipo de comunicação, pinos RX, TX
  Serial.begin(115200);                                                     // velocidade 
  Serial.println();
  Serial.println(F("Iniciando módulo DFPlayer ..."));

  if (!myDFPlayer.begin(mySoftwareSerial))
{ // Verifica o funcionamento do módulo // Se não for capaz de identificar o módulo Serial.println(myDFPlayer.readType(), HEX); Serial.println(F("Erro ao iniciar, verifique:")); Serial.println(F("1. A conexao do modulo.")); Serial.println(F("2. Se o SD card foi inserido corretamente.")); while (true); } Serial.println(F("DFPlayer Mini online.")); // Ao identificar o funcionamento do módulo myDFPlayer.setTimeOut(500); //Ajusta o tempo de comunicação para 500ms //----Ajuste do Volume---- myDFPlayer.volume(10); //Volume de 0 á 30. myDFPlayer.volumeUp(); //Volume Up //----Ajusta o Equalizador---- myDFPlayer.EQ(0); //0 = Normal, 1 = Pop, 2 = Rock, 3 = Jazz, 4 = Classic, 5 = Bass //----Define o dispositivo---- myDFPlayer.outputDevice(DFPLAYER_DEVICE_SD); //----Quantidade de Arquivos---- Serial.print(F("Numero de arquivos no cartao SD: ")); Serial.println(myDFPlayer.readFileCounts(DFPLAYER_DEVICE_SD)); myDFPlayer.play(1); //Le o primeiro arquivo no cartão } void loop() { // Vazio, para realizar uma única leitura }

          Qualquer pino GPIO poderá atuar como RX, enquanto TX irá dispor apenas dos terminais entre GPIO00 e GPIO31. Para especificar os valores atribuídos a comunicação RX-TX utilize o comando mySoftwareSerial.begin(9600, SERIAL_8N1, 16, 17). A função if (!myDFPlayer.begin(mySoftwareSerial)) será responsável por verificar o status de conexão, vinculando o controle do módulo a variável "mySoftwareSerial". Após transferir a programação, abra o monitor serial e verifique o status de leitura do DFPlayer, caso visualize a seguinte mensagem de erro, verifique os pontos apresentados e reinicie o ESP32. 


Ao abrir o monitor serial será indicado o status de conexão do módulo, caso falhe, verifique as opções listadas abaixo.


          Quando o componente estiver On-line, serão ajustados alguns parâmetros básicos como volume, equalizador, e selecionando um arquivo. No caso da programação acima, fizemos um ajuste direto, com a função de tocar algum arquivo de áudio uma única vez, aumentando o volume com myDFPlayer.volumeUp(),selecionando o nível 10 em myDFPlayer.volume(10), ajustando a equalização myDFPlayer.EQ(0), e reproduzindo o primeiro arquivo no cartão SD em myDFPlayer.play(1).

Controle via Monitor Serial

          Agora que alguns parâmetros básicos foram apresentados, será possível aprimorar o controle da programação, que, no caso do exemplo abaixo, irá construir um projeto mais completo, elaborando um programa para acionar as funções do DFPlayer através do monitor serial do Arduino IDE. O circuito elétrico desta atividade será similar ao apresentado anteriormente, adicionando apenas um LED RGB aos terminais D15, D02, e D04.


 O LED RGB  será utilizado para testar o funcionamento de algumas funções.


          A programação irá utilizar a ferramenta monitor serial para comunicar-se com o DFPlayer, acionando algumas comandos como pausar, continuar,  ajustar o volume, e selecionar uma música.

// Projeto Curto Circuito - ESP32 & DFPlayer: Controle via Monitor Serial
// ---- Bibliotecas ----
#include <Arduino.h>
#include "DFRobotDFPlayerMini.h"

HardwareSerial mySoftwareSerial(1);

DFRobotDFPlayerMini myDFPlayer;

//--- LED RGB ---
int RED = 15;
int BLUE = 2;
int GREEN = 4;

void setup()
{
  mySoftwareSerial.begin(9600, SERIAL_8N1, 16, 17);  // Taxa de transmissão, tipo, RX, TX
  Serial.begin(115200);
  pinMode(RED, OUTPUT);
  pinMode(BLUE, OUTPUT);
  pinMode(GREEN, OUTPUT);
  Serial.println();
  Serial.println(F("Iniciando modulo DFPlayer ..."));

  if (!myDFPlayer.begin(mySoftwareSerial)) {  // Verifica o funcionamento do módulo
    digitalWrite(RED, 1);
    Serial.println(myDFPlayer.readType(), HEX);
    Serial.println(F("Erro ao iniciar, verifique:"));
    Serial.println(F("1.A conexao do modulo."));
    Serial.println(F("2.Se o SD card foi inserido corretamente."));
    while (true);
  }
  Serial.println(F("DFPlayer Mini online."));
  digitalWrite(RED,   0);


  //----Tempo de comunicação----
  myDFPlayer.setTimeOut(500);


  //----Define o dispositivo----
  myDFPlayer.outputDevice(DFPLAYER_DEVICE_SD);

  //----Quantidade de Arquivos----
  Serial.print(F("Arquivos encontrados no cartao SD: "));
  Serial.println(myDFPlayer.readFileCounts(DFPLAYER_DEVICE_SD));

  //----Ajusta o Equalizador e inicia com a primeira música----
  myDFPlayer.EQ(0);    //0 - Normal
  myDFPlayer.play(1);  //Le o primeiro arquivo no cartão

  Serial.println("Volume: + ou -");
  Serial.println("Avançar e Recuar faixa: a ou r");
  Serial.println("Pausar e Continuar: s ou p");
  Serial.println("Equalizador: 0 - Normal, 1 - Pop, 2 - Rock, 3 - Jazz, 4 - Classic e 5 - Bass ");


}
void loop()
{
  //Armazena os caracteres escritos no Monitor Serial
  char choice = Serial.read();
  if (choice == 'p')
  {
    Serial.println(F("---Play---"));
    digitalWrite(GREEN, 1); 
digitalWrite(BLUE,0); myDFPlayer.start(); //Volume Aumenta delay(10); } if (choice == 's') { digitalWrite(BLUE, 1);
digitalWrite(GREEN,0); Serial.println(F("---Stop---")); myDFPlayer.stop(); //Volume Diminui delay(10); } if (choice == '+') { myDFPlayer.volumeUp(); Serial.println("---Aumenta o volume---"); } if (choice == '-') { Serial.println("---Reduz o volume---"); myDFPlayer.volumeDown(); } if (choice == 'a') { Serial.println("---Avança---"); myDFPlayer.next(); } if (choice == 'r') { Serial.println("---Recua---"); myDFPlayer.previous(); } // Equalizador if (choice == '0') { myDFPlayer.EQ(0); //0 - Normal Serial.println("---Equalizador: Normal---"); } if (choice == '1') { myDFPlayer.EQ(1); //1 - Pop Serial.println("---Equalizador: Pop---"); } if (choice == '2') { myDFPlayer.EQ(2); //2 - Rock Serial.println("---Equalizador: Rock---"); } if (choice == '3') { myDFPlayer.EQ(3); //3 - Jazz Serial.println("---Equalizador: Jazz---"); } if (choice == '4') { myDFPlayer.EQ(4); //4 - Classic Serial.println("---Equalizador: Classic---"); } if (choice == '5') { myDFPlayer.EQ(5); //5 - Bass Serial.println("---Equalizador: Bass---"); } }

          O comando char choice = Serial.read() irá habilitar a leitura de caracteres no monitor serial, porém, apenas os valores especificados na programação irão executar algum tipo de funções, como: "+"  e "-"  no ajuste de volume," s" e "p" para pausar ou continuar, "a" e "r" avançar ou recuar a leitura de um arquivo, e enviando números de 0 á 5 será possível ajustar o tipo de equalização, sendo eles  "0 - Normal, 1 - Pop, 2 - Rock, 3 - Jazz, 4 - Classic, e 5 - Bass".  


O monitor serial será habilitado para o recebimento de caracteres, sendo alguns deles aplicados ao controle das funções do DFPlayer.


          O LED RGB será acionado para indicar três eventos, sendo a cor vermelha aplicada a função de erro do DFPlayer, demonstrando quando possíveis problemas com a conexão do módulo, enquanto as cores verde e azul serão atribuídas aos comando Play e Stop.

Acionamento Mobile

          A aplicação de sistemas sonoros em projetos que envolvam automações como domótica ou Internet das Coisas (IOT) tem sido uma realidade cada vez mais corriqueira, afinal, possuem serventia tanto no quesito de segurança, quanto no laser. Nesse tópico, iremos desenvolver uma programação que integre o controle do DFPlayer a um sistema mobile, acionando o módulo através do Telegram, um aplicativo gratuito para troca de mensagens instantâneas baseado na nuvem. De forma simples, esse aplicativo possui a disposição uma inteligência artificial (IA) capaz de auxilia-lo na construção de seu próprio servo virtual (Bot), que, no caso do projeto proposto, será vinculado a comunicação com o ESP32. Para criar seu próprio chatBot, abra a tela inicial do aplicativo e pesquise por: @BotFather. 


Como referência ao clássico filme "O poderoso chefão", os usuários deverão pedir permissão ao "Father" para conseguir construir um chatbot particular.


          O comando irá direciona-lo a um chat particular com o "Father", o robô virtual do Telegram, que apresentará diversas ferramentas e funções exclusivas, voltadas ao desenvolvimento de projetos IOT. Clique no botão "Iniciar", e envie a mensagem "/newbot" para solicitar a construção de um novo chatBot. Como resposta, o Father irá lhe solicitar um nome para o novo Bot,  e um usuário finalizado com a palavra "bot", este será utilizado como forma de localiza-lo na barra de pesquisa, que, no caso da imagem a seguir, seria: @Curtocircuitobot.


Os chatbots particulares serão compostos por uma IA programável, que irá auxiliar no desenvolvimento de projetos automatizados.

 

          Na mensagem de confirmação, será enviado um Token de acesso, composto por diversas letras e números, com a função de estabelecer conexão entre o chat particular recém-criado e o ESP32.


Para construir uma comunicação entre o chatbot e ESP32, será necessário inserir um token API, que atuará como uma autenticação na comunicação entre o Hardware e o Software.


          Procure pelo novo chatBot na barra de pesquisa, por exemplo: @Curtocircuitobot.


Para localizar o bot recém criado, escreva "@" juntamente ao nome do chat.


          A troca de mensagens entre o Telegram e o ESP32 irá exigir uma conexão Wi-Fi, portanto, antes de transferir a programação substitua os valores "ssid" e "password" por um nome de usuário e senha de uma rede conhecida, adicione o token fornecido pelo "Father" na variável BOTtoken, e adicione a biblioteca UniversalTelegramBot.

// Projeto Curto Circuito - ESP32 & DFPlayer: Telegram Controll

// ---- Bibliotecas ----
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <UniversalTelegramBot.h>
#include "DFRobotDFPlayerMini.h"

//-------- Conexão Wi-Fi -----------
const char* ssid = "NOME_DA_REDE";
const char* password =  "SENHA";

//-------- Token Telegram -----------
#define BOTtoken "NNNNNN:AAAAAAAA" // Token completo enviado pelo Father
#define Intervalo 1000 //Intervalo para obter novas mensagens

//--------Variável DFPlayer Mini -----------
DFRobotDFPlayerMini myDFPlayer;


//-------- HarwareSerial -----------
HardwareSerial mySoftwareSerial(1);

long Scan;

//-------- LED RGB -----------
int RED = 15;
int BLUE = 2;
int GREEN = 4;

int vol = 0;
int music = 0;

WiFiClientSecure client;
UniversalTelegramBot bot(BOTtoken, client);

//-------- Recebe novas mensagens -----------
void Messages(int NewMessages)
{
  
  for (int i = 0; i < NewMessages; i++)
  {
    String chat_id = String(bot.messages[i].chat_id); // Armazena o valor de ID do chat
    String text = bot.messages[i].text; // As mensagens enviadas no chat serão armazenas na variável
    String from_name = bot.messages[i].from_name;// Identifica o nome de usuário
    if (from_name == "") from_name = "Convidado";

    //-----Comandos e Funções-----

    if (text == "/UP")
    { // Se receber /UP
      vol++;                     // Soma 1 ao valor atual de "vol"
      myDFPlayer.volume(vol);    // Ajusta o volume de acordo com "vol"
      myDFPlayer.volumeUp();     // Aumenta o volume
      String volume = " Volume ++"; // Envia uma mensagem ao Telegram
      bot.sendMessage(chat_id, volume, "");
    }

    if (text == "/DOWN")
    { // Se receber /DOWN
      vol--;                     // Subtrai 1 do valor atual de "vol"
      myDFPlayer.volume(vol);    // Ajusta o volume de acordo com "vol"
      myDFPlayer.volumeDown();   // Reduz o volume
      String volume = " Volume --";// Envia uma mensagem ao Telegram
      bot.sendMessage(chat_id, volume, "");
    }
    if (text == "/next")
    { // Se receber /next
      myDFPlayer.next();         // Avança para a próxima música
      String volume = ">>";      // Envia uma mensagem ao Telegram
      bot.sendMessage(chat_id, volume, "");
    }
    if (text == "/return")
    { // Se receber /return
      myDFPlayer.previous();     // Retorna para a música anterior
      String volume = "<<";      // Envia uma mensagem ao Telegram
      bot.sendMessage(chat_id, volume, "");
    }

    if (text == "/Normal")
    { // Se receber /Normal
      myDFPlayer.EQ(0); // Equalizador: normal
      String volume = " Normal";
      bot.sendMessage(chat_id, volume, "");
    }
    if (text == "/Pop")
    { // Se receber /Pop
      myDFPlayer.EQ(1);// Equalizador: Pop
      String volume = " Pop";
      bot.sendMessage(chat_id, volume, "");
    }
    if (text == "/Rock")
    { // Se receber /Rock
      myDFPlayer.EQ(2);// Equalizador: Rock
      String volume = " Rock";
      bot.sendMessage(chat_id, volume, "");
    }
    if (text == "/Jazz")
    { // Se receber /Jazz
      myDFPlayer.EQ(3);// Equalizador: Jazz
      String volume = " Jazz";
      bot.sendMessage(chat_id, volume, "");
    }
    if (text == "/Classic")
    { // Se receber /Classic
      myDFPlayer.EQ(4);// Equalizador: Classic
      String volume = " Classic ";
      bot.sendMessage(chat_id, volume, "");
    }
    if (text == "/Bass")
    { // Se receber /Bass
      myDFPlayer.EQ(5);// Equalizador: Bass
      String volume = " Bass ";
      bot.sendMessage(chat_id, volume, "");
    }
    if (text == "/play")
    { // Se receber /play
      myDFPlayer.start();
      String volume = " Play";// Continua
      bot.sendMessage(chat_id, volume, "");
      digitalWrite(GREEN, LOW);
      digitalWrite(BLUE, HIGH);
    }
    if (text == "/stop")
    { // Se receber /stop
      myDFPlayer.pause();// Pausa
      String volume = " Pause";
      bot.sendMessage(chat_id, volume, "");
      digitalWrite(GREEN,HIGH);
      digitalWrite(BLUE, LOW);
    }

    // Cria um teclado com as opções de comando
    if (text == "/options")
    { // Se receber /options
      String keyboardJson = "[[\"/UP\", \"/DOWN\"],[\"/EQ\", \"/normal\"],[\"/play\",\"/stop\"],[\"/next\",\"/return\"]]";
      bot.sendMessageWithReplyKeyboard(chat_id, "Escolha uma das opções", "", keyboardJson, true);
    }
    // Cria teclado com as opções de equalização
    if (text == "/EQ")
    { // Se receber /EQ
      String keyboardJson = "[[\"/Normal\", \"/Pop\"],[\"/Rock\", \"/Jazz\"],[\"/Classic\",\"/Bass\"],[\"/options\",\"/stop\"]]";
      bot.sendMessageWithReplyKeyboard(chat_id, "Escolha uma das opções", "", keyboardJson, true);
    }
    // Inicia a conversa com o telegram
    if (text == "/start")
    { // Se receber /start
      String welcome = "Olá" + from_name + ", bem-vindo(a) ao DFPLAYER Controll.\n";
      welcome += "\n Envie /options para acessar as opções de controle disponíveis \n";
      bot.sendMessage(chat_id, welcome, "");
    }
  }
}


void setupWifi()
{
  Serial.begin(115200);

  // Indica a rede Wi-Fi ao qual o ESP irá se conectar:
  Serial.print("Conectando ao Wifi: ");
  Serial.println(ssid);
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED)
  { // Enquanto estiver desconectado
    Serial.print(".");
    delay(500);
  }
  // Ao conectar-se
  Serial.println("");
  Serial.println("WiFi conectado");
  Serial.print("Endereço de IP: ");
  Serial.println(WiFi.localIP()); // Envia o endereço de IP de REDE
}

void setup()
{
  mySoftwareSerial.begin(9600, SERIAL_8N1, 16, 17);  // Taxa de transmissão do DFPlayer, tipo de comunicação, pinos RX, TX
  Serial.begin(115200);
  pinMode(RED, OUTPUT);
  pinMode(BLUE, OUTPUT);
  pinMode(GREEN, OUTPUT);
  Serial.println(F("Inicializando modulo DFPlayer... (3~5 segundos)"));
  if (!myDFPlayer.begin(mySoftwareSerial))
  {
    digitalWrite(RED, HIGH);   // Liga o LED Vermelho
    Serial.println(F("Nao inicializado:"));
    Serial.println(F("1.Cheque as conexoes do DFPlayer Mini"));
    Serial.println(F("2.Insira um cartao SD"));
    while (true);
  }
  digitalWrite(RED, LOW);   // Desliga o LED Vermelho
  Serial.println();
  Serial.println(F("Modulo DFPlayer Mini inicializado!"));

  //----Ajustes Iniciais----
  myDFPlayer.setTimeOut(500); //500ms
  myDFPlayer.volume(5);       //Volume 5
  myDFPlayer.EQ(0);           //Equalizacao normal
  setupWifi();                // Ajustes de conexão
  Scan = millis();         // Scan entre cada mensagem
}

void loop()
{
  if (millis() > Scan + Intervalo)
  {
    int NewMessages = bot.getUpdates(bot.last_message_received + 1);

    while (NewMessages)
    {
      Messages(NewMessages);
      NewMessages = bot.getUpdates(bot.last_message_received + 1);
    }

    Scan = millis();
  }
  yield(); // Direciona o comando ao void Messages
  delay(10);
}

          A variável #define Intervalo irá definir um intervalo, voltado a busca de novas mensagens no chatbot. Na função if (millis() > Scan + Intervalo), escrita no final da programação, será realizada uma comparação entre o tempo corrido em millis(), e a soma dos valores de Scan e Intervalo, se millis for maior, irá atualizar as informações recebidas com bot.getUpdates e direciona-las ao void Messages. Envie "/start" para iniciar a comunicação com o chat, if (text == "/start") fará o bot responder ao comando com os valores armazenados na String welcome, a palavra "/options", destacada na mensagem, tem a função de exibir as opções de controle disponíveis diretamente no teclado do Telegram, como mostra a imagem a seguir.


Ao enviar o comando "/options", o teclado do Telegram será ajustado com as opções de controle disponível na programação.


          As opções apresentadas no menu do teclado serão voltadas ao controle das funções do DFPlayer, sendo "/UP" e "/DOWN" aplicados ao volume, "/play" e "/stop" para pausar ou continuar, "/next" e "/return"  avança ou retorna a seleção de músicas, "/normal" ajusta o equalizador com o tipo normal, e "/EQ" abre um segundo teclado com as demais opções de equalização.


O som poderá ser ajustado entre normal, pop, rock, jazz, classic, e bass.


          O comando yield() costuma ser aplicado em funções que levarão algum tempo para serem concluidas, direcionando o controle do programa a outras tarefas, no caso do exemplo acima, irá direciona-las ao recebimento de novas mensagens em void Messages, garantindo total atenção a troca de informações entre o Telegram e o ESP32.


A programação permanecerá a espera de novas mensagens, dando um leve intervalo de 1 segundo entre cada leitura.


Considerações Finais

          O DFPlayer Mini apresenta-se como uma opção completa e econômica para aqueles que desejam trabalhar com sons, afinal, esse pequeno componente nem ao menos necessita de programação em seu funcionamento básico, possibilitando aplicações tanto de formas mais simples, quanto sofisticadas. Na breve introdução apresentada nesse post, inserimos alguns conceitos de controle para este tipo de módulo, que poderia ser facilmente convertido em projetos mais complexos, como por exemplo, um sistema de alarme com horário programado, transmissão de mensagens programadas em pedágios eletrônicos, ou o favorito dos fãs de quadrinhos um assistente pessoal (como o Jarvis ou a Alexa), capaz de responder a comandos de voz e mensagens, executando funções como despertador, lembrete de eventos, e até mesmo o controle de objetos que possuam conexão a internet.