Despertador com Módulo MP3 e ESP32S Deixe um comentário

Neste tutorial você aprenderá  como criar um despertador personalizável com o ESP32S NodeMCU e o módulo MP3 Arduino DFPlayer Mini. Este projeto combina a praticidade da tecnologia IoT (Internet das Coisas) com a diversão de personalizar o seu despertar com suas músicas favoritas. 

Módulo MP3 Arduino

Ao longo deste tutorial, iremos guiar você desde a montagem do circuito até a programação do despertador, passando pela configuração dos componentes e a integração com a Arduino IDE. Além disso, vamos explorar as funcionalidades do módulo MP3 DFPlayer Mini e aprender como configurá-lo para reproduzir suas músicas preferidas. 

Objetivos

O principal objetivo deste tutorial é fornecer instruções detalhadas para construir um despertador que atenda às suas preferências individuais. Ao final do tutorial, você terá um despertador funcional que exibe o horário atual em um display LCD 16×2, permite ajustar o horário do despertador através de um encoder rotativo e que reproduz a música escolhida no momento do alarme através do módulo MP3. 

Além disso, durante este tutorial você irá:

  • Compreender o funcionamento do display LCD 16×2, do encoder rotativo e do módulo MP3 DFPlayer Mini, compreendendo suas funcionalidades individuais e como eles podem ser integrados em um sistema de despertador personalizado.
  • Explorar as capacidades do ESP32S NodeMCU em conectar-se à rede WiFi e sincronizar o horário utilizando o protocolo NTP (Network Time Protocol), garantindo que o despertador mantenha o horário atualizado com precisão.
  • Integrar o display LCD 16×2, o encoder rotativo e o módulo MP3 DFPlayer Mini ao ESP32S NodeMCU, assegurando uma conexão eficiente entre os componentes e permitindo seu controle através do microcontrolador.
  • Configurar e personalizar o despertador para ajustar o horário do despertador e selecionar a música desejada para reprodução no momento do alarme, proporcionando uma experiência de despertar única e personalizada para o usuário.

Materiais Necessários

Para seguir com este tutorial, você irá precisar dos seguintes componentes:

Materiais Necessários Módulo DFplayer

Além dos itens mencionados acima, você também precisará ter a Arduino IDE instalada em seu computador ou uma conta cadastrada na Arduino Cloud.

Como funciona o Módulo MP3 DFPlayer Mini?

O módulo MP3 Arduino (DFPlayer Mini) é um dispositivo compacto e fácil de usar para reprodução de áudio em formato MP3. Ele é comumente utilizado em projetos DIY que envolvem a reprodução de músicas, efeitos sonoros, mensagens de voz, entre outros. Aqui está uma visão geral de como esse módulo funciona:

  • Armazenamento de Áudio: O módulo DFPlayer Mini não possui memória interna para armazenar arquivos de áudio. Em vez disso, ele é projetado para trabalhar com um cartão microSD. Você precisa carregar seus arquivos de áudio (no formato MP3 ou WAV) em um cartão microSD e inseri-lo no slot correspondente no módulo DFPlayer Mini.
  • Interface Serial Simplificada: O módulo DFPlayer Mini possui uma interface serial UART simples, o que o torna fácil de usar com microcontroladores. Você só precisa conectar os pinos TX e RX do módulo DFPlayer Mini aos pinos correspondentes do seu microcontrolador, além de uma conexão para o controle de volume (geralmente um pino PWM).
  • Feedback de Status: O módulo DFPlayer Mini fornece feedback de status por meio de pinos de saída dedicados. Por exemplo, ele pode enviar sinais para indicar se um arquivo foi reproduzido com sucesso, se houve algum erro na reprodução ou se o cartão microSD foi detectado.
  • Amplificador de Áudio Integrado: O módulo DFPlayer Mini também inclui um amplificador de áudio integrado, o que significa que você pode conectar um alto-falante diretamente ao módulo para reproduzir o áudio sem a necessidade de amplificação externa.

Pinout do Módulo MP3 DFPlayer Mini

