Automação de baixo custo com ESP01: 19 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

Hoje, vamos discutir a automação usando ESP01 com 16 relés. É um modelo de design super barato onde você pode multiplicar os módulos e chegar até 128 relés, já que é possível colocar até oito expansores de porta neste microcontrolador.

Em nosso circuito, você terá um aplicativo em um smartphone que se comunica com o ESP01. Terá um expansor com 16 portas, cada uma conectada a um relé. Também temos uma fonte ajustável 3v3. Portanto, controlaremos um módulo de retransmissão de 16 canais usando ESP01 por meio do aplicativo Android, que disponibilizo para você.

Etapa 1: Dica para lembrar

É importante notar, meus amigos, que usei este chip em um circuito chamado MCP23016. Também é importante que você assista ao vídeo EXPANSOR OF IOS FOR ESP32, ESP8266 E ARDUINO, no qual testo o dispositivo e mostro que funciona para esses três tipos de placas.

Etapa 2: MCP23016

Aqui temos uma imagem do MCP23016, que é um chip com 28 pinos. É importante citar que existe também o modelo MCP23017, que é mais comum e não precisa de resistor e capacitor, pois possui clock interno. Isso torna mais fácil, mas sua fixação é diferente do que mostramos neste vídeo.

Etapa 3: Endereço

Para definir o endereço do MCP23016, usamos os pinos A0, A1 e A2. Você pode apenas deixá-los em HIGH ou LOW para a mudança de endereço.

O endereço será formado da seguinte forma:

MCP_Address = 20 + (A2 A1 A0)

Onde A2 A1 A0 pode assumir valores ALTOS / BAIXOS, um número binário de 0 a 7 formas.

Por exemplo:

A2> GND, A1> GND, A0> GND (significa 000, então 20 + 0 = 20)

Ou então, A2> HIGH, A1> GND, A0> HIGH (significa 101, então 20 + 5 = 25)

Etapa 4: Comandos

Aqui está uma tabela com comandos para comunicação:

Etapa 5: categorias

GP0 / GP1 - Registros de porta de dados

Existem dois registros que fornecem acesso às duas portas GPIO.

A leitura do registro fornece o status dos pinos nessa porta.

Bit = 1> HIGH Bit = 0> LOW

IODIR0 / IODIR1

Existem dois registros que controlam o modo de pin. (Entrada ou saída)

Bit = 1> Bit INPUT = 0> OUTPUT

Etapa 6: Estrutura para comunicação

Aqui falamos sobre o endereço do chip e acessamos o comando e os dados, que é um tipo de protocolo que precisa ser feito para enviar informações.

Etapa 7: Programa

Faremos um programa que consiste em comunicar o ESP01 com o MCP23016 para ter mais GPIOs para usar. Esses 16 novos GPIOs que teremos irão controlar um módulo de retransmissão de 16 canais.

Os comandos serão enviados ao ESP01 por meio de um aplicativo Android.

Etapa 8: MCP23016

Etapa 9: ESP-01

Esta é uma placa de 16 relés.

Etapa 10: Montagem do ESP01

Etapa 11: Bibliotecas e variáveis

Incluiremos as bibliotecas responsáveis pela comunicação i2c e pela criação do Access Point e do servidor web. Definimos o endereço do chip e as portas. Finalmente, definimos as variáveis para armazenar os valores dos pinos MCP.

#include // responsável pela comunicação i2c. # include // responsável por criar o accesspoint e o webserver WiFiServer server (80); // webserver para acessarmos através do aplicativo // endereço I2C do MCP23016 #define MCPAddress 0x20 // ENDEREÇOS DE REGISTRADORES # define GP0 0x00 // REGISTRO DE PORTA DE DADOS 0 #define GP1 0x01 // REGISTRO DE PORTA DE DADOS 1 #define IODIR0 0x06 // REGISTRO DE DIREÇÃO I / O 0 #define IODIR1 0x07 // REGISTRO DE DIREÇÃO I / O 1 // guarda os valores dos pinos fazer MCP uint8_t currentValueGP0 = 0; uint8_t currentValueGP1 = 0;

Etapa 12: Configuração

Inicializamos o ESP01 e configuramos as portas. Também configuramos o Ponto de Acesso e inicializamos o servidor.

