Como conectar a Raspberry Pi Pico à internet WiFi usando ESP8266 5

A Raspberry Pi Pico é uma placa muito versátil. No entanto, um recurso que não está disponível é a comunicação com redes locais. Pensando nessa limitação, elaboramos esse artigo ensinando a conectar a Raspberry Pi Pico ao WiFi com utilizando o ESP8266.

A ausência de acesso às redes locais faz falta principalmente nas aplicações de IoT, onde é desejado o acesso à internet. Uma forma de baixo custo de suprir esta necessidade é conectar ao Pi Pico um módulo ESP-01. Baseado no ESP8266, o ESP-01 é um módulo compacto com suporte a comunicação WiFi. Neste artigo veremos como preparar o módulo ESP-01, conectá-lo ao Raspberry Pi Pico e utilizar a linguagem MicroPython para acessar a internet.

Montagem da Raspberry Pi Pico com o ESP8266 na Protoboard.

Materiais Necessários

Preparando o Módulo WiFi ESP8266 ESP-01

Vamos usar no ESP-01 um firmware padrão da ExpressIf, no qual o ESP8266 é controlado através de “comandos AT” recebidos pela serial. Os “comandos AT” tem este nome porque são iniciados pelas letras AT, eles surgiram para controle de modems.

Normalmente este firmware já vem instalado de fábrica no ESP-01, mas seguem as instruções para instalação ou atualização no Windows.

O firmware que vamos usar é parte do SDK oficial da ExpressIf. Para o ESP-01 deve ser usado o SDK “bare metal” (NONOS). Baixe o SDK de https://github.com/espressif/ESP8266_NONOS_SDK e expanda em um diretório (no meu caso C:\ESP8266_NONOS_SDK).

Vamos usar o adaptador USB para ESP-01, para isso é necessário fazer uma adaptação, ligando um botão entre os pinos GND e GPIO1, como descrito no artigo da Arduino e Cia. Conecte o ESP-01 ao adaptador USB (tomando o cuidado da antena ficar virada para o conector USB). Não conecte ainda o adaptador ao micro.

Módulo Wifi ESPP-01 conectado ao adaptador USB

Baixe o Flash Download Tool do site da ExpressIf, extraia os arquivos do zip em um diretório e execute o flash_download_tool.xxx.exe (onde xxx é a versão).

Escolha ChipType “8266” e Workmode “develop” e clique em OK

Configuração de chip e WorkMode para download da flash.

Pressione o botão no adaptador, ligue a uma porta USB do seu micro e, após cerca de 1 segundo, solte o botão. No Flash Download Tool, selecione a porta serial que foi criada para o adaptador, confira que SpiAutoSet está marcado e a tabela na parte de cima está limpa e clique em Start. Se tudo estiver correto, a caixa “Detected Info” será preenchida.

Tela de configuração do Flash Download Tool para ESP8266.

Preencha a tabela na parte de cima da tela como indicado abaixo, clique em Start e aguarde aparecer Finish.

Tela de configuração do Flash Download Tool para ESP8266 com tabela preenchida.

Conectando o ESP-01 à Raspberry Pi Pico

Siga os seguintes passos para conectar o a Raspberry Pi Pico ao ESP-1:

  1. Corte a barra de pinos ao meio e solde no Raspberry Pi Pico
  2. Espete o Raspberry Pi Pico na Protoboard
  3. Use os jumpers para fazer as conexões indicadas abaixo
Conexão da Raspberry Pi Pico com o ESP8266 no fritzing.

Acessando a Internet Wifi com o Raspberry Pi Pico e ESP8266

A documentação dos comandos AT aceitos pelo ESP-01 pode ser baixada do site da ExpressIf. Os comandos que vamos usar no nosso exemplo são os seguintes:

AT ESP responde com OK, usado para testar a comunicação
AT+CWMODE=1 Coloca o ESP no modo Station
AT+CWJAP=ssid,password Conecta o ESP a uma rede WiFi
AT+CIPSTART=”TCP”,ip,porta Estabelece uma conexão TCP
AT+CIPSEND=tam

dados

Envia dados

Exemplo: Acesso a uma API REST

Para mostrar o potencial dos comandos AT, vamos utilizar um serviço aberto de previsão do tempo, o 7Timer!. Este serviço fornece uma interface REST: fazendo um GET HTTP, com os parâmetros adequados, a previsão do tempo é devolvida em formato JSON.

Os comandos AT aceitos pelo firmware padrão do ESP-01 são bastante básicos, não incluindo suporte ao HTTP. O meu programa exemplo implementa isto de forma bem rústica, mas é o suficiente para fazer uma consulta e apresentar a primeira previsão de tempo na resposta.

Detalhes sobre como preparar o micro e o Raspberry Pi Pico para usar o MicroPython pode ser visto no artigo da Rosana Guse.

Utilize o Thonny para carregar no Pi Pico o programa abaixo, colocando nas linhas apropriadas o ssid e password do seu roteador e a latitude e longitude da sua cidade:

# Demonstração do uso do ESP01 com o Raspberry Pi Pico

import machine
import utime
import json

# Coloque aqui as informações da sua rede
ssid = "DQuadros"
password = "******"

# Coloque aqui a latitude e longitude da sua cidade
latitude = '-23.63283'
longitude = '-46.692355'

# Mudar para True para mostrar comandos e respostas
debug = False

# Inicia a UART
uart0 = machine.UART(0, baudrate=115200, rxbuf=10000)

# Le uma linha finalizada por \n
def leResp(uart=uart0, timeout=2000, ignoraVazias=True):
    resp = b""
    try:
        limite = utime.ticks_ms()+timeout
        while utime.ticks_ms() < limite:
            if uart.any():
                c = uart.read(1)
                if c == b'\r':  # ignora \r
                    continue
                if c == b'\n':
                    if resp != b"" or not ignoraVazias:
                        break
                else:
                    resp = resp+c
        if debug:
            print ("RESP: "+resp.decode())
        return resp.decode()
    except Exception as e:
        if debug:
            print(e)
        return ""
    
# Envia um comando para o ESP-01 e le a resposta
def enviaCmdESP(cmd, uart=uart0, timeout=2000):
    if debug:
        print ("CMD: "+cmd)
    uart.write(cmd+"\r\n")
    leResp(timeout=timeout)  # echo do comando
    return leResp(timeout=timeout)

# Envia dados
def enviaDadosESP(dados, uart=uart0, timeout=2000):
    tam = len(dados)
    if enviaCmdESP("AT+CIPSEND="+str(tam), timeout=timeout) == "OK":
        uart.write(dados)
        while True:
            resp = leResp(timeout=timeout)
            if resp == 'SEND OK':
                return True
            if resp == 'ERROR':
                return False
            if resp == 'SEND FAIL':
                return False
            if resp == '':
                return False
    else:
        return False

# Le resposta HTTP
def leRespHTTP(uart=uart0, timeout=10000):
    leResp(ignoraVazias=False, timeout=timeout)
    while not leResp(ignoraVazias=False, timeout=timeout) == "":
        pass
    resp = ""
    while True:
        r = leResp(ignoraVazias=False, timeout=500)
        resp = resp+r
        if r == "":
            return resp

# Testa se comunicação OK
def testaESP(uart=uart0):
    resp = enviaCmdESP("AT")
    return resp == "OK"

# Conecta com a rede WiFi
def conectaWiFi(uart=uart0):
    # Coloca no modo Station
    if not enviaCmdESP("AT+CWMODE=1") == "OK":
        print ("Erro ao colocar no modo Station")
        return False
    # Dispara conexão
    if not enviaCmdESP('AT+CWJAP="'+ssid+'","'+password+'"',
                       timeout=10000) == "WIFI DISCONNECT":
        print ("Resposta inesperada")
        return False
    if not leResp(timeout=10000) == "WIFI CONNECTED":
        print ("Erro ao conectar ao AP")
        return False
    if not leResp(timeout=10000) == "WIFI GOT IP":
        print ("Erro ao solicitar IP")
        return False
    return leResp() == "OK"

# Faz a consulta à API
def consultaTempo(uart=uart0):
    # Connecta ao site
    ip = '167.99.8.254'
    if not enviaCmdESP('AT+CIPSTART="TCP","'+ip+'",80',
                       timeout=10000) == "CONNECT":
        print ("Erro ao conectar ao site")
        return None
    leResp() # Lê o "OK"
    # Envia a requisição
    url = '/bin/civillight.php?lon='+longitude+'&lat='+latitude+ \
        '&output=json'
    if not enviaDadosESP('GET '+url+ \
        ' HTTP/1.1\r\nHost: www.7timer.info\r\n\r\n'):
        print ("Erro ao enviar a requisição")
        return None
    # Le a resposta
    resp = leRespHTTP(timeout=10000)
    try:
        return json.loads(resp)
    except JSONDecodeError:
        print ("Resposta em formato incorreto")
        return None

# Dicionario para traduzir a previsao
previsoes = {
    'clear': 'limpo',
    'mcloudy': 'parcialmente nublado',
    'cloudy': 'nublado',
    'rain': 'chuva',
    'snow': 'neve',
    'ts': 'tempestade',
    'tsrain': 'tempestade com chuva'
    }

# Programa Principal
print()
print('----------------------------------')
if not testaESP():
    print ("ESP não respondendo corretamente!")
print ("Conectando à rede...")
if conectaWiFi():
    print ("ESP conectado à rede")
    print ("Consultando previsão do tempo...")
    resp = consultaTempo()
    if (not resp is None) and ('dataseries' in resp):
        data = str(resp['dataseries'][0]['date'])
        print ('Data: '+data[6:8]+'/'+data[4:6]+'/'+data[0:4])
        previsao = resp['dataseries'][0]['weather']
        if previsao in previsoes:
            previsao = previsoes[previsao]
        print ('Previsao: '+previsao)

Executando o programa, você deve obter um saída como a abaixo:

Código sendo executado na IDE Thonny.

Conclusão

Neste artigo vimos como usar um módulo ESP-01 para fornecer comunicação à internet para o Raspberry Pi Pico. O exemplo em MicroPython pode servir de base para aplicações simples que necessitem consultar ou armazenar informações em outros sistemas conectados à internet.

Para aplicações mais complexas você pode usar a mesma montagem de hardware porém criar o seu próprio firmware para o ESP-01.

Gostou do artigo? Deixe seu comentário logo abaixo dizendo o que achou. Para mais artigos e tutorias de projetos acesse nosso blog.

Faça seu comentário

Acesse sua conta e participe

5 Comentários

  1. Não carrega as imagens do artigo

    1. Olá!

      Verifique agora, por favor.

      Abraços!
      Vinícius – Equipe FilipeFlop

  2. MUITO bom!!!
    Será que tem como fazer uma conexão socket com essa conexão Wi-Fi??? Seria interessante termos um software em Delphi que pudesse receber e enviar diversas mensagens usando esse tipo de equipamento (enviar e receber valores de fluxo de líquidos, gazes, peças, etc… em consumo ou produção), atualizar mostradores ou sistema de mensagens em vias públicas, etc….

    Euclides Franco de Rezende
    1. A comunicação usada no exemplo é uma “conexão socket”, portanto é plenamente viável o que você quer fazer. O comando AT+CIPSTART efetua uma conexão UDP ou TCP com uma máquina remota, feito isso o formato dos dados trocados é definido pelas aplicações.

  3. MUITO bom!!!

    Euclides Franco de Rezende