Geralmente possui um pinout padrão, consistindo em vários pinos que desempenham funções específicas. Aqui está o pinout típico do módulo DFPlayer Mini:

Módulo MP3 Arduino

  • VCC: Este é o pino de alimentação. Normalmente é alimentado com uma tensão de 3,3V a 5V.
  • GND: Este é o pino de terra, conectado ao terra do sistema.
  • TX (Transmit): Este é o pino de transmissão serial. Ele é usado para transmitir dados do módulo para o microcontrolador. Conecte este pino ao pino RX do seu microcontrolador.
  • RX (Receive): Este é o pino de recepção serial. Ele é usado para receber comandos do microcontrolador. Conecte este pino ao pino TX do seu microcontrolador.
  • ADKEY_1 e ADKEY_2: Estes são os pinos para conectar botões físicos para controlar a reprodução, avanço e retrocesso de faixas, ajuste de volume, entre outras funções. Eles também podem ser configurados para outras funções, dependendo do firmware do módulo.
  • IO_1 e IO_2: Estes são pinos de entrada/saída geral. Eles podem ser configurados para várias funções, como indicadores de status ou controle adicional, dependendo do firmware do módulo.
  • BUSY: Este é um pino de saída que indica o status do módulo. Ele fica alto quando o módulo está ocupado processando um comando ou reproduzindo uma faixa de áudio.
  • SPK_1 e SPK_2: Estes são os pinos de saída do amplificador interno do módulo. Eles podem ser usados para conectar diretamente um alto-falante.
  • DAC_R e DAC_L: Estes são os pinos de saída de áudio do DAC (Digital to Analog Converter). Eles podem ser usados para conectar um amplificador externo ou outros dispositivos de áudio.
  • USB+ e USB-: Estes são os pinos positivo e negativo da porta USB. Ele fornece a energia para o módulo DFPlayer Mini quando conectado através de um cabo USB.

Esteja ciente de que as descrições dos pinos podem variar ligeiramente entre diferentes versões do módulo DFPlayer Mini, então sempre é uma boa ideia verificar o datasheet ou a documentação fornecida pelo fabricante específico do seu módulo.

Circuito Eletrônico com Módulo MP3

Segue o esquema de conexões:

Circuito Eletrônico

As conexões realizadas são as seguintes:

Display LCD 16×2 I2C <-> ESP32S NodeMCU

GND <-> GND
VCC <-> 5V
SDA <-> GPIO21
SCL <-> GPIO22

Módulo MP3 DFPlayer Mini <-> ESP32S NodeMCU

VCC <-> 5V
RX <-> GPIO17
TX <-> GPIO16
GND <-> GND

Módulo MP3 DFPlayer Mini <-> Mini Alto Falante

SPK_1 <-> Terminal Positivo
SPK_2 <-> Nerminal negativo

Encoder Decoder KY-040 Rotacional <-> ESP32S NodeMCU

CLK <-> GPIO18
SW <-> GPIO19
+ <-> 5V
GND <-> GND

Preparação do cartão microSD

Ao utilizar o Módulo MP3 DFPlayer Mini em seus projetos, é fundamental entender o formato esperado para os nomes de arquivos no cartão SD. Este formato padronizado garante uma reprodução suave e sem problemas dos arquivos de áudio.

O DFPlayer Mini requer que os arquivos de áudio sejam nomeados de forma sequencial e específica. Um formato comum é utilizar nomes de arquivos numéricos seguidos por uma extensão específica, como “001.mp3”, “002.mp3” e assim por diante. O número no nome do arquivo indica a ordem de reprodução desejada.

Por exemplo, se você deseja criar uma lista de reprodução de músicas, pode nomear os arquivos no cartão SD como “001.mp3”, “002.mp3”, “003.mp3” e assim por diante, de acordo com a ordem desejada de reprodução. O módulo DFPlayer Mini irá ler esses arquivos em ordem numérica e reproduzi-los conforme especificado.

Configuração da Arduino IDE para o ESP32S NodeMCU

 

 

Antes de efetivamente realizar os ajustes na Arduino IDE, é necessário instalar o driver CP210X. Siga os passos abaixo:

  1. Acesse o site oficial da Silicon Labs para baixar o driver CP210x adequado para o seu sistema operacional. Você pode encontrar os drivers em: Silicon Labs CP210x USB to UART Bridge VCP Drivers.
  2. Escolha o seu sistema operacional na lista disponível para baixar o driver apropriado. Certifique-se de baixar o driver compatível com a sua versão específica do sistema operacional.
  3. Conecte o dispositivo o ESP32S ao seu computador usando um cabo USB. Após conectar o dispositivo, o sistema operacional deve reconhecê-lo automaticamente.
  4. Abra o Gerenciador de Dispositivos e navegue até Portas (COM e LPT). Clique com o botão direito do mouse em ‘Silicon Labs CP210x USB to UART Bridge (COMX)’, escolha ‘Atualizar Driver’ e, em seguida, selecione a pasta onde você acabou de baixar o driver. Aguarde até que a instalação seja concluída.

Na sequência, podemos seguir com a preparação da Arduino IDE:

  1. Abra a Arduino IDE e vá para “Arquivo > Preferências”.
  2. No campo “URLs do Gerenciado de Placas Adicionais”, adicione o seguinte URL: https://dl.espressif.com/dl/package_esp32_index.json. Clique em “OK” para fechar a janela de preferências.
  3. Agora, vá para “Ferramentas > Placa > Gerenciador de Placas….”
  4. Na barra de pesquisa, digite “ESP32” e você deve ver uma opção chamada “esp32” na lista. Clique no botão “Install” para instalar o suporte ao ESP32.
  5. Após a instalação, vá para “Ferramentas > Placas” e selecione a placa “ESP32 Dev Module“.
  6. Conecte seu ESP32 ao computador usando um cabo USB. Em seguida, vá para Ferramentas > Porta e selecione a porta COM à qual o ESP32 está conectado. A porta COM atribuída pode variar de acordo com o seu sistema operacional.

Instalação das Bibliotecas

Para garantir o funcionamento adequado do código com o ESP32S, é necessário instalar algumas bibliotecas. As seguintes bibliotecas podem ser facilmente instaladas usando o Gerenciador de Bibliotecas da Arduino IDE:

  • NTPClient – por Fabrice Weinberg: Esta biblioteca permite sincronizar o relógio do ESP32 com um servidor de tempo (NTP), garantindo que o dispositivo mantenha o tempo preciso.
  • AiEsp32RotaryEncoder – por Igor Antolic: Esta biblioteca é útil para lidar com a entrada de um codificador rotativo (rotary encoder), facilitando a interação do usuário em projetos que necessitam de entrada rotativa.
  • DFRobotDFPlayerMini – por DFRobot: Essa biblioteca é crucial para controlar o módulo DFPlayer Mini, permitindo a reprodução de arquivos de áudio a partir de um cartão SD.

Para instalar essas bibliotecas, siga estes passos simples:

  1. Abra a Arduino IDE e vá para Ferramentas > Gerenciar Bibliotecas….
  2. Na barra de pesquisa, digite o nome da biblioteca desejada (por exemplo, ‘NTPClient’, ‘AiEsp32RotaryEncoder’ ou ‘DFRobotDFPlayerMini’).
  3. Clique no botão ‘Instalar’ ao lado da biblioteca para iniciar o processo de instalação. Aguarde até que a instalação seja concluída.

Além disso, é necessário instalar a biblioteca LiquidCrystal_I2C. Siga as instruções abaixo para instalar esta biblioteca:

  • Clique aqui para baixar a biblioteca LiquidCrystal_I2C. Você deverá ter uma pasta .zip em seus Downloads.
  • Descompacte a pasta .zip e você obterá a pasta LiquidCrystal_I2C-master.
  • Renomeie sua pasta de LiquidCrystal_I2C-master para LiquidCrystal_I2C.
  • Mova a pasta LiquidCrystal_I2C para a pasta de bibliotecas da sua instalação da Arduino IDE.
  • Finalmente, reabra sua Arduino IDE.

Código

Este código demonstra um exemplo de como criar um despertador com ESP32, utilizando diversos componentes como um display LCD I2C, um encoder rotativo e um módulo DFPlayer Mini para reprodução de músicas. 

No início do código, são incluídas as bibliotecas necessárias para o projeto, como a NTPClient para sincronização de tempo via NTP, WiFi para conexão com a rede Wi-Fi, LiquidCrystal_I2C para controle do display LCD, AiEsp32RotaryEncoder para interação com o encoder rotativo e DFRobotDFPlayerMini para controle do módulo DFPlayer Mini. 

Em seguida, são definidas as configurações de rede Wi-Fi e outras variáveis globais, como pinagem do encoder e variáveis para armazenar informações como hora, minuto e música selecionada. O código também inclui a criação de objetos para a inicialização de dispositivos, como o cliente NTP, display LCD, encoder rotativo e módulo DFPlayer Mini. 

Além disso, apresenta diversas funções auxiliares para lidar com diferentes tarefas, como exibir o horário atual no LCD, ajustar a hora do despertador, escolher a música do despertador, exibir informações sobre a música selecionada e verificar se é hora de ativar o despertador.

Na função de configuração inicial (setup), são realizadas as configurações iniciais, como inicialização da comunicação serial, conexão com a rede Wi-Fi, configuração do cliente NTP, inicialização do display LCD, do encoder rotativo e do módulo DFPlayer Mini. Já no loop principal, o código executa continuamente as funções que atualizam o horário no LCD e verificam se é hora de ativar o despertador.

Importante! Antes de carregar o código abaixo para o ESP32, não esqueça de editar as linhas 8 e 9 com as suas credenciais de rede WiFi (nome da rede e senha da rede).

// Programa: Despertador com ESP32S NodeMCU e módulo MP3 DFPlayer Mini
// Autor: Rosana Guse

#include <NTPClient.h>
#include <WiFi.h>
#include <LiquidCrystal_I2C.h>
#include "AiEsp32RotaryEncoder.h"
#include "DFRobotDFPlayerMini.h"

// Configurações de rede Wi-Fi
const char* ssid = "insira-aqui-o-nome-da-rede-wifi";
const char* password = "insira-aqui-a-senha-da-rede-wifi";

// Pinagem do encoder
#define DT_ENCODER 23
#define CLK_ENCODER 18
#define SW_ENCODER 19
#define VCC_ENCODER -1
#define STEPS_ENCODER 4

// Variáveis globais
int programa = 0;
int lcdColunas = 16;
int lcdLinhas = 2;
int minuto = 0;
int hora = 0;
int minutoDespertador = 0;
int horaDespertador = 0;
int musicaDespertador = 0;
int numeroMusicaAtual = 1;
int totalDeArquivos = 0;
int ultPosicao;
int leituraCLK;

char horaDespertadorStr[3];
char minutoDespertadorStr[3];
char horaStr[3];
char minutoStr[3];

bool escolhendoHoras = false;
bool escolhendoMinutos = false;
bool escolhendoMusica = false;
bool reproduzindoMusica = false;
bool despertadorAtivo = false;
bool alarme = false;

// Criação de objetos
WiFiUDP udp;
NTPClient ntp(udp, "a.st1.ntp.br", -3 * 3600, 60000);
LiquidCrystal_I2C lcd(0x27, lcdColunas, lcdLinhas);
AiEsp32RotaryEncoder rotaryEncoder = AiEsp32RotaryEncoder(DT_ENCODER, CLK_ENCODER, 
SW_ENCODER, VCC_ENCODER, STEPS_ENCODER);
HardwareSerial mySoftwareSerial(1);
DFRobotDFPlayerMini myDFPlayer;

// Função de interrupção do encoder
void IRAM_ATTR readEncoderISR() {
  rotaryEncoder.readEncoder_ISR();
}

