WJ Componentes

Stream Deck com ESP32

,

Olá, como estão? Aliás já pensaram em ter o seu próprio Stream Deck ou um teclado de macro para poder configurar, mudar e abrir algo com um simples toque? Entretanto caso não saiba o que é um teclado macro ele é um teclado convencional ou uma serie de botões onde você configura a ação. Por exemplo abrir um software, diminuir o brilho, mudar de tela, parar a música e muitas outras ações que podemos configurar neles… Por isso iremos desenvolver um Stream Deck com ESP32.

ESP32
Tela Nextion - WJ Componentes

Componentes Utilizados no Projeto Stream Deck com ESP32

Funcionamento do Projeto Stream Deck com ESP32

A princípio iremos fazer um teclado macro com os botões que colocaremos no display Nextion, e iremos interligar com o ESP32 via comunicação Serial. Em seguida iremos conectar no computador via conexão bluetooth, para que assim possamos enviar comandos para o computador.

Montagem do Circuito do Projeto Stream Deck com ESP32

Logo após compra dos componentes na WJ Componentes, vamos à montagem! Então na montagem do circuito será simples. Primeiramente iremos conectar o VCC do Nextion no pino VIN do ESP32, pois ele tem uma tensão operacional de 4,75 a 7V. Em seguida conectamos também o GND, RX e TX do Nextion nas entradas GND, TX2 e RX2 do ESP32.

Contudo segue abaixo uma imagem que demonstrando a montagem do circuito.

Montagem do Circuito Eletrônico na Protoboard - Aplicativo com ESP32

Software Nextion Editor

Então para conseguimos utilizar o Nextion iremos precisar realizar o download do software Nextion Editor. Logo após abaixá-lo execute o executável e instale o software. Contudo segue documentação do Nextion Editor.

Adicionando Tecla de Atalho em Softwares

Em seguida para adicionar uma tecla de atalho em algum software sem a utilização de programas vá em Área de trabalho -> Botão direito em um ícone de atalho -> Propriedades -> Tecla de Atalho.

Instalação das Bibliotecas

A princípio neste projeto iremos utilizar duas bibliotecas sendo a primeira a Easy Nextion Library, com ela conseguimos enviar informações do Nextion para o ESP32 com comandos simples. Entretanto nós podemos instalar esta biblioteca pelo próprio gerenciador de bibliotecas do Arduíno IDE vá em Ferramentas -> Gerenciar Bibliotecas -> Easy Nextion -> Instalar

Então agora nossa segunda biblioteca será ESP32 BLE Keyboard, com ela conseguimos simular um teclado via bluetooth. Contudo diferente da anterior essa não está no gerenciador de bibliotecas da Arduíno IDE, iremos ter que baixar a biblioteca via Github.

Easy Nextion Library

Antes de mais nada essa biblioteca possui poucas funções, apenas 6 funções sendo elas:

  • begin ();
  • writeNum ();
  • writeStr ();
  • readNumber ();
  • NextionListen ();
  • trigger ();

Contudo possui também 1 objeto e 2 variáveis sendo elas:

  • EasyNex;
  • currentPageId (tipo de dados: inteiro)
  • lastCurrentPageId (tipo de dados: inteiro)

Declaração de Objeto

Então para se declarar um objeto, terá que ser feito depois das bibliotecas e antes da função setup, juntamente com as variáveis globais.

Sintaxe: 

EasyNex nome (Serial);

Onde:

  • nome – Nome do objeto declarado.
  • Serial – Serial que irá ser utilizado.

Função begin ()

Contudo a função begin() inicializa o objeto que passaremos para ele.

Sintaxe: 

myObjeto.begin(baud);

Onde:

  • myObjeto – Nome do objeto que declaramos.
  • baud – Velocidade de transferência de dados.

Função writeNum ()

A função writeNum, para poder escrever números em atributos numéricos em qualquer componente (por exemplo variável, caixas de texto, etc).

Sintaxe: 

myObjeto.writeNum(“String”, uint32_t);

Onde:

  • myObjeto – Nome do objeto que declaramos.
  • String – objectname.numericAttribute (exemplo: “n0.val” ou “n0.bco”… etc).
  • uint32_t – valor (exemplo: 84) (número de 0 a 4.294.967.295).

Função writeStr ()

Para escrever texto no Nextion, entretanto a duas maneiras pelas quais o comando pode ser usado:

Sintaxe 1: 

myObjeto.writeStr(“String”, “String2”);

Onde:

  • Usado para mudar a String de um atributo .txt.
  • myObjeto – Nome do objeto que declaramos.
  • String – Objectname.textAttribute (exemplo: “t0.txt” ou “b0.txt”).
  • String2 – Texto (exemplo: “Olá, Mundo”).

