Buffer não-inversor CD4050 com ESP8266 e Arduino UNO

CD4050 com ESP8266

Neste outro post falamos sobre LLC ou, conversor de nível lógico e divisor de tensão que são opções alternativas ao CD4050 com ESP8266 ou com Arduino, para fazer a comunicação entre dispositivos de diferentes tensões, como é o caso do Arduino (5v) e o ESP8266 (3.3v).

Como sempre cito, sei pouquíssimo sobre eletrônica e pesquiso muito para poder fazer algo. Já em programação e microcontroladora me viro bem, mas as vezes me deparo com dúvidas como do tipo:

– Posso usar o 3.3v do Arduino para alimentar o ESP8266, uma vez que ele pode consumir até 170mA?

Vi esquemáticos utilizando o 3.3 e parece funcionar sem problemas. Também vi nos casos de uso que não estão subindo o sinal de 3.3 para 5 na comunicação com o Arduino (nesse caso, dispensando o conversor de nível lógico, ou um MOSFET, etc) e os meios utilizados para fazer a queda de tensão tem sido mesmo [divisor de tensão]. Mas esse elegante CI pode dar um charme a mais e tem um custo baixo, valendo a experiência. Ainda, quero deixar claro que o divisor de tensão resolveria plenamente a questão e também o CD4050 está sendo utilizado exclusivamente entre o TX do Arduino e RX do ESP8266.

Para fazer a alimentação a 3.3v, não podemos utilizar um divisor de tensão porque ele não suporta carga e aí sim, tudo o que vi foi alimentação a partir do Arduino. Porém, preferí utilizar um regulador de tensão para derrubar pra 3.3v e ter algo realmente confiável, sem receio de drenar mais do que a controladora possa oferecer (mostrarei adiante).

Esse CI tem como uma de suas funcionalidades, fazer a conversão de nível lógico para baixa, isto é, você pode receber sinais de 5v nos pinos por exemplo, e ele automaticamente baixa para a tensão de alimentação, sendo esta a sua referência. Por isso, utilizá-lo como um conversor de nível lógico entre Arduino e ESP8266 é uma boa opção.

Características

O CD4050 é um hex buffer não-inversor com capacidade de gerenciar 2 TTLs, convertendo nível lógico de alta pra baixa, com taxas parametricas de 5v, 10v e 15v.

Os pinos tem correspondência; entra alta, sai baixa. No diagrama de blocos a relação dos pinos está clara, como você pode notar.

Seu datasheet tem 4 exemplos de uso, mas aqui vamos ver apenas sua aplicação para conversão de nível lógico – um processo muito simples, mas é um complemento ao post supracitado.

Feitas as apresentações, vamos ver como pinar utilizando um ESP8266 (3.3v) alimentado através de um regulador de tensão, que também proverá energia para o CD4050. O Arduino, alimentado pela USB, como de costume nos testes, trabalhando em 5v.

ESP8266-01

É meio incomum ver uma imagem utilizando 2 protoboards tiny, mas foi assim que montei para resolver problemas que tive no inicio. Por exemplo, eu estava conectando o regulador 3v3 a uma protoboard com o regulador 5v. Ao enviar qualquer comando para o ESP8266, o LED de alimentação praticamente apagava. Estava claro que era algo relacionado a corrente. Pesquisei um bocado e encontrei em um fórum uma citação do datasheet dizendo que a diferença de tensão deveria ser de no mínimo 3v – e não sei o porque, mas é fato – assim que alimentei o regulador 3.3v diretamente com a fonte e alimentação de 9v, o problema não ocorreu mais. Esse foi o passo 1.

Passei a trabalhar sobre um segundo problema; a comunicação não ocorria entre o ESP8266 e o Arduino, então utilizei o Bus Pirate da Dangerous Prototypes para descobrir o que sucedia. Me surpreendi um pouco, porque jamais esperava por isso, mas o ESP8266-01 estava já configurado a 115200bauds. Descoberto isso, pude enviar comandos e perceber em que resultava, assim, seguidamente trabalhar os comandos AT na interface do Arduino. Aliás, uma referência de visual e conteúdo agradável sobre os comandos AT do ESP8266 pode ser vista nesse link.

Colocando ESP8266 na protoboard
Para colocar o ESP8266 na protoboard, duas coisas são necessárias; que a protoboard tenha uma divisão central e que você tenha slots de pinos do Arduino, que você encontra no LabDeGaragem ou no Mercado Livre. Eu fiz um “L” nas pernas do slot e encaixei cada um de um lado da protoboard, juntando-os ao meio, como demonstro nas imagens seguintes:

Repare que o pino de reset está ligado diretamente na alimentação de 3.3v. Eu havia deixado sem nada, mas estava causando comportamentos anômalos, dentre os quais, reset. Deixá-lo em “HIGH” resolveu o problema, mas o correto é controlá-lo através da microcontroladora para o caso de haver a necessidade de um reset, bastando por o pino em LOW por uns 100ms e voltando-o a HIGH posteriormente.

Esse post teve mais o propósito de apresentar o buffer como opção para a conversão de nível lógico, portanto o exemplo de código que segue trata de fazer uma pequena comunicação entre o ESP8266 e meu notebook. No meu notebook executei um pequeno script python para abrir um servidor TCP, receber e exibir mensagens e os pontos de conexão (veja o video). O código python utilizado, logo abaixo:

import socket
import sys
 
HOST = '192.168.1.230' # Symbolic name, meaning all available interfaces
PORT = 8888 # Arbitrary non-privileged port
 
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print 'Socket created'
 
#Bind socket to local host and port
try:
 s.bind((HOST, PORT))
except socket.error as msg:
 print 'Bind failed. Error Code : ' + str(msg[0]) + ' Message ' + msg[1]
 sys.exit()
 
print 'Socket bind complete'
 
#Start listening on socket
s.listen(10)
print 'Socket now listening'
 
#now keep talking with the client
while 1:
 #wait to accept a connection - blocking call
 conn, addr = s.accept()
 print 'Connected with ' + addr[0] + ':' + str(addr[1])
 while 1:
 data = conn.recv(1024)
 if not data: break
 print(data)
 
s.close()

Mais uma vez, quero salientar que esse código foi utilizado para simples teste e não serve para mais nada, nem implementação de código porque após receber uma mensagem, fica atrelado ao ponto para sempre. Porém, essa foi a prova de conceito que fiz para implementar um projeto freela, que no final será com PIC.

Já no Arduino, o código foi implementado para receber e enviar comandos AT; o código não é meu, copiei de algum lugar e infelizmente não tenho a referência, mas é apenas leitura-escrita serial, nada significativo. Quando vi pronto, não havia mais razão para escrever o meu próprio para prova de conceito.

Está gerando caracteres estranhos e não sei a razão, infelizmente (farei mais testes). De qualquer modo, o video mostra a configuração de uma conexão TCP e o envio de mensagem.

#include <SoftwareSerial.h>

SoftwareSerial esp8266(2,3); // make RX Arduino line is pin 2, make TX Arduino line is pin 3.
// This means that you need to connect the TX line from the esp to the Arduino's pin 2
// and the RX line from the esp to the Arduino's pin 3
void setup()
{
  Serial.begin(115200);
  esp8266.begin(115200); // your esp's baud rate might be different
}

void loop()
{
  if(esp8266.available()) // check if the esp is sending a message
  {
    while(esp8266.available())
    {
    // The esp has data so display its output to the serial window
    char c = esp8266.read(); // read the next character.
    Serial.write(c);
    }
  }



  if(Serial.available())
  {
    // the following delay is required because otherwise the arduino will read the first letter   of the command but not the rest
    // In other words without the delay if you use AT+RST, for example, the Arduino will read the letter A send it, then read the rest and send it
    // but we want to send everything at the same time.
    delay(1000);

    String command="";

    while(Serial.available()) // read the command character by character
    {
    // read one character
      command+=(char)Serial.read();
    }
    Serial.print("nComando: ");
    Serial.println(command);
    esp8266.println(command); // send the read character to the esp8266
  }
}

No video apresento um problema, ainda insolúvel para mim. Que dar dar sua dica de como resolvê-lo?

Iniciei testes com o Arduino Leonardo pela questão da velocidade utilizada com SoftwareSerial, conforme a sugestão do Ricardo (nos comentários). Realmente, softserial não funcionou bem a 115200, mas com o Arduino Leonardo (que possui duas seriais) ficou uma beleza!

E no próximo post será exibido um protocolo de comunicação para receber no PC informações do sistema composto por Arduino e ESP8266. Além disso, em alguns dias será disponibilizado ao menos 1 post com ESP8266-07 e ao menos 1 post com ESP8266-12.




Se gostou, acompanhe-nos no Do bit Ao Byte no facebook e até o próximo!