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.
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.
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
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
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.
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.
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 a 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.
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.
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 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.
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.
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.
Procure pelo novo chatBot na barra de pesquisa, por exemplo: @Curtocircuitobot.
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.
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 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.
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.
