Aprenda sobre a comunicação uart no esp8266 nodemcu

A comunicação UART (Universal Asynchronous Receiver/Transmitter) é um padrão de comunicação usado para transmitir e receber dados que é suportado pela maioria dos microcontroladores, incluindo o ESP8266. Neste artigo, irá ajudá-lo a aprender como usar a comunicação UART no ESP8266.

Como funciona o UART?

O protocolo UART utiliza dois fios para o lado receptor e o lado transmissor. Por definição, o UART é um protocolo de comunicação de hardware que utiliza comunicação serial assíncrona e pode configurar a velocidade de transmissão e recepção.

Ao transmitir dados através do UART, os dados são divididos em quadros (frames) e cada quadro inclui bits de início, bits de dados e bits de fim. Os bits de início e fim são usados para sincronizar o processo de comunicação entre os dispositivos. O número de bits de dados em um quadro de transmissão depende da configuração do UART.

Lado transmissor de dados

Quando o transmissor deseja enviar um quadro de dados, ele envia um sinal na linha de transmissão do nível alto para o nível baixo para sinalizar ao receptor que um quadro de dados está prestes a ser enviado. Em seguida, ele envia os bits de dados na ordem do bit baixo para o bit alto. Ao terminar de enviar os bits de dados, ele envia um sinal na linha de transmissão do nível baixo para o nível alto para sinalizar ao receptor que o quadro de dados foi enviado.

Destinatário dos dados

O destinatário aguarda o sinal de início aparecer na linha de transmissão e, em seguida, começa a receber os bits de dados na ordem do bit mais baixo para o mais alto. Ao terminar de receber os bits de dados, ele verifica o sinal de parada para determinar que o quadro de dados foi recebido.

Como usar a comunicação UART no ESP8266

O NodeMCU ESP8266 tem dois conjuntos de comunicação UART, UART0 e UART1, em que UART0 (são 2 pinos Rx e Tx) é usado para o processo de carregamento do programa, bem como para a comunicação UART direta com o computador através do chip CP2102/CH340, UART1 (são os 2 pinos GPIO2 e GPIO8), em que GPIO8 está conectado ao chip Flash, portanto, ao usar UART1, só podemos transmitir dados através do pino GPIO2.

Hardware Serial

Ao usar o Hardware Serial, podemos comunicar UART com o ESP8266 NodeMCU diretamente através dos dois pinos Rx e Tx. É necessário garantir que os dois pinos Rx e Tx estejam desconectados ao carregar o programa, pois o Arduino IDE carregará o programa para o ESP8266 NodeMCU através desses dois pinos.

Este é um exemplo de código de programa de comunicação UART entre o computador e o kit ESP8266 NodeMCU para controlar o LED ON/OFF enviando o caractere 0/1 do Arduino IDE para o ESP8266.

// Declaração de conexão com LED
#define LED_PIN 2 // D4

void setup() {
  // Inicie o Serial0 para se comunicar com o computador e o Monitor Serial.
  Serial.begin(9600);
  // Inicie a saída LED.
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  // Se houver dados do Monitor Serial, envie e exiba-os.
  if (Serial.available()) {
    char c = Serial.read();
    Serial.write(c);
    // Se o dado for ‘0’, desligue o LED.
    if (c == '0') {
      digitalWrite(LED_PIN, HIGH);
    }
    // Se o dado for ‘0’, desligue o LED.
    if (c == '1') {
      digitalWrite(LED_PIN, LOW);
    }
  }
}

Software Serial

Além da comunicação UART direta através dos dois pinos Rx e Tx, podemos usar a biblioteca ESPSoftwareSerial para criar uma comunicação UART suave. Isso significa que podemos definir dois pinos GPIO quaisquer no ESP8266 para desempenhar a mesma função dos dois pinos Rx e Tx.

Nesta seção, configurarei a comunicação UART no ESP8266 com o Arduino UNO R3 através da biblioteca ESPSoftwareSerial para controlar o LED no Arduino UNO R3 ON/OFF transmitindo os caracteres 0/1.

Código de carregamento para NodeMCU ESP8266.

#include <SoftwareSerial.h>
// Declaração dos pinos RX e TX para espsoftwareserial
#define RX_PIN 4 // D2
#define TX_PIN 5 // D1

// Crie um objeto espsoftwareserial com velocidade de transmissão de 9600
SoftwareSerial mySerial(RX_PIN, TX_PIN);

void setup() {
  // Inicialize a porta serial de hardware com uma velocidade de transmissão de 115200 bauds.
  Serial.begin(115200);

  // Inicie a porta serial do software com uma velocidade de transmissão de 9600 bauds.
  mySerial.begin(9600);

  // Imprimir o aviso de início
  Serial.println("ESP8266 UART Communication Example");
}

void loop() {
  // Se houver dados da porta serial rígida, envie-os para a porta serial flexível.
  if (Serial.available()) {
    char c = Serial.read();
    mySerial.write(c);
  }

  // Se houver dados da porta serial virtual, envie-os para a porta serial física.
  if (mySerial.available()) {
    char c = mySerial.read();
    Serial.write(c);
  }
}

Nesta parte do código, usamos dois tipos de comunicação UART: 1) comunicação UART entre o ESP8266 e o computador (usando Hardware Serial) e 2) comunicação UART entre o ESP8266 e o Arduino Uno (usando Software Serial).

Para carregar este código no ESP8266, você precisa instalar a biblioteca ESPSoftwareSerial no Arduino IDE.

Código de carregamento para Arduino Uno

#include <SoftwareSerial.h> // Biblioteca para porta serial virtual
#define RX_PIN 10 // Pino RX da porta serial flexível
#define TX_PIN 11 // Pino TX da porta serial flexível
#define LED_PIN 13 // Pino conectado ao led

SoftwareSerial mySerial(RX_PIN, TX_PIN); // Criar um objeto de porta serial

void setup() {
  Serial.begin(9600); // Inicie a porta serial com uma velocidade de transmissão de 9600 bauds.
  mySerial.begin(9600); // Inicie a porta serial com uma velocidade de transmissão de 9600 bauds.
  pinMode(LED_PIN, OUTPUT); // A conexão com o LED é a saída.
}

void loop() {
  if (mySerial.available()) { // Se houver dados da porta serial
    char c = mySerial.read(); // // Se houver dados da porta serial
    mySerial.println(c); // Imprimir caracteres de controle através da porta serial
    Serial.println(c); // Imprimir caracteres de controle através da porta serial
    if (c == '0') { // Se o caractere for '0'
      // Bật led
      digitalWrite(LED_PIN, HIGH);
      Serial.println("LED is on"); // No estado LED através da porta serial rígida
    }
    else if (c == '1') { // Se o caractere for 'f'
      // Tắt led
      digitalWrite(LED_PIN, LOW);
      Serial.println("LED is off"); // No estado LED através da porta serial rígida
    }
    else { // Se o caractere for diferente
      // Không làm gì
      Serial.println("Invalid command"); // Relate o erro através da porta serial
    }
  }
}

O princípio de funcionamento deste exemplo é que o computador transmite os caracteres 0/1 para o ESP8266. Quando o ESP8266 recebe os caracteres do computador, ele os transmite para o Arduino Uno R3 através da comunicação UART (Software Serial). Quando o Arduino Uno R3 recebe o caractere “0”, ele acende o LED no pino 13; quando recebe o caractere “1”, ele apaga o LED.

Conclusão

Através deste artigo, aprendemos o básico sobre como usar a comunicação UART no ESP8266 NodeMCU. No entanto, para poder transmitir informações e separar informações da cadeia de transmissão, precisamos aplicar alguns truques para transmitir o conteúdo de acordo com um padrão específico. Quando for necessário transmitir muitos valores do MCU1 para o MCU2, é preciso definir como enquadrar os dados entre o lado transmissor e o lado receptor. No próximo artigo, vou ensinar como transmitir muitos dados através do UART entre dois microprocessadores.