// Função para obter o horário atual e exibi-lo no LCD
void horarioAtual() {
  hora = ntp.getHours();
  minuto = ntp.getMinutes();
 
  sprintf(horaStr, "%02d", hora);
  sprintf(minutoStr, "%02d", minuto);
 
  Serial.print("Horário: ");
  Serial.print(horaStr);
  Serial.print(":");
  Serial.println(minutoStr);

  lcd.setCursor(1, 0);
  lcd.print("Horario Atual");
  lcd.setCursor(5, 1);
  lcd.print(horaStr);
  lcd.print(":");
  lcd.print(minutoStr);
  delay(100);

  if (rotaryEncoder.isEncoderButtonClicked()) {
    Serial.println("Ajustar Hora Despertador...");
    escolhendoHoras = true;
    ajusteHoraDespertador();
  }
}

// Função para ajustar a hora do despertador
void ajusteHoraDespertador() {
 
  lcd.clear();
 
  while (escolhendoHoras == true) {
    if (rotaryEncoder.encoderChanged()) {
      horaDespertador = rotaryEncoder.readEncoder();
      Serial.print("Hora Despertador: ");
      Serial.println(horaDespertador);

      if (horaDespertador < 0) {
        horaDespertador = 59;
      }
      else if (horaDespertador > 59) {
        horaDespertador = 0;
      }
    }
    sprintf(horaDespertadorStr, "%02d", horaDespertador);

    lcd.setCursor(2, 0);
    lcd.print("Despertador");
    lcd.setCursor(5, 1);
    lcd.print(horaDespertadorStr);
    lcd.print(":");
    lcd.print(minutoDespertadorStr);
    delay(100);

    if (rotaryEncoder.isEncoderButtonClicked()) {
      Serial.println("Ajustar Minuto Despertador...");
      escolhendoHoras = false;
      escolhendoMinutos = true;
      ajusteMinutoDespertador();
    }
  }  
}

// Função para ajustar os minutos do despertador
void ajusteMinutoDespertador() {
  while (escolhendoMinutos == true) {
    if (rotaryEncoder.encoderChanged()) {
      minutoDespertador = rotaryEncoder.readEncoder();
      Serial.print("Minuto Despertador: ");
      Serial.println(minutoDespertador);

      if (minutoDespertador < 0) {
        minutoDespertador = 59;
      }
      else if (minutoDespertador > 59) {
        minutoDespertador = 0;
      }
    }
    sprintf(minutoDespertadorStr, "%02d", minutoDespertador);

    lcd.setCursor(2, 0);
    lcd.print("Despertador");
    lcd.setCursor(5, 1);
    lcd.print(horaDespertadorStr);
    lcd.print(":");
    lcd.print(minutoDespertadorStr);
    delay(100);

    if (rotaryEncoder.isEncoderButtonClicked()) {
      Serial.println("Despetador Ajustado...");
      escolhendoMinutos = false;
      escolhendoMusica = true;
      escolhaMusica();
    }
  }  
}

// Função para escolher a música do despertador
void escolhaMusica(){
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Selecione a");
  lcd.setCursor(0, 1);
  lcd.print(F("musica..."));
  totalDeArquivos = myDFPlayer.readFileCounts(DFPLAYER_DEVICE_SD);
  totalDeArquivos = myDFPlayer.readFileCounts(DFPLAYER_DEVICE_SD);
  Serial.println(totalDeArquivos);
 
  while (escolhendoMusica == true){
    if (rotaryEncoder.encoderChanged()) {
      numeroMusicaAtual = rotaryEncoder.readEncoder();
      if (numeroMusicaAtual < 1) {
        numeroMusicaAtual = 1;
      }
      else if (numeroMusicaAtual > totalDeArquivos) {
        numeroMusicaAtual = totalDeArquivos;
      }
      Serial.println(numeroMusicaAtual);
      displayListaMusica(numeroMusicaAtual);
      delay(150); // debounce
    }
    if (rotaryEncoder.isEncoderButtonClicked()){
      musicaDespertador = numeroMusicaAtual;
      Serial.print("Música selecionada: ");
      Serial.println(musicaDespertador);
      escolhendoMusica = false;
      despertadorAtivo = true;
      lcd.clear();
      loop();
    }
  }
}

// Função para exibir informações sobre a música selecionada no LCD
void displayListaMusica(int numeroMusica){
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(F("Musica "));
  lcd.print(numeroMusica);
  lcd.setCursor(0, 1);
  lcd.print(F("Nome: "));
  lcd.print(F("00"));
  lcd.print(numeroMusica);
  lcd.print(F(".mp3"));
}

// Função para verificar se é hora de ativar o despertador
void verificaDespertador(){
  if (ntp.getHours() == horaDespertador && ntp.getMinutes() == minutoDespertador 
  && despertadorAtivo == true) {
    alarme = true;
    reproduzindoMusica = true;
    lcd.clear();
    while (alarme == true) {
      if (reproduzindoMusica == true){
        myDFPlayer.play(numeroMusicaAtual);
        delay(200);
        reproduzindoMusica = false;
      }
     
      Serial.println("Alarme!");
     
      lcd.setCursor(5, 0);
      lcd.print("Alarme");
      lcd.setCursor(5, 1);
      lcd.print("Ativo!"); // Exibe a hora do despertador formatada
      delay(100);

      if (rotaryEncoder.isEncoderButtonClicked()) {

        Serial.println("Alarme desativado");
        myDFPlayer.stop();
        alarme = false;
        despertadorAtivo = false;
        lcd.clear();
        loop();
      }  
    }
  }
}

// Configuração inicial
void setup() {
 
  Serial.begin(9600);
 
  // Conexão Wi-Fi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Conectando ao WiFi...");
  }
  Serial.println("Conectado ao WiFi com sucesso!");
 
  // Configuração do cliente NTP
  ntp.begin();
  ntp.forceUpdate();
 
  // Inicialização do LCD
  lcd.init();                    
  lcd.backlight();
 
  // Inicialização do Encoder
  rotaryEncoder.begin();
  rotaryEncoder.setup(readEncoderISR);
  bool circleValues = false;
  rotaryEncoder.setBoundaries(0, 59, circleValues);
  rotaryEncoder.setAcceleration(250);
 
  // Inicialização do DFPlayer Mini
  mySoftwareSerial.begin(9600, SERIAL_8N1, 16, 17);
  if (!myDFPlayer.begin(mySoftwareSerial)) {                                                      
    Serial.println(myDFPlayer.readType(), HEX);
    Serial.println(F("Erro ao iniciar, verifique:"));
    Serial.println(F("1. A conexão do módulo."));
    Serial.println(F("2. Se o SD card foi inserido corretamente."));
    while (true);
  }
  Serial.println(F("DFPlayer Mini online."));
  myDFPlayer.setTimeOut(500);
  myDFPlayer.volume(20);
  myDFPlayer.volumeUp();
  myDFPlayer.EQ(0);
  myDFPlayer.outputDevice(DFPLAYER_DEVICE_SD);
}

// Loop principal
void loop() {

  horarioAtual();
  verificaDespertador();
}

Funcionamento

Após conectar o circuito utilizando um cabo USB, o display 16×2 exibirá o horário atual, obtido através do protocolo NTP pela rede WiFi do ESP32.

YouTube video

Para ajustar o horário do despertador, basta pressionar o botão do encoder e girá-lo até atingir a hora desejada. Após ajustar a hora, pressione o botão novamente e gire o encoder para definir os minutos desejados. Um último clique confirma a seleção.

Em seguida, você poderá selecionar a música que deseja que o despertador reproduza. Utilize o encoder para percorrer a lista e clique no botão para confirmar sua escolha.

Quando o horário atual coincidir com o horário programado no despertador, o alarme será ativado, reproduzindo a música previamente selecionada. Para desativá-lo, basta pressionar o botão do encoder.


Se você tiver dúvidas, sugestões ou experiências para compartilhar, fique a vontade para deixar um comentário abaixo. E para não perder nenhum conteúdo como este, não deixe de nos seguir no Instagram.

Faça seu comentário

Acesse sua conta e participe