void setup () {Serial.begin (9600); atraso (1000); Wire.begin (0, 2); // ESP01 Wire.setClock (200000); configurePort (IODIR0, OUTPUT); configurePort (IODIR1, OUTPUT); writeBlockData (GP0, 0x00); writeBlockData (GP1, 0x00); configuraçãoWiFi (); // configuração do Access Point server.begin (); // inicialização do servidor}

Etapa 13: Loop

Aqui eu verifico se algum cliente foi conectado ao servidor. Também lemos a primeira linha de solicitação. Extraímos os dados para manipulação, definimos o cabeçalho de resposta padrão e enviamos essa resposta ao cliente.

void loop () {cliente WiFiClient = server.available (); // Verifica se um cliente foi conectado se (! Cliente) {retornar; } String req = client.readStringUntil ('\ r'); // Faz a leitura da primeira linha da requisição / * / MR é o header prefixo para saber se a requisição é esperada para os relés * / if (req.indexOf ("/ MR")! = -1) {parserData (req); // a partir da requisição extrai os dados para manipulação} else {Serial.println ("invalid request"); Retorna; } client.flush (); String s = "HTTP / 1.1 200 OK / r / n"; // cabeçalho padrão de resposta client.print (s); // envia uma resposta para o atraso do cliente (1); } // fim do loop

Etapa 14: ParserData

A partir da solicitação, buscamos os dados relacionados aos relés. Em seguida, enviamos os dados para o MCP23016.

// a partir da requisição da busca de dados referentes aos relésvoid parserData (String data) {uint8_t relay = -1; uint8_t gp = -1; valor uint8_t = -1; índice interno = data.indexOf ("/ MR"); // busca o índice do prefixo MR if (data [index + 5] == '/') // / MR01 / 1, onde 0 = GP; 1 = RELE; 1 = ESTADO (ligado / desligado) {gp = dados [índice + 3] - '0'; relé = dados [índice + 4] - '0'; valor = dados [índice + 6] - '0'; // envia os dados para o MCP23016 // [relay-1] porque o MCP vai de 0-7 os pinos writePinData (relay-1, valor, gp); }}

Etapa 15: ConfigurePort

Definimos o modo de pino GPIO (GP0 ou GP1).

// configura o modo dos pinos GPIO (GP0 ou GP1) // como parametro passamos: // porta: GP0 ou GP1 // INPUT para todos as portas do GP trabalharem como entrada // OUTPUT para todos as portas do GP trabalharem como saida // custom um valor de 0-255 indicando o modo das portas (1 = INPUT, 0 = OUTPUT) // ex: 0x01 ou B00000001 ou 1: indica que apenas o GPX.0 trabalhará como entrada, o restante como saida void configurePort (porta uint8_t, custom uint8_t) {if (custom == INPUT) {writeBlockData (porta, 0xFF); } else if (custom == OUTPUT) {writeBlockData (port, 0x00); } else {writeBlockData (porta, personalizado); }}

Etapa 16: WritePinData

Nesta parte do código, mudamos o estado de um pino desejado e enviamos os dados para o MCP.

// muda o estado de um pino desejado, passando como parametro: // pin = pino desejado; valor = 0/1 (liga / desliga); gp = 0/1 (PORT do MCP) void writePinData (int pin, int value, uint8_t gp) {uint8_t statusGP = 0; if (gp == GP0) statusGP = currentValueGP0; senão statusGP = currentValueGP1; if (valor == 0) {statusGP & = ~ (B00000001 << (pin)); // muda o pino para BAIXO} else if (value == 1) {statusGP | = (B00000001 << (pin)); // muda o pino para HIGH} if (gp == GP0) currentValueGP0 = statusGP; senão currentValueGP1 = statusGP; // envia os dados para o MCP writeBlockData (gp, statusGP); atraso (10); }

Etapa 17: WriteBlockData e SetupWiFi

Aqui, enviamos dados para o MCP23016 por meio do barramento i2c. A seguir, configuramos as propriedades para habilitar o Ponto de Acesso. Por fim, configuramos o WiFi para o modo Access Point e criamos um AP com SSID e a SENHA.

// envia dados para o MCP23016 através do barramento i2c // reg: REGISTRADOR // dados: dados (0-255) void writeBlockData (porta uint8_t, dados uint8_t) {Wire.beginTransmission (MCPAddress); Wire.write (porta); Wire.write (dados); Wire.endTransmission (); atraso (10); }

// configura como propriedades para habilitar o PONTO DE ACESSOvoid setupWiFi () {WiFi.mode (WIFI_AP); WiFi.softAP ("ESP01_RELAY", "12345678"); }

Etapa 18: aplicativo

Para criar o aplicativo, utilizamos o MIT App Inventor 2, que pode ser acessado através do link:

ai2.appinventor.mit.edu/

O aplicativo consiste em duas telas contendo oito pares de botões em cada uma, indicando o estado de cada relé.

A seguir estão alguns dos blocos de programação usados:

IMPORTANTE: O endereço IP padrão do ESP, como ponto de acesso é 192.168.4.1

1. Quando a tela inicializa, armazenamos o IP na memória e chamamos o procedimento para recuperar o estado dos botões (ON / OFF).

2. Ligue para a outra tela

1. Ao clicar no botão ON de um dos relés, faremos alterações visuais no botão (blocos verdes). WebViewer1. GoToUrl faz uma solicitação para nosso ESP01 vinculando os dados MR01 / 1 na URL.

2. Ao clicar no botão OFF de um dos relés, faremos alterações visuais no botão (blocos verdes). WebViewer1. GoToUrl faz uma solicitação ao nosso ESP01 vinculando os dados MR01 / 0 na URL.

Este procedimento é utilizado para recuperar o estado dos botões (relés), pois ao mudar a tela, ele retorna ao padrão de criação.

O bloco amarelo se repete para cada um dos pares de botões.

Etapa 19: Baixar

Aqui estão os arquivos do projeto para download:

Arquivo de projeto do MIT App Inventor 2 - download

APK do aplicativo para instalar no Android - download

Baixe os outros arquivos:

PDF

EU NÃO