Sintaxe 2: 

myObjeto.writeStr(“String”);

Onde:

  • O comando a ser enviado para o Nextion.
  • myObjeto – Nome do objeto que declaramos.
  • String – Objectname.textAttribute (exemplo: “page 1” ou “dim=50”).

Função readNumber ()

Usamos para ler o valor do atributo de um componente.

Sintaxe: 

myObjeto.readNumber(“String”);

Onde:

  • myObjeto – Nome do objeto que declaramos.

String – objectname.numericAttribute (exemplo: “n0.val”, “n0.pco”).

Função NextionListen ()

Esta função deve ser chamada repetidamente para responder a eventos.

Sintaxe: 

myObjeto.NextionListen();

Onde:

  • myObjeto – Nome do objeto que declaramos.

Função trigger ()

Esta função é pré-definidas e nomeados de trigger1(), trigger2(), trigger3()… até trigger50(). Você pode usá-los como uma função simples fora do loop. Onde executará um bloco de código toda vez que for chamado. Você pode chamar essas funções trigger a qualquer momento no Nextion. Então basta escrever no Evento Nextion o comando printh 23 02 54 XX onde XX é a id em em HEX.

Por exemplo, em um evento de liberação de toque de botão.

ComandoFunção
printh 23 02 54 01trigger 1 ()
printh 23 02 54 02trigger 2 ()
printh 23 02 54 0Atrigger 10 ()
printh 23 02 54 32trigger 50 ()

ESP32 BLE Keyboard

Essa biblioteca possui muitas funções, porém irei falar sobre as funções que usaremos em nosso código.

Declaração de Objeto

Você irá declarar ela após incluir as bibliotecas e antes da função setup, juntamente com as variáveis globais.

Sintaxe: 

BleKeyboard nome ("nomeBLE", "fabricante", Bateria);

Onde:

  • nome – Nome do objeto declarado.
  • nomeBLE – Nome da Rede bluetooth.
  • fabricante – Nome do Fabricante.
  • nomeBLE – Estado inicial da Bateria por default é inicializado com 100% (tipo de dados: inteiro).

Função begin ()

Da mesma forma, que anteriormente iremos iniciar a função begin, e passaremos um objeto para ele.

Sintaxe: 

myObjeto.begin();

Onde:

  • myObjeto – Nome do objeto que declaramos.

Função isConnected ()

A função isConnected, verifica se possui algum aparelho conectado. Caso esteja conectado retorna verdadeiro, caso ao contrário retorna falso.

Sintaxe: 

myObjeto.isConnected();

Onde:

  • myObjeto – Nome do objeto que declaramos.

Função press ()

Usado para pressionar uma tecla do teclado. Após pressionar todas as teclas que gostaria irá precisar utilizá-la um delay de 100 milissegundos e chamar a função releseAll ().

Sintaxe: 

myObjeto.press (KEY);

Onde:

  • myObjeto – Nome do objeto que declaramos.
  • KEY – Tecla do teclado

Você pode conferir todas as teclas clicando aqui.

Função releaseAll ()

A função releaseAll, solta as todas as teclas que foram pressionadas.

Sintaxe: 

myObjeto.releaseAll();

Onde:

  • myObjeto – Nome do objeto que declaramos.

Função print ()

A função print, escreve um texto no bluetooth.

Sintaxe:

myObjeto.print(String);

Onde:

  • myObjeto – Nome do objeto que declaramos.
  • String – Texto que irá ser escrito.

Código-fonte do Projeto Stream Deck com ESP32

Em seguida segue abaixo o código-fonte completo do projeto.

//Bibliotecas ----------------------------------------------------------------------------------------
#include <EasyNextionLibrary.h>                                    // Responsável pelo Nextion
#include <BleKeyboard.h>                                           // Responsável pelo Teclado BLE

//Declaração de Objetos ------------------------------------------------------------------------------
EasyNex Nextion(Serial2);                                          // Objeto Nextion
BleKeyboard bleKeyboard("ESP32 v2", "WJ Componentes", 100);        // Objeto teclado

//Variáveis Globais ----------------------------------------------------------------------------------
int i = 0;                                                         // Variável de controle

//Função Auxiliares ----------------------------------------------------------------------------------
void led();                                                        // Função Pisca LED

//Setup ----------------------------------------------------------------------------------------------
void setup() {
    Nextion.begin(115200);                                         // Inicia objeto Nextion
    pinMode(2, OUTPUT);                                            // Definimos LED como OUTPUT
    bleKeyboard.begin();                                           // Inicia teclado bluetooth
    delay(100);                                                    // Espera 0,1s
}

//Loop -----------------------------------------------------------------------------------------------
void loop() {
    if (bleKeyboard.isConnected()) {                               // Verifica se esta conectado
        if (i == 0) {                                              // Verifica se i = 0
            Nextion.writeStr("page 2");                            // Muda para pagina 2
            i++;                                                   // Incrementa +1 a i
        }
        Nextion.NextionListen();                                   // Espera clicar no botão
    }
    else if (i == 1) {                                             // Se não tiver conectado
        Nextion.writeStr("page 1");                                // Muda para pagina 1
        i--;                                                       // Subtrai -1 de i
    }
}

//LED ------------------------------------------------------------------------------------------------
void led() {
    digitalWrite(2, HIGH);                                         // Ascende o LED
    delay(100);                                                    // Espera 0,1s
    digitalWrite(2, LOW);                                          // Apaga o LED
}

//Abre Chrome ----------------------------------------------------------------------------------------
void trigger1() {
    led();                                                         // Pisca LED
    bleKeyboard.press(KEY_F1);                                     // Pressiona 'F1'
    delay(100);                                                    // Espera 0,1s
    bleKeyboard.releaseAll();                                      // Solta todas as teclas
}

//Abre YouTube ---------------------------------------------------------------------------------------
void trigger2() {
    led();                                                         // Pisca o LED
    bleKeyboard.press(KEY_F1);                                     // Pressiona 'F1'
    delay(100);                                                    // Espera 0,1s
    bleKeyboard.releaseAll();                                      // Solta todas as teclas
    delay(100);                                                    // Espera 0,1s
    bleKeyboard.print("youtube.com");                              //Escreve 'youtube'
    bleKeyboard.press(KEY_RETURN);                                 // Pressiona 'ENTER'
    delay(100);                                                    // Espera 0,1s
    bleKeyboard.releaseAll();                                      // Solta todas as teclas
}

//Abre Word ------------------------------------------------------------------------------------------
void trigger3() {
    led();                                                         // Pisca o LED
    bleKeyboard.press(KEY_F3);                                     // Pressiona 'F3'
    delay(100);                                                    // Espera 0,1s
    bleKeyboard.releaseAll();                                      // Solta todas as teclas
}

//XBOX -----------------------------------------------------------------------------------------------
void trigger4() {
    led();                                                         // Pisca o LED
    bleKeyboard.press(KEY_LEFT_GUI);                               // Pressiona 'Bandeira do Windows'
    bleKeyboard.press('g');                                        // Pressiona 'g'
    delay(100);                                                    // Espera 0,1s
    bleKeyboard.releaseAll();                                      // Solta todas as teclas
}

//Abre Arduino IDE -----------------------------------------------------------------------------------
void trigger5() {
    led();                                                         // Pisca o LED
    bleKeyboard.press(KEY_F2);                                     // Pressiona 'F2'
    delay(100);                                                    // Espera 0,1s
    bleKeyboard.releaseAll();                                      // Solta todas as teclas
}

//Abre Explorador de Arquivos ------------------------------------------------------------------------
void trigger6() {
    led();                                                         // Pisca o LED
    bleKeyboard.press(KEY_LEFT_GUI);                               // Pressiona 'Bandeira do Windows'
    bleKeyboard.press('e');                                        // Pressiona a tecla 'e'
    delay(100);                                                    // Espera 0,1s 
    bleKeyboard.releaseAll();                                      // Solta todas as teclas
}

//Bloqueia o Windows ---------------------------------------------------------------------------------
void trigger7() {
    led();                                                         // Pisca o LED
    bleKeyboard.press(KEY_LEFT_GUI);                               // Pressiona 'Bandeira do Windows'
    bleKeyboard.press('l');                                        // Pressiona 'l'
    delay(100);                                                    // Espera 0,1s
    bleKeyboard.releaseAll();                                      // Solta todas as teclas
}

//Abre Blog ------------------------------------------------------------------------------------------
void trigger8() {
    led();                                                         // Pisca o LED
    bleKeyboard.press(KEY_F1);                                     // Pressiona 'F1'
    delay(100);                                                    // Espera 0,1s
    bleKeyboard.releaseAll();                                      // Solta todas as teclas
    delay(100);                                                    // Espera 0,1s
    bleKeyboard.print("blog.wjcomponentes.com.br");                // Escreve 'blog.wjcomponentes'
    bleKeyboard.press(KEY_RETURN);                                 // Pressiona Enter
    delay(100);                                                    // Espera 0,1s
    bleKeyboard.releaseAll();                                      // Solta todas as teclas
}

Vamos dar uma olhada mais de perto no código:

Incluindo Bibliotecas

Primeiramente temos que incluir as bibliotecas que usamos em nosso projeto.

//Bibliotecas ----------------------------------------------------------------------------------------
#include <EasyNextionLibrary.h>                                    // Responsável pelo Nextion
#include <BleKeyboard.h>                                           // Responsável pelo Teclado BLE

Declarações de Objetos

Então inicializamos dois objetos um para o Nextion e outro para o teclado bluetooth.

//Declaração de Objetos ------------------------------------------------------------------------------
EasyNex Nextion(Serial2);                                          // Objeto Nextion
BleKeyboard bleKeyboard("ESP32 v2", "WJ Componentes", 100);        // Objeto teclado

Variáveis Globais

Logo após declaramos 1 variável global chamada i para controle sendo ela do tipo Inteiro.

//Variáveis Globais ----------------------------------------------------------------------------------
int i = 0;                                                         // Variável de controle

Funções Auxiliares

Então declaramos uma função auxiliar chamada LED para que possamos estar organizando o código-fonte.

//Função Auxiliares ----------------------------------------------------------------------------------
void led();                                                        // Função Pisca LED

Funções Setup

Em seguida já na função setup, iniciamos os objetos que declaramos e configuramos o pino do LED.

//Setup ----------------------------------------------------------------------------------------------
void setup() {
    Nextion.begin(115200);                                         // Inicia objeto Nextion
    pinMode(2, OUTPUT);                                            // Definimos LED como OUTPUT
    bleKeyboard.begin();                                           // Inicia teclado bluetooth
    delay(100);                                                    // Espera 0,1s
}

Funções Loop

Logo após na função loop, verificamos se algum dispositivo conectou via bluetooth, caso tenha conectado ele irá mudar para a tela dois, caso o usuário se desconecte ele volta para a página 1.

//Loop -----------------------------------------------------------------------------------------------
void loop() {
    if (bleKeyboard.isConnected()) {                               // Verifica se esta conectado
        if (i == 0) {                                              // Verifica se i = 0
            Nextion.writeStr("page 2");                            // Muda para pagina 2
            i++;                                                   // Incrementa +1 a i
        }
        Nextion.NextionListen();                                   // Espera clicar no botão
    }
    else if (i == 1) {                                             // Se não tiver conectado
        Nextion.writeStr("page 1");                                // Muda para pagina 1
        i--;                                                       // Subtrai -1 de i
    }
}

Funções LED

Então agora na função LED, nós o ligamos e esperamos 0,1 segundo e desligamos.

//LED ------------------------------------------------------------------------------------------------
void led() {
    digitalWrite(2, HIGH);                                         // Ascende o LED
    delay(100);                                                    // Espera 0,1s
    digitalWrite(2, LOW);                                          // Apaga o LED
}

Funções Tringgers

Agora são nos triggers, irei falar somente de um, pois todos repetem mudando somente as informações.

//Abre Chrome ----------------------------------------------------------------------------------------
void trigger1() {
    led();                                                         // Pisca LED
    bleKeyboard.press(KEY_F1);                                     // Pressiona 'F1'
    delay(100);                                                    // Espera 0,1s
    bleKeyboard.releaseAll();                                      // Solta todas as teclas
}

E assim finalizamos todo código e explicação referentes ao projeto.

Resultado do Projeto Stream Deck com ESP32

Por fim esse foi o resultado obtido com nosso projeto.

Resultado Obtido conectando - Stream Deck com ESP32
Resultado obtido com o vídeo - Stream Deck com ESP32
Resultado obtido com o Apps - Stream Deck com ESP32
Resultado obtido com a eletrônica - Stream Deck com ESP32

Agradecemos sua Presença

Por fim, espero que tenham gostado e aprendido. Compartilhe com seus colegas e deixe um comentário de qual projeto deveria ser o próximo aqui no Blog da WJ Componentes!!
Enfim estarei deixando os arquivos do código-fonte e Fritzing, software e sites utilizados e deixarei também o GitHub da biblioteca utilizada.
Fique à vontade para tirar suas dúvidas nos comentários.

ESP32 – Download do Arquivo:Baixar
Nextion – Download do Arquivo:Baixar
Fritzing – Download do Arquivo:Baixar

Software e Sites Utilizados

GitHub das Bibliotecas Utilizadas

Post Relacionados

    Posts mais Recentes

    Julio Cesar Bonow Manoel

    Julio Cesar Bonow Manoel

    Cursando Engenharia da Computação pelo Centro Universitário Facens e atua no desenvolvimento de projetos na WJ Componentes. Participante da equipe de robótica Omegabotz.

    Deixe um comentário

    O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *