ESP8266 e ESP32 são placas de desenvolvimento WiFi populares. Esses microcontroladores de placa única são suportados pela estrutura MicroPython e são frequentemente usados para a Internet das Coisas (IoT). Usando MicroPython, ESP8266 e ESP32 podem se conectar à Internet via WiFi e Ethernet. As portas MicroPython usam Ethernet ou rede local sem fio (WLAN).
Neste artigo, discutiremos a rede do MicroPython, que é útil para gerenciar conexões de Internet por meio de portas suportadas pelo MicroPython. Também discutiremos como o módulo de rede do MicroPython pode ser usado para configurar uma conexão à Internet no ESP8266 e ESP32 via WiFi.
Módulo de rede
O módulo de rede do MicroPython foi escrito para configurar conexões WiFi. O módulo fornece duas interfaces WiFi: estação e ponto de acesso. A interface do ponto de acesso está ativa por padrão.
- Na interface do ponto de acesso, o ESP8266/ESP32 ou qualquer outra porta MicroPython atua como um ponto de acesso WiFi para outros dispositivos se conectarem à Internet.
- Na interface da estação, o ESP8266/ESP32 ou qualquer outra porta MicroPython se conecta ao roteador para acesso à internet.
O módulo de rede pode ser importado para um script MicroPython com esta instrução:
importar rede, hora
O módulo de rede fornece apenas drivers de rede e configurações de roteador e é usado para configurar interfaces de rede de hardware. Um módulo de soquete é necessário para obter serviços de rede das respectivas interfaces de rede. Isso significa que só podemos usar o módulo de rede para nos conectar à Internet, gerenciar a conexão à Internet definindo as configurações do roteador e criar um ponto de acesso.
O módulo de rede não fornece nenhuma classe abstrata de placa de interface de rede (NIC). Em vez disso, oferece diferentes classes de interface de rede implementadas através das portas MicroPython para diferentes hardwares.
Essas classes de interface de rede incluem:
- A WLAN – para interfaces WiFi
- WLANWiPy – para controles WiFi específicos do WiPy
- LAN – para Ethernet
- CC3K – para módulos WiFi CC3000
- WIZNET5K – para módulos WiFi WIZnet5x00.
As classes de interface de rede são todas projetadas para hardware de rede específico. Uma classe específica de interface de rede possui este método construtor: rede de classe.AbstractNIC(id=Nenhum,…)
O construtor representa um objeto de interface de rede. Os parâmetros passados dependem da classe específica da interface de rede. Se mais de uma interface da mesma classe for instanciada, o primeiro parâmetro deverá ser um “id”.
Por exemplo, o construtor a seguir cria um objeto para a interface de rede WiFi:
nic = rede.WLAN(rede.STA_IF)
Independentemente da classe da interface de rede, o módulo de rede fornece os seguintes métodos…
ResumoNIC.active : usado para ativar ou desativar uma interface de rede. É necessário um argumento booleano. Se passado como True como argumento, a respectiva interface de rede será ativada. Se passado como falso como argumento, a respectiva interface de rede será desativada. Se o método for chamado sem argumentos, ele retornará ao estado atual da interface de rede fornecida.
Nota: Todos os outros métodos só funcionam na interface de rede se este método estiver ativado.
ResumoNIC.connect : conecta a interface a uma rede. Este método só deve ser chamado para interfaces que nem sempre estão conectadas. Os parâmetros passados dependem da classe da interface de rede e/ou da porta MicroPython específica.
Por exemplo, o objeto de interface WiFi requer que o SSID seja passado como parâmetro para conectar-se a uma rede. Se um único parâmetro for passado para este método, será sempre o identificador dos serviços de rede. Outros parâmetros são específicos de palavras-chave. Eles são passados para especificar tipos de identificadores de serviço alternativos ou para fornecer parâmetros de conexão adicionais. Por exemplo, o objeto de interface WiFi pode exigir uma senha de rede como parâmetro adicional.
ResumoNIC.disconnect : desconecta a interface com a rede.
ResumoNIC.isconnected : verifica se a interface está conectada a uma rede. Se retornar True, a interface está conectada à rede. Caso contrário, retorna False.
ResumoNIC.scan : procura serviços de rede ou conexões disponíveis. Ele retorna uma lista de tuplas que correspondem a qualquer um dos parâmetros de serviço encontrados. O formato da tupla depende da classe específica da interface de rede. Uma tupla para um objeto de rede WiFi é a seguinte: (ssid, bssid, canal, RSSI, segurança, oculto). Este método permite que um filtro verifique os resultados. Ele pode ser chamado para procurar um serviço, canal ou serviços específicos de um conjunto específico. Os parâmetros definidos para a duração da varredura e outros parâmetros de rede também podem ser passados como argumentos.
ResumoNIC.status : usado para consultar as informações de status dinâmico de uma rede. Se o método for chamado sem argumentos, ele retornará o status do link da rede. Caso contrário, a classe de interface de rede específica do parâmetro poderá ser passada para recuperar informações específicas. Por exemplo, passar “estações” como argumento para um objeto de interface de ponto de acesso WiFi retorna uma lista de todas as estações conectadas a esse ponto de acesso. Da mesma forma, passar “RSSI” como argumento para uma interface de estação WiFi retorna RSSI (que é o indicador de intensidade do sinal recebido) do ponto de acesso ou roteador conectado.
ResumoNIC.ifconfig : usado para definir ou obter os parâmetros da interface de rede no nível IP. Esses parâmetros incluem endereço IP, máscara de sub-rede, gateway e servidor DNS. Se chamado sem argumentos, ele retorna os parâmetros acima como uma tupla de 4. Para definir os parâmetros da interface de rede no nível IP, uma tupla de 4 com os parâmetros mencionados acima deve ser passada.
ResumoNIC.config : usado para definir ou consultar parâmetros específicos de rede ou hardware. Quando chamados para definir parâmetros, os parâmetros devem ser especificados com argumentos de palavras-chave. É possível definir vários parâmetros específicos de rede ou hardware em uma única chamada de método, onde todos os parâmetros são passados como argumentos específicos de palavras-chave. Apenas um único parâmetro pode ser consultado em uma chamada de método.
Alguns exemplos válidos deste método são:
ap_if.config(ssid='Meu AP')
ap_if.config(ssid='Meu AP', canal=11)
print(ap_if.config('canal'))
imprimir(ap_if.config('ssid'))
Esses métodos estão disponíveis para todas as classes de interface de rede que incluem WLAN, WLANWiPy, LAN, CC3K e WIZNET5K.
O módulo de rede também fornece um método para definir ou obter o modo WiFi. Este método é rede.phy_mode . No entanto, está disponível apenas para ESP8266. Pode ser passado como os argumentos MODE_11B, MODE_11G ou MODE_11N para definir o modo WiFi para IEEE 802.11b, IEEE 802.11g ou IEEE 802.11n, respectivamente. Se chamado sem argumentos, retorna o modo WiFi atual.
Classe WLAN
O módulo de rede de classe WLAN fornece um driver para os processadores de rede WiFi. A classe faz parte do módulo de rede. O método construtor é o seguinte:
rede de classe.WLAN (interface_id)
O método cria um objeto de interface de rede WiFi. Conforme mencionado, existem dois tipos de interfaces WiFi suportadas no MicroPython: estação e ponto de acesso. Este é um exemplo válido para criar um objeto de estação WiFi:
rede de importação
sta_if = rede.WLAN(rede.STA_IF)
Aqui está um exemplo válido para criar um objeto de ponto de acesso WiFi:
rede de importação
ap_if = rede.WLAN(rede.AP_IF)
A classe WiFi do módulo de rede fornece estes métodos…
WLAN.ativo :usado para ativar ou desativar o objeto de interface de rede WiFi. Se passado como argumento True, a interface WiFi identificada pelo objeto WLAN é ativada. Se passado como falso como argumento, a interface WiFi será desativada. Se chamado sem argumentos, o método retorna ao status atual do objeto de rede WiFi.
WLAN.connect(ssid=Nenhum, key=Nenhum, *, bssid=Nenhum): usado para conectar-se a um roteador WiFi ou ponto de acesso. Leva SSID ou BSSID do serviço de rede disponível como argumento. A chave de rede pode ser necessária para passar como um argumento adicional. Se o BSSID for passado, a conexão de rede será restrita ao ponto de acesso com o endereço MAC fornecido. Neste caso, o SSID também deve ser passado.
WLAN.disconnect : desconecta a interface com a conexão WIFI atual.
WLAN.scan : disponível apenas para objetos de estação WiFi. O método procura redes WiFi e ocultas disponíveis, desde que a interface WLAN permita isso. Ele retorna uma lista de tuplas com informações sobre os pontos de acesso WiFi disponíveis. Os valores usados para segurança são “0” para rede WiFi aberta, “1” para WEP, “2” para WPA=PSK, “3” para WPA2-PSK e “4” para WPA/WPA2-PSK. Os valores “0” e “1” indicam os pontos de acesso WiFi visíveis e ocultos, respectivamente.
WLAN.status : retorna o status do link de rede.
O status pode ser:
- STAT_IDLE – não há conexão ou atividade.
- STAT_CONNECTING – a conexão está em andamento.
- STAT_WRONG_PASSWORD – a conexão de rede falhou devido a uma chave de rede incorreta.
- STAT_NO_AP_FOUND – a conexão de rede falhou porque nenhum ponto de acesso respondeu à solicitação de conexão.
- STAT_CONNECT_FAIL – a conexão de rede falhou devido a outro motivo.
- STAT_GOT_IP – a rede foi conectada com sucesso e o IP foi obtido.
Para o objeto estação, o método pode ser chamado com o argumento “RSSI”, que retorna o indicador de intensidade do sinal recebido para um determinado ponto de acesso.
WLAN.isconnected : para um objeto de estação WiFi, este método retorna True se a porta estiver conectada a um ponto de acesso WiFi, indicando que um endereço IP válido foi obtido. Para o objeto WiFi do ponto de acesso, o método retorna True se pelo menos uma estação estiver conectada à porta que está funcionando como ponto de acesso WiFi.
WLAN.ifconfig :usado para definir ou obter os parâmetros da interface de rede no nível IP. Esses parâmetros incluem endereço IP, máscara de sub-rede, gateway e servidor DNS. Se chamado sem argumentos, ele retorna os parâmetros acima como uma tupla de 4. Para definir os parâmetros da interface de rede no nível IP, uma tupla de 4 com os parâmetros mencionados acima deve ser passada.
WLAN.config :usado para definir ou obter parâmetros específicos da rede WiFi. Isso é feito passando argumentos de palavras-chave. Esses parâmetros estão listados abaixo…
Conectando-se manualmente a uma rede WiFi
É possível conectar manualmente o ESP8266/ESP32 a uma rede WiFi usando o prompt de comando Python. Uma conexão manual pode ser feita usando o prompt Python do uPyCraft IDE ou Thonny IDE. Ele também pode funcionar com uma conexão serial a um prompt de comando Python por meio de um programa de terminal (como Putty).
Configuramos uma conexão manual a uma rede WiFi para este projeto usando o console de comando do uPyCraft IDE. Para euPara importar o módulo de rede, use este comando:
rede de importação
A seguir, crie um objeto estação WiFi para conectar a placa ESP8266/ESP32 com uma conexão WiFi. Execute o seguinte comando no console uPyCraft para criar uma interface WiFi de estação:
estação = rede.WLAN(rede.STA_IF)
Ative a interface WiFi da estação chamando o método WLAN.active . Execute o seguinte comando no console do UPyCraft para ativar a interface WiFi da estação:
estação.active(Verdadeiro)
Assim que a interface WiFi estiver ativa, ela poderá ser conectada ao WiFi com o SSID e a chave de rede conhecidos. A chave de rede não será necessária se a conexão WiFi estiver aberta. Execute este comando no console UPyCraft para conectar-se ao WiFi disponível:
station.connect(
Para verificar se a interface de rede está conectada com sucesso a uma rede WiFi, chame o método isconnected . Use este comando no console UPyCraft para verificar a conexão:
estação.isconnected
Se o método retornar True, a interface de rede foi conectada com sucesso ao WiFi. Verifique os parâmetros de nível IP chamando o método ifconfig . Execute o seguinte comando no console do UPyCraft para visualizar os parâmetros de rede no nível IP, que incluem o endereço IP, máscara de sub-rede, gateway e servidor DNS:
estação.ifconfig
A interface de rede pode ser desabilitada, se necessário, chamando o método active . Use este comando no console UPyCraft para desativar a interface de rede WiFi:
estação.active(Falso)
Captura de tela de uma conexão manual a uma rede WiFi usando ESP8266.
Conectando-se com uma chamada de função
Uma conexão WiFi pode ser configurada por uma chamada de função usando um script MicroPython. Os mesmos comandos usados para a conexão WiFi manual também são usados para uma chamada de função — exceto que os comandos são encapsulados em um corpo de função com validação em pontos diferentes.
Abaixo está um exemplo típico de função para configurar uma conexão WiFi usando portas suportadas pelo MicroPython, incluindo ESP8266 e ESP32.
rede de importação
estação = rede.WLAN(rede.STA_IF)
def conectar(id, pswd):
ssid=id
senha=pswd
se station.isconnected == Verdadeiro:
print(“Já conectado”)
retornar
estação.active(Verdadeiro)
estação.connect(ssid, senha)
enquanto estação.isconnected == Falso:
passar
print(“Conexão bem sucedida”)
imprimir(estação.ifconfig )
Você notará que declaramos o objeto estação como uma variável global. Isso nos ajudará a criar uma função para desconectar a rede WiFi sempre que necessário.
Aqui está um exemplo de função para desativar uma conexão WiFi:
def desconectar :
se estação.active == Verdadeiro:
estação.active(Falso)
se station.isconnected == Falso:
print(“Desconectado”)
Este script MicroPython é um exemplo válido para conectar e desconectar ESP8266/ESP32 a uma conexão WiFi:
rede de importação
estação = rede.WLAN(rede.STA_IF)
def conectar(id, pswd):
ssid=id
senha=pswd
se station.isconnected == Verdadeiro:
print(“Já conectado”)
retornar
estação.active(Verdadeiro)
estação.connect(ssid, senha)
enquanto estação.isconnected == Falso:
passar
print(“Conexão bem sucedida”)
imprimir(estação.ifconfig )
def desconectar :
se estação.active == Verdadeiro:
estação.active(Falso)
se station.isconnected == Falso:
print(“Desconectado”)
conectar(“NUA”, “***********”)
desconectar
“NUA” é o nome/SSID da rede WiFi no script acima. Ao lado do SSID está sua senha de rede ou chave de rede. Você deve passar o SSID e a chave de rede da conexão WiFi no script para conectar o ESP8266/ESP32 à internet.
Uma captura de tela do resultado após carregar e executar o script acima em UPyCraft para ESP8266.
Conectando-se automaticamente a uma rede WiFi
ESP8266/ESP32 pode ser configurado para conectar-se automaticamente ao WiFi. Isso pode ser feito adicionando os comandos para conectar-se a uma rede WiFi no arquivo boot.py. O arquivo boot.py é sempre executado primeiro quando o ESP8266/ESP32 ou qualquer porta MicroPython é inicializada.
Adicione o código abaixo no final do arquivo boot.py e carregue novamente o boot.py para ESP8266/ESP32:
rede de importação
estação = rede.WLAN(rede.STA_IF)
se station.isconnected == Verdadeiro:
print(“Já conectado”)
estação.active(Verdadeiro)
estação.connect(“NUA”, “***********”)
enquanto estação.isconnected == Falso:
passar
print(“Conexão bem sucedida”)
imprimir(estação.ifconfig )
Mais uma vez, “NUA” é o nome/SSID da rede WiFi. Ao lado do SSID está sua senha de rede ou chave de rede. Você deve passar o SSID e a chave de rede da conexão WiFi no script para conectar o ESP8266/ESP32 à internet.
O arquivo boot.py modificado.
A conexão WiFi pode ser verificada no script de execução principal usando este trecho de código…
rede de importação
estação = rede.WLAN(rede.STA_IF)
se station.isconnected == Verdadeiro:
print(“Conectado ao WiFi!”)
imprimir(estação.ifconfig )
No script principal, a conexão WiFi pode ser desativada usando este trecho de código…
se estação.active == Verdadeiro:
estação.active(Falso)
se station.isconnected == Falso:
print(“Desconectado”)
O script de execução principal, que verifica a configuração padrão da conexão WiFi na inicialização e a desativa se estiver ativa.
Aqui está uma captura de tela do resultado ao carregar e executar o arquivo boot.py modificado.
Conclusão
MicroPython fornece um módulo de rede para conexão com diferentes mídias. Uma interface de rede comumente usada é WiFi. As portas MicroPython – incluindo ESP32 e ESP8266 – podem ser configuradas como uma estação WiFi e pontos de acesso WiFi ao usar o firmware MicroPython.
Normalmente, ESP32/ESP8266 deve ser configurado como uma estação WiFi para que a Internet das Coisas se conecte corretamente ao WiFi e se comunique com uma plataforma ou serviço IoT/Cloud. Posteriormente, o módulo soquete pode ser usado para executar vários protocolos de Internet e acessar serviços de rede.
É possível conectar manualmente o ESP32/ESP8266 ou qualquer porta MicroPython a uma rede WiFi usando o script de execução principal. A conexão a uma rede WiFi também pode ser automatizada modificando o arquivo boot.py.
