Programmig Esp8266-Based Wireless Syste in MicroPython - En.pt

Programação ESP8266 baseada em
Sistemas sem fio em

MicroPython
Por Yury Magda
Copyright © 2017 por Yury Magda. Todos os direitos reservados.
Os programas, exemplos e aplicações apresentadas neste livro foram incluídas por seu valor
instrutivo. As ofertas autor nenhuma garantia implícita ou expressa, incluindo, mas não se
limitando a garantias implícitas de adequação ou comerciabilidade para qualquer finalidade
específica e não aceita qualquer responsabilidade por qualquer perda ou dano decorrente do
uso de qualquer informação neste livro, ou qualquer erro ou omissão dessas informações, ou
qualquer uso incorreto desses programas, procedimentos e aplicações.
Nenhuma parte desta publicação pode ser reproduzida, armazenada num sistema de
recuperação, ou transmitido em qualquer forma ou por qualquer meio, electrónico,
mecânico, de gravação, ou de outra forma, sem a prévia escrita do autor.
Conteúdo
introdução
Disclaimer
Configurando ESP8266
Execução de comandos através de uma interface serial O manuseio do
sistema de arquivos na placa ESP8266 Usando WebREPL
Programação de sistemas de rede sem fio com saídas digitais ESP8266

Condução: projeto 1 Condução saídas digitais: Projecto 2 PWM
Programação
Lendo os sinais analógicos de projecto: 1 os sinais
analógicos de Leitura: 2 projecto
Lendo os sinais analógicos usando um entradas digitais

Servidor de Leitura Web: Projeto 1 Leitura entradas digitais:
Projeto 2
Lendo entradas digitais usando um servidor Web
Introdução
Este livro descreve os princípios básicos da programação de aplicações Wi-Fi sem fio com base em quadros de
ESP8266-compatíveis usando uma linguagem de programação MicroPython. MicroPython é uma implementação magra e eficiente
do Python 3 e inclui um pequeno subconjunto da biblioteca padrão do Python. MicroPython é otimizado para ser executado na
maioria dos microcontroladores populares (ATSAMD21, STM32, esp8266, etc.) e em ambientes restritos.
MicroPython está repleto de funcionalidades avançadas, tais como um alerta, inteiros de precisão arbitrária, fechos, compreensão da lista,
geradores, tratamento de exceção interativo e muito mais. No entanto, é bastante compacto para ajuste e executar dentro de apenas 256k de
espaço de código e 16k de memória RAM. objetivos MicroPython ser tão compatível com Python normal quanto possível para que você possa
transferir código com facilidade a partir do desktop para um microcontrolador ou sistema embarcado.
O livro contém vários projetos de sistemas de medição e controlo sem fios simples. Cada projeto é acompanhado por uma
descrição breve que ajuda a tornar as coisas claras. Todos os projetos descritos neste manual pode ser facilmente melhorado
ou modificado se necessário.
Todas as aplicações sem fio foram construídos e testados no PC desktop rodando Linux (Ubuntu 16.04) e um 1,0
(ESP-12E) bordo nodemcu equipado com esp8266 CPU. O código-fonte de aplicações foi desenvolvido em Python 3 e
MicroPython.
aviso Legal
As técnicas de projeto descritos neste livro foram testadas na nodemcu 1,0 (ESP-12E), sem danos do equipamento. Eu não vou
aceitar qualquer responsabilidade por danos de qualquer espécie devido a ações tomadas por você depois de ler este livro.
Configurando ESP8266
Antes de utilizar um ESP8266 devemos configurar o seu firmware. Depois que o módulo ESP8266 foi conectado a uma
porta USB do PC, uma interface serial é atribuído à placa. Podemos facilmente verificar isso digitando o seguinte comando
na janela Terminal: $ ls -l / dev / ttyU *
CRW-rw ---- uma raiz dialout 188, 0 гру 25 10:43 / dev / ttyUSB0
Neste caso particular, o nosso ESP8266 pensão (nodemcu) está associado a um dev / dispositivo / ttyUSB0. Este
dispositivo será usado ao configurar nosso conselho para operar no ambiente MicroPython.
Em primeiro lugar, apagar a memória flash placa ESP8266 usando o esptool.py utilitário que deve ser previamente instalado no
Linux. A sequência de comando apaga o flash, produzindo a saída mostrada abaixo:
$ Esptool.py --port / dev / ttyUSB0 erase_flash esptool.py

v1.3-dev Conectando ...
Não foi possível conectar. [<Class '__main __ FatalError'>; Excedeu a aguardar cabeçalho do pacote]. Tentando novamente ...
Correndo Cesanta pisca-pisca toco ... Apagar Flash

(pode demorar um pouco) ... Erase levou 8,5 segundos
Depois de apagar estiver concluída, podemos escrever o intérprete MicroPython em uma memória flash de esp8266. Para fazer
isso, devemos baixar a imagem estável MicroPython mais recente para ESP8266 de http://microbit.org/download . O firmware
para ESP8266 pode ser encontrada na seção “Firmware para esp8266 boards”. No meu caso, este foi o arquivo esp8266-20161110-v1.8.6.
Em seguida, implantar o novo firmware usando o esptool.py comando como é mostrado abaixo: $ esptool.py --port / dev /
ttyUSB0 --baud 460.800 write_flash --flash_size = detectar 0 esp8266- 20161110-v1.8.6.bin
No meu caso, o comando produziu o seguinte resultado:
$ Esptool.py --port / dev / ttyUSB0 --baud 460.800 write_flash --flash_size = detectar 0 esp8266- 20161110-v1.8.6.bin
esptool.py v1.3-dev Conectando ...
Não foi possível conectar. [<Class '__main __ FatalError'>; Excedeu a aguardar cabeçalho do pacote].
Tentando novamente ...
tamanho do Flash detectada automaticamente:
32m Correndo Cesanta pisca-pisca toco ...
flash parâmetros definido para 0x0040
Escreveu 569344 bytes em 0x0 em 12,6 segundos (362,3 kbit / s) ... Deixando ...
Após as etapas acima sucedido, podemos acessar o ambiente MicroPython na placa nodemcu usando um comando
REPL pronta.
Execução de comandos através de uma interface serial
A maneira mais fácil de testar um código e executar comandos é usar o REPL (Leia Avaliar Imprimir Loop). REPL é o
MicroPython interativo pronta usado para interagir com uma placa esp8266. Para acessar o REPL podemos usar um
interface serial UART ou Wi-Fi. O REPL está sempre disponível na interface serial UART0 que utiliza pinos GPIO1 ( TX) e
GPIO3 ( RX). A taxa de transmissão do REPL é 115200. Se uma placa esp8266 tem uma interface USB-to-UART como no caso
de nodemcu, então seremos capazes de acessar a REPL directamente a partir do PC. Caso contrário, você precisará ter uma
forma de comunicar com o UART. Para acessar o mais necessidade que prompt de USB-serial usar algum programa emulador de
terminal. No Windows, TeraTerm é uma boa escolha, no Mac, podemos usar o built-in tela programa e Linux podemos usar picocom,
minicom ou tela. Neste guia, usará o tela utilidade.
No Ubuntu 16.04, tela é lançado pela entrada: $ tela / dev /

ttyUSB0 115200
Uma vez que a ligação através da porta serial é estabelecida, podemos testá-lo premindo Entrar algumas vezes até que o
MicroPython REPL linha (>>>) aparece.
O exemplo a seguir ilustra como executar um script simples que alterna o on-board LED no pino GPIO16 do
conselho nodemcu.
> > > máquina de importação

> > > tempo de importação
> > > cnt = 0
> > > levou = machine.Pin (16, machine.Pin.OUT)
> > > enquanto cnt <10:
... led.high ()
... time.sleep (0,5)
... led.low ()
... time.sleep (0,5)
... CNT + 1 =
... led.high ()
>>>
Podemos executar até mesmo scripts mais complicados do REPL alerta, mas seria muito melhor ter a capacidade de
criar, editar, salvar e executar scripts MicroPython diretamente na placa esp8266. Para fazer isso, precisamos usar
qualquer um dos poucos utilitários descritos na seção seguinte.
Manipulação do sistema de arquivos na placa ESP8266
A fim de manipular arquivos localizados na placa ESP8266, devemos saber como o MicroPython controla um sistema de arquivos.
Digitando um código dentro do REPL série seria adequado quando precisamos executar pequenos scripts. Desenvolvimento e execução de
programas complexos podem exigir outras ferramentas. MicroPython tem um sistema de arquivo interno que pode armazenar o código que é
executado sempre que os poderes do conselho para cima. Neste guia, vamos usar a ferramenta Adafruit MicroPython ( ampy) para carregar arquivos
e executar um código MicroPython em uma placa de esp8266.
Nota que todas as placas ESP8266 compatíveis reservar apenas uma pequena parte de sua memória flash interna para o sistema de
arquivos. o ampy utilitário pode ser baixado a partir https://github.com/adafruit/ampy . ampy Não é a única ferramenta para manipular arquivos
e muito mais em uma placa de MicroPython, existem várias outras ferramentas descritas no site da Adafruit www.adafruit.com . Eles estão
listados abaixo:
ESP8266 WebREPL - Para as placas baseadas em ESP8266 o WebREPL fornece uma interface web básico para
upload de arquivos para o conselho. Isso é útil para soltar um arquivo em uma placa, mas exige estar conectado
à WebREPL que pode não ser sempre conveniente.
rshell - um controle remoto ferramenta MicroPython shell que lhe permite acessar os arquivos e mais de uma placa de
MicroPython ligados através de sua conexão serial / USB.
mpfshell - semelhante ao rshell e fornece acesso a arquivos e REPL em um shell específico da MicroPython. No entanto, mpfshell
é feito especificamente para apoiar as placas baseadas em ESP8266 e do conselho WiPy.
Este guia utiliza ampy porque é uma ferramenta de linha de comando multi-plataforma simples que fornece a funcionalidade apenas o suficiente
para o acesso ao sistema de arquivos de um MicroPython sem ser demasiado complexa. Esteja ciente que ampy não suporta a falar com um
placas sem uma conexão REPL série / USB.
Nota que antes de usar uma ferramenta como ampy para placas baseadas em ESP8266, que talvez seja necessário desativar a depuração
saída na placa. Se você estiver usando uma compilação de lançamento oficial do MicroPython (isto é, que termina em uma versão simples como
1.8.6 em vez de uma compilação diária mais complexo como 1.8.6-xx-xxxxxxxx) saída de depuração já está desativado e você não faz precisa fazer
nada extra. No entanto, se você estiver usando uma compilação diária ou compilação personalizado a partir da fonte que você precisa para saída de
depuração desativar que pode confundir ferramentas como ampy.
Para desativar a saída de depuração em ESP8266, devemos estabelecer a conexão com o ESP8266 através de um REPL série e
execute os seguintes comandos: import esp
esp.osdebug (Nenhum)
o esp.osdebug () função retorna nenhuma saída. Depois de executar a saída do comando de depuração não será impressa no terminal serial
e podemos usar ferramentas como ampy.
É altamente recomendável adicionar o acima duas linhas para os do conselho boot.py arquivo para saída de depuração é desativado
permanentemente. Se você não fizer essa alteração, você precisará de saída de depuração desativar manualmente cada vez que você reiniciar a
placa! Com ampy podemos tomar um código MicroPython escrito no PC e executá-lo em uma placa de MicroPython conectado. Isto dá-nos um fluxo
de trabalho simples para explorar MicroPython. Podemos escrever um código no PC em algum editor de texto, em seguida, invocar ampy com o corre
comando para executar o código em uma placa!
Para usar o corre comando, devemos apenas especificar um caminho para um arquivo Python no PC. o ampy
vontade programa
enviar o arquivo para a placa, esperar por ele para concluir a execução, e imprimir qualquer saída do programa. Por exemplo, vamos
colocar a seguinte impressão de código MicroPython ( 'Olá mundo Eu posso contar a 10:') for i in range (1,11):
imprimir (i) no arquivo test.py no PC. Para executar o código dentro deste arquivo no conectado ESP8266 bordo,
devemos abrir a janela de terminal no diretório onde test.py reside e digite o comando:
$ Ampy --port / / porta serial prazo test.py
onde / porta / série é o caminho ou o nome da porta de série ligado à placa MicroPython. No nosso caso, este será / dev /
ttyUSB0. Se você não quiser especificar constantemente a - porta opção, você pode definir o AMPY_PORT
variável de ambiente em sua sessão de terminal. o ampy utilidade vai usar esta variável para ligar a porta série do bordo. Esteja ciente de
que o corre comando não é uma concha ou uma ferramenta que permite que você envie a entrada do seu computador para o conselho!
Se você precisa enviar entrada, você vai querer se conectar à placa e usar a sua REPL serial. Por padrão, o corre comando irá aguardar o
script para concluir a execução na placa antes de imprimir sua saída. Em alguns casos, você não quer esse comportamento, por
exemplo, se o seu script tem um loop principal ou infinito que nunca retorna. Neste caso, adicionar o - sem-saída opção para o corre comando.
Este sinalizador informa ampy não esperar por qualquer saída e simplesmente começar a executar o script e retorno. O exemplo seguinte
ilustra esta abordagem:
tempo de importação
imprimir ( 'Counting ...')
i=1
while True:
imprimir (i)
+i=1
time.sleep (1,0) # Atraso durante 1 segundo.
Salve o código acima MicroPython na test.py arquivo e executar o aplicativo com o - sem-saída
opção como é mostrado abaixo:
$ Ampy --port / série / porta de execução --no-saída test.py A ampy utilitário também pode ser usado
para upload de arquivos para o ESP8266: $ ampy --port / dev / ttyUSB0 blinky.py colocá
Quando precisamos de substituir um arquivo que já existe no ESP8266 (por exemplo, main.py) com algum arquivo (por exemplo, main1.py)
podemos usar o seguinte comando: $ ampy --port / dev / ttyUSB0 colocar /main.py main1.py Para visualizar os arquivos no esp8266
podemos usar o ls comando: $ ampy --port / dev / ls ttyUSB0
Nós também pode baixar o conteúdo do arquivo da placa em algum arquivo no PC. O comando a seguir grava o
conteúdo do arquivo main.py na ESP8266 no arquivo main1.py que será criado no diretório atual:
$ Ampy --port / dev / ttyUSB0 get main.py> main1.py A rm comando permite remover um
arquivo especificado a partir da placa: $ ampy --port / dev / ttyUSB0 rm test.py
A lista de opções suportadas pela ampy utilitário pode ser obtido utilizando a opção de ajuda:
$ Ampy --help
Uso: ampy [opções] comando [ARGS] ... ampy - Adafruit
MicroPython Ferramenta
ampy é uma ferramenta para controlar placas MicroPython através de uma conexão serial. Usando ampy
você pode manipular arquivos no sistema de arquivos interno do conselho e scripts do mesmo executados.
opções:
- p, --port porta Nome da porta serial por placa conectado. Pode, opcionalmente,
especificar com variável de ambiente AMPY_PORT. [requeridos]
- b, --baud taxa de transmissão de bits para a ligação em série (padrão 115200). Pode,
opcionalmente, especificar com variável de ambiente AMPY_BAUD.
- - version Mostra a versão e sai.

- - Socorro Mostra esta mensagem e sai.
Comandos: get
Recuperar um arquivo do tabuleiro. ls

Lista o conteúdo de um diretório no conselho. mkdir
Criar um diretório no tabuleiro. colocar
Colocar um arquivo na placa.
redefinir Execute macio de reset / reboot da placa. rm Remover
um arquivo do tabuleiro. corre Executar um script e imprimir sua
saída.
usando WebREPL
WebREPL permite que você use o prompt Python através de Wi-Fi para estabelecer a conexão com a placa ESP8266 através de um
navegador da Web (as versões mais recentes do Firefox e Chrome são suportados).
Para sua conveniência, o cliente WebREPL está hospedado no http://micropython.org/webrepl . Alternativamente, você
pode instalá-lo localmente a partir do repositório GitHub https://github.com/micropython/webrepl .
Antes de conectar a WebREPL, você deve definir uma senha e ativar a interface através de uma conexão serial normal. As versões
iniciais de MicroPython para ESP8266 veio com WebREPL habilitado automaticamente na inicialização e com a capacidade de
definir uma senha via Wi-Fi na primeira ligação, mas como WebREPL estava se tornando mais amplamente conhecido e popular, a
configuração inicial mudou para um fio conexão para melhorar a segurança.
Depois de ter ligado para o conselho ESP8266 através de uma interface serial, digite o comando:
>>> webrepl_setup importação
Em seguida, deve seguir as instruções na tela e instruções. Por exemplo, no Ubuntu 16.04, podemos ver a seguinte
sequência:
>>> webrepl_setup importação

WebREPL daemon status de auto-start: desativado
Gostaria de (E) nable ou (D) Isable-lo funcionando na inicialização? (Linha vazio para
parar)
> E
Para habilitar WebREPL, você deve definir a senha para ele New
password: password 1234 Confirme: 1234
As alterações serão activadas após a reinicialização Você

gostaria de reiniciar agora? (Y / n)
Depois de premir “ y ”O conselho vai ser reposto. Vamos obter algo semelhante a:
>>>
WebREPL daemon começou no ws: //192.168.4.1: 8266 webrepl iniciado
no modo normal poderia arquivo não aberto 'main.py' para leitura
MicroPython v1.8.6-7-gefd0927 on 2016/11/10; módulo ESP com ESP8266

Type "help ()" para mais informações.
>>>
Para verificar as interfaces de rede, podemos executar a seguinte seqüência digitado na REPL:
> > > rede de importação

> > > sta_if = network.WLAN (network.STA_IF)
> > > ap_if = network.WLAN (network.AP_IF)
> > > sta_if.active ()
Falso
>>> ap_if.active ()
Verdadeiro
> > > ap_if.ifconfig ()
( '192.168.4.1', '255.255.255.0', '192.168.4.1', '208.67.222.222')
> > > sta_if.ifconfig ()
( '0.0.0.0', '0.0.0.0', '0.0.0.0', '208.67.222.222')
>>>
Vê-se que a placa ESP8266 é configurado como um ponto de acesso (AP) com um endereço IP
192.168.4.1 (por padrão). A maioria das configurações (incluindo o meu) usa um autônomo router Wi-Fi configurado AP, enquanto os
outros nós são configurados como estações. Por essa razão, eu reconfigurado ESP8266 para operar como uma estação.
Em tal configuração, o ESP8266 recebe o endereço IP do servidor DHCP rodando em um roteador Wi-Fi (TP-LINK, no meu
caso). A sequência seguinte digitado na REPL foi usado para configurar ESP8266 como uma estação de Wi-Fi:
> > > sta_if.active (True)

# 5 ets_task (4020ed88, 28, 3fff9708, 10)
> > > sta_if.connect ( 'TP-LINK_77D8', 'password') # se conectar à rede Wi-Fi usando um roteador TP- LIGAÇÃO
>>> sta_if.isconnected ()
Verdadeiro
> > > sta_if.ifconfig ()
( '192.168.0.107', '255.255.255.0', '192.168.0.1', '192.168.0.1')
>>>
O último comando, sta_if.ifconfig (), dá-lhe a informação sobre a rede, onde uma placa ESP8266 está
conectado.
Na minha configuração, o endereço IP da estação ESP8266 (192.168.0.107) é retirada de uma piscina reservada de endereços IP
determinados para o servidor DHCP. Usando o desenvolvimento de um endereço IP predeterminado simplifica de aplicações sem fio,
uma vez que o programa não precisa fazer a varredura de uma rede.
Nós podemos facilmente testar se uma interface de rede em ESP8266 é ativado executando um utilitário padrão Linux chamada ping. o sibilo
comando verifica se o nó de rede de destino pode ser alcançado através do envio dos pacotes ICMP. No nosso caso, depois de configurar
ESP8266 podemos testar sua interface de rede da seguinte forma: $ ping 192.168.0.107
PING 192.168.0.101 (192.168.0.107) 56 (84) bytes de dados. 64 bytes de

192.168.0.107: icmp_seq = 1 ttl = 255 = 101 ms de tempo de 64 bytes de
192.168.0.107: icmp_seq = 2 ttl = 255 tempo = 20,0 ms 64 bytes de 192.168.0.107:
icmp_seq = 3 ttl = 255 Tempo = 42,8 ms 64 bytes de 192.168.0.107: icmp_seq = 4 =
255 ttl tempo = 67,8 ms 64 bytes de 192.168.0.107: icmp_seq = 5 ttl = 255 tempo =
87,9 ms 64 bytes de 192.168.0.107: icmp_seq = 6 ttl = 255 tempo = 7,04 ms 64 bytes
de 192.168.0.107: icmp_seq = 7 ttl = 255 tempo = 3,40 ms 64 bytes de 192.168.0.107:
icmp_seq = 8 = 255 ttl tempo = 3,40 ms 64 bytes de 192.168.0.107: icmp_seq = 9 ttl =
255 tempo = 1,81 ms
Duas configurações (um AP e a estação) descritos acima pode ser utilizado para lançar WebREPL. Para testar WebREPL, devemos
lançar digite o seguinte URL em um navegador da Web:
http://micropython.org/webrepl/
Depois WebREPL foi lançado ( Figura 1), devemos introduza o endereço IP de ESP8266 (192.168.0.107, no nosso caso),
deixando a porta (8266) inalterada. Quando terminar, pressione “ Conectar ”.
Figura 1
Se a conexão tiver êxito, devemos ver uma solicitação de senha ( Figura 2).
Figura 2
Uma vez que tenha digitado a senha, pressione Entrar mais uma vez para obter um prompt “>>>” ( Fig.3).
Fig.3
Agora você pode começar a digitar comandos MicroPython como é mostrado na figura acima. Para desconectar-se de WebREPL, você pode
pressionar a tecla “ desconectar ”Botão ( Fig.4).
Fig.4
Para estabelecer automaticamente a ligação à nossa rede Wi-Fi, podemos usar a seguinte função ( Listagem 1): Lista 1.
def do_connect ():

rede de importação
sta_if = network.WLAN (network.STA_IF) se não
sta_if.isconnected ():
imprimir ( 'conexão à rede ...')
sta_if.active (True)
sta_if.connect ( '<essid>', '<password>'), enquanto
não sta_if.isconnected ():
passar
imprimir ( 'configuração de rede:', sta_if.ifconfig ()) O código fonte acima deve ser escrito no boot.py arquivar na
placa esp8266. O exemplo prático do código-fonte para ligar para minha casa rede Wi-Fi é apresentado na
Listagem 2. Este código é colocado no main.py arquivo que é executado após boot.py termina.
Listagem 2.
sta_if = network.WLAN (network.STA_IF) ap_if =
network.WLAN (network.AP_IF)
ap_if.active (False)
se não sta_if.isconnected ():
sta_if.connect ( 'TP-LINK_77D8', 'password') # conectar a minha rede Wi-Fi No meu caso particular, uma
estação esp8266 será atribuído o endereço IP 192.168.0.107 em uma rede 192.168.0.0.
As seções seguintes descrevem os conceitos básicos de construção de vários sistemas de rede sem fio para medição e
controle usando a placa ESP8266 (nodemcu).
Programação sistemas de rede sem fio com ESP8266
Pode haver uma série de métodos para sistemas de medição de configurar e programa de rede Wi-Fi. Geralmente, as aplicações de
rede sem fio usar a configuração “cliente-servidor”, que é amplamente utilizado em redes com fio.
Quando executado, o aplicativo de rede pode funcionar como um "servidor" ou como um "cliente". Muitas vezes, um aplicativo de rede é
desenvolvida para operar em ambos os modos, dependendo de algumas condições pré-determinadas. O diagrama de blocos na Fig.5 ilustra
a configuração básica “cliente-servidor".
Fig.5
Aqui você pode ver uma interação entre três aplicações de rede (um servidor TCP e dois clientes TCP). O servidor TCP é atribuído
o endereço IP 192.168.0.100 e porta 8089 - esses parâmetros da rede são usadas para esperando para receber os pedidos de
clientes TCP. Vamos supor que o TCP Cliente 1 em execução em algumas tentativas de nó de rede para se conectar ao TCP
Server em execução no outro nó. Inicialmente, os TCP Cliente 1 coloca uma solicitação para o servidor TCP utilizando os
parâmetros básicos de rede (192.168.0.100: 8089). O TCP Server descobre este pedido e cria uma conexão de trabalho ( “socket
de trabalho”) para o TCP cliente 1. Além disso, o

TCP Server especifica os parâmetros da conexão de trabalho (endereço IP = 192.168.0.100 e portuárias = 47901) e
passa-los para o TCP Cliente 1.
A transferência de dados entre o servidor TCP e TCP Cliente 1 será realizada utilizando esta tomada de trabalho que tem que ser
fechada após as operações foram concluídos.
Mais uma vez, quando o TCP Cliente conexão 2 estabelece que o TCP Server, a nova conexão de trabalho com um endereço IP
192.168.0.100 e porta 48344 é criado. Nota, que o "socket de escuta" usando a porta 8089 do TCP Server serve apenas para
estabelecer a comunicação entre os clientes TCP Server e TCP. Esta tomada só escuta para solicitações de entrada de clientes
TCP e as forças do TCP Server para criar uma nova conexão de trabalho, se necessário. Quando o TCP Server termina ele tem
que fechar o socket "escuta". Uma vez que um canal de comunicação foi criado, os dados podem ser transferidos em ambas as
direções entre um servidor TCP e TCP Cliente Isso depende principalmente em um algoritmo de controle.
Ao projetar o sistema de rede Wi-Fi mais simples, precisamos de pelo menos um servidor TCP e um TCP Cliente. Neste
caso, uma placa Wi-Fi pode ser “TCP Server” ou “TCP Client”. Em configurações mais complicadas, o código de programa
em execução na placa Wi-Fi pode executar tanto TCP servidor e cliente TCP.
Neste guia, vamos considerar as configurações mais simples, onde placas Wi-Fi será executado apenas um servidor TCP ou TCP
cliente de cada vez.
As seções seguintes descrevem projetos práticos de sistemas de medição e controlo sem fios simples.
Condução saídas digitais: projeto 1
Este projeto ilustra a concepção de um sistema de controle sem fio simples que irá conduzir GPIO5 e
GPIO16 pins de nodemcu ON / OFF do PC. Neste sistema, o aplicativo de servidor TCP está em execução no ESP8266 bordo
remoto, enquanto um cliente TCP está em execução no PC. o GPIO16 pin impulsiona o LED on-board que está ligado a + 3.3V
através de um resistor pull-up. o
GPIO5 pino acciona o diodo emissor de luz ligado a ESP8266 através da resistência R1 como é mostrado na Fig.6.
Fig.6
O código-fonte MicroPython do servidor TCP é mostrado na Listagem 3. Listagem 3.
tempo de importação
tomada importação
máquina de importação

network.WLAN (network.AP_IF) ap_if.active (Falso)

sta_if.connect ( 'TP-LINK_77D8', 'password') # ligar para o meu time.sleep rede Wi-Fi (2)
# criar um objeto de soquete

socketServidor = socket.socket (socket.AF_INET, socket.SOCK_STREAM) hospedeira =
'192.168.0.107' = 55000 porta

# ligam-se à porta
serverSocket.bind ((host, port))
# fila para 5 pedidos
serverSocket.listen (5) while
True:
# estabelecer uma conexão
clientSocket, addr = serverSocket.accept () sRecv =
clientSocket.recv (128) sASCII = sRecv.decode ( 'UTF-8')
sParam = sASCII.split (' ') se sParam [0] == 'GPOUT':
pino = int (sParam [1]) val =

int (sParam [2])
levou = machine.Pin (pino, machine.Pin.OUT) led.value
(Val)
clientSocket.send (sRecv)
clientSocket.close ()
Neste código de fonte, a sequência


sta_if.connect ( 'TP-LINK_77D8', 'password')
Coloca o nodemcu em modo “estação” e estabelece a ligação à rede Wi-Fi. Uma vez que a placa está ligado ao
Wi-Fi, a interface de rede de nodemcu é atribuído o endereço IP
192.168.0.107. Este endereço será utilizado para configurar o TCP Server. A sequência

'192.168.0.107' = 55000 porta

serverSocket.listen (5)
cria o objeto servidor socket serverSocket associado ao servidor O TCP IP-address 192.1168.0.107 e porta 55000. vai
esperar para receber os pedidos (max = 5) neste socket. As solicitações do cliente são processados na interminável enquanto
ciclo. Após a conexão do cliente é
aceito, o novo “trabalho” socket é criado pelo comando: clientSocket, addr
= serverSocket.accept ()
Todas as operações com o cliente será então realizada utilizando o clientSocket socket. No nosso caso, o clientSocket recebe a
seqüência de comandos a partir do cliente TCP e salva os dados na variável de seqüência aASCII:
sRecv = clientSocket.recv (128) sASCII = sRecv.decode ( 'UTF-8') A sequência que se segue analisa o sASCII corda, determina o pino
de unidade (o PIN variável), em seguida, determina o valor de escrever para este pino (o val variável). O pino de accionamento é mantida
no conduziu
variável. Finalmente, o valor val será escrito para o pino pela led.value () função.
sParam = sASCII.split (' ') se

sParam [0] == 'GPOUT':
pino = int (sParam [1]) val =
int (sParam [2])
(Val)
O código-fonte Python do TCP Cliente ( TCPClient.py) em execução no PC é mostrada na Listagem

4.
Listagem 4.
import sys tomada

de importação
se (len (sys.argv) == 4):
GPIO = str (sys.argv [1]) = pino
str (sys.argv [2]) do estado str =
(sys.argv [3])
cmd = GPIO + '' + pino + '' + estado
s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) hospedeira = "192.168.0.107";

# Endereço IP do servidor TCP da porta nodemcu = 55000
# ligação ao nome de host na porta.

s.connect ((host, port))
s.send (cmd.encode ( 'utf8')) # utf8 codificação é usado
sRecv = s.recv (128)
s.close ()
imprimir ( 'eco recebido:' + sRecv.decode ( 'utf8'))
Para configurar o nosso sistema, devemos baixar o código fonte de um servidor TCP em ESP8266 usando o ampy utilitário:
$ Ampy --port / dev / ttyUSB0 colocar TCPServer.py /main.py No comando acima, o arquivo TCPServer.py contém o
código-fonte apresentado na Listagem 4.

Em seguida, reiniciar a placa ESP8266 e testá-lo. Ao testar o TCP Server, que irá conduzir pins GPIO16 e GPIO5 na
placa esp8266.
GPIO16 está ligado ao LED on-board com um resistor pull-up e GPIO5 está ligado ao nosso LED (ver Fig.6). Para conduzir
os dois pinos ON / OFF podemos usar os seguintes comandos em execução no comando Ubuntu prompt: $ python
TCPClient.py GPOUT 5 1 eco recebido: GPOUT 5 1 $ python TCPClient.py GPOUT 16 0 eco recebido: GPOUT 16 0 $
python TCPClient.py GPOUT 5 0 eco recebido: GPOUT 5 0 $ python TCPClient.py GPOUT 16 1 eco recebido: GPOUT
16 1
Nota que o LED no pino GPIO16 é ON quando o pino é baixo e OFF quando GPIO16 é alto.
Condução saídas digitais: Projeto 2
Neste projeto, o TCP Server é lançado em ESP8266 pela ampy utilidade. o main.py arquivo no diretório raiz do ESP8266
deve conter apenas o código para inicializar interface de Wi-Fi ( Listagem 5).
Listagem 5.


sta_if.connect ( 'TP-LINK_77D8', 'password') # conectar a minha rede Wi-Fi
O código-fonte MicroPython da aplicação TCP Server é mostrado na Listagem 6. Listagem 6.
soquete importação
máquina importação

socketServidor = socket.socket (socket.AF_INET, socket.SOCK_STREAM)
Host = '192.168.0.107' =
55000 porta
# ligam-se à porta
# a fila até 5 pedidos

while True:
sParam = sASCII.split (' ') se sParam [0] == 'GPOUT':
pino = int (sParam [1])

val = int (sParam [2])
(Val)
clientSocket.send (sRecv)
Depois de guardar o código de cima no TCPServer.py arquivo, o aplicativo pode ser lançado na placa ESP8266 invocando
o ampy utilitário: $ ampy --port / dev / ttyUSB0 executar TCPServer.py
O código-fonte do TCP cliente é a mesma que no projeto anterior. Nota que depois de sair da aplicação TCP Server
(pressionando Ctrl-C), você deve reiniciar a placa esp8266 antes de executar a mesma aplicação mais uma vez. Caso
contrário, você vai ter uma EADDRINUSE
mensagem de erro tal como é mostrado abaixo:
$ Ampy --port / dev / ttyUSB0 executar mainTCPServer_GPOUT2.py ^ C
Abortado!
$ Ampy --port / dev / ttyUSB0 executar mainTCPServer_GPOUT2.py
. . .
\ NOSError: [Errno 98] EADDRINUSE \ r \ n ')
Condução saídas digitais: projeto 3

Este projeto ilustra como implementar condução pinos GPIO de ESP8266 através da interface WebREPL. Neste caso, o
código-fonte do TCP Server pode ser digitado e executado dentro de uma janela WebREPL como é mostrado abaixo:
>>> tomada de importação

>>> s = socket.socket (socket.AF_INET, socket.SOCK_STREAM)
>>> host = '192.168.0.107'
>>> porto = 55000
>>> s.bind ((host, port))
>>> s.listen (5)
>>> while True:
... Cl, addr = s.accept ()
... sRecv = cl.recv (128)
... sASCII = sRecv.decode ( 'UTF-8')
... sParam = sASCII.split (' ')
... se sParam [0] == 'GPOUT':
... pino = int (sParam [1])
... val = int (sParam [2])
... levou = machine.Pin (pino, machine.Pin.OUT)
... led.value (Val)
... cl.send (sRecv)
... cl.close ()
...
PWM programação
Este projecto ilustra a configuração do ciclo de serviço de um sinal PWM no pino GPIO5 do conselho esp8266.
O código-fonte MicroPython do TCP Server que será executado em ESP8266 é mostrado na Listagem 7. Listagem 7.
de importação máquina Pin, PWM tempo de

importação tomada importação rede de
importação


sta_if.connect ( 'TP-LINK_77D8', 'palavra-passe') time.sleep
(2)
pwm5 = PWM (pino (5), freq = 500, dever = 512)

'192.168.0.107' = 55000 porta
# ligam-se à porta
True:
sParam = sASCII.split (' ') se sParam [0] == 'PWM':
pwmPin = int (sParam [1])
dutycycle = int (sParam [2])
pwm5 = PWM (Pin (pwmPin), freq = 500, dever = dutycycle)
clientSocket.send (sRecv) clientSocket.close ()
Neste código de fonte, a sequência


sta_if.connect ( 'TP-LINK_77D8', 'password') # conectar aos meus puts rede Wi-Fi do nodemcu no modo
“estação” e estabelece a ligação à rede Wi-Fi. Uma vez que a placa está ligado ao Wi-Fi, a interface de rede de
nodemcu é atribuído o endereço IP 192.168.0.107. Este endereço será utilizado para configurar o TCP Server.
A sequência

'192.168.0.107' = 55000 porta

cria o objeto servidor socket serverSocket associado ao servidor O TCP IP-address 192.1168.0.107 e porta
55000. vai esperar para receber os pedidos (max = 5) neste ( “escuta”) socket.
As solicitações do cliente são processados na interminável enquanto ciclo. Após a conexão do cliente for aceite, o
novo socket “trabalho” é criado pelo comando: clientSocket, addr = serverSocket.accept ()
Todas as operações com o cliente será então realizada utilizando o clientSocket socket. No nosso caso, o clientSocket recebe a
seqüência de comandos a partir do cliente TCP e salva os dados na variável de seqüência aASCII:
sRecv = clientSocket.recv (128) sASCII = sRecv.decode ( 'UTF-8') A sequência que se segue analisa o sASCII corda,
determina a saída para a unidade (o pwmPin
variável), em seguida, determina o ciclo de serviço para ser escrito para este pino (o dutycycle variável). o
pino de accionamento é mantida no pwm5 variável. Finalmente, o valor de dutycycle será escrito para o pino chamando o PWM
() função. sParam = sASCII.split (' ')
se sParam [0] == 'PWM':

pwmPin = int (sParam [1])
dutycycle = int (sParam [2])
pwm5 = PWM (Pin (pwmPin), freq = 500, dever = dutycycle)
O código-fonte Python da aplicação TCP Cliente em execução no Ubuntu é mostrado na Listagem 8. Listagem 8.
import sys tomada

de importação
PWM = str (sys.argv [1]) = pino
str (sys.argv [2]) dever = str
(sys.argv [3])
cmd = PWM + '' + pin + '' + dever


s.send (cmd.encode ( 'UTF-8')) # UTF-8 codificação é utilizado sRecv =
s.recv (128)
s.close ()
imprimir ( 'eco recebido:' + sRecv.decode ( 'utf8'))
sinais analógicos de Leitura: um projecto
Este projecto ilustra a medição de um sinal analógico no pino A0 de ESP8266 e transferir os dados obtidos para um cliente TCP
remoto. Para testar uma aplicação, utilizamos o circuito mostrado nas Fig.7.
Fig.7
Neste circuito, o sinal analógico no pino A0 é simulada pelo divisor de tensão dispostas usando resistência R1 e R2
potenciómetro. Note-se que a tensão analógica no pino A0 de esp8266 não deve ser superior a 1,0 V!
O código-fonte MicroPython do aplicativo em execução TCP Server em ESP8266 é mostrado na

Listagem 9.
Lista 9.
da máquina de importação ADC tempo

de importação tomada importação rede
de importação


LSB = 3,3 / 1024 # LSB para adc ADC =
ADC (0) # ADC objecto

'192.168.0.101' = 55000 porta
# ligam-se à porta
True:
clientSocket.recv (128) .decode ( 'UTF-8') se sRecv ==
'ADC0':
Dn = adc.read () vin
= LSB * Dn
Svin =. "{:} .3f" formato (vin) else:
Svin = 'parâmetro errado.'

clientSocket.send (Svin)
Neste código fonte, o código binário correspondente à tensão de entrada analógica no pino A0 é tomada pelo adc.read () comando
O valor do código é salvo no Dn variável. A tensão real é representada como um valor flutuador e é mantido no vin variável. A
corda Svin contém a representação de texto vin. Essa seqüência é então enviada para a remota TCP cliente chamando o
clientSocket.send (Svin) função. O código-fonte Python de um cliente TCP ( TCPClient.py) em execução no PC é mostrada na Listage
10.
Listagem 10.
import sys tomada

de importação
adc = str (sys.argv [1])

s.send (adc.encode ( 'UTF-8')) # UTF-8 codificação é utilizado sRecv =
s.recv (128)
s.close ()
imprimir ( 'Vin em A0, V:' + sRecv.decode ( 'UTF-8'))
O seguinte linha de comando permite receber dados do TCP Server: $ python
TCPClient.py ADC0 Vin em A0, V: 0,387
$ Python TCPClient.py ADC0 Vin em

A0, V: 0,441
$ Python TCPClient.py ADC2 Vin em A0,
V: parâmetro errado. $ Python
TCPClient.py ADC0 Vin em A0, V: 0,690
sinais analógicos de Leitura: 2 projecto
Esta é uma versão modificada do projeto anterior. Aqui o aplicativo é executado servidor TCP no PC, enquanto o
aplicativo TCP Cliente correndo na placa ESP8266 mede periodicamente a tensão analógica no pino A0 e envia o
resultado para o servidor TCP remoto. O código-fonte MicroPython do cliente TCP correndo na placa ESP8266 é
mostrado na
Listagem 11.
Listagem 11.
da máquina de importação ADC tomada

de importação tempo de importação

ADC (0) # ADC objecto
host = "192.168.0.100" #O IP-endereço da porta PC =

55000 cnt = 0
enquanto cnt <15:

sClient = socket.socket (socket.AF_INET, socket.SOCK_STREAM)
sClient.connect ((host, port)) Dn = adc.read ()
Vin = LSB * Dn
sClient.send ((str (CNT + 1) + ': tensão no pino A0, V =' +

'{:} .3f'.. Formato (vin)) codificar ( 'UTF-8')) # UTF-8 codificação é utilizado sClient.close
() time.sleep (10) CNT + 1 =
Neste código-fonte, o código do programa dentro de um enquanto() ciclo repete-se até um contador cnt alcances
15.
Este código pode ser inserido no main.py arquivo para executar enquanto ESP8266 é ligado ou reiniciado. Neste exemplo, o código
acima é colocado no TCPClient.py arquivo e começa a correr na placa ESP8266 usando a ampy comando:
$ Ampy --port / dev / ttyUSB0 executar TCPClient.py

O TCP Server ( TCPServer.py) em execução no PC recebe os resultados das medições. código-fonte do servidor é
mostrado na Listagem 12. Listagem 12.
tomada de importação

"192.168.0.100" port = 55000
# ligam-se à porta

print ( "aguarda TCP Server para solicitações de entrada na
192.168.0.100:55000 ... ") try:
while True:
clientSocket.recv (256) clientSocket.close () print
(sRecv.decode ( 'utf8')), exceto KeyboardInterrupt:
serverSocket.close ()
imprimir ( 'TCP Server está sendo desligado ...')
A aplicação de servidor TCP produz o seguinte resultado: $ python
TCPServer.py
Servidor TCP espera para receber os pedidos em 192.168.0.100:55000 ... 1: tensão no
pino A0, V = 0,135 2: tensão no pino A0, V = 0,168 3: tensão no pino A0, V = 0,873 4:
tensão no pino A0, V = 0,725 5: tensão no pino A0, V = 0,738 6: tensão no pino A0, V =
0,206 7: tensão no pino A0, V = 0,200 8: tensão no pino A0, V = 0,429
9: tensão no pino A0, V = 0,487 10:
tensão no pino A0, V = 0,503 11: tensão
no pino A0, V = 0,699 12: tensão no pino
A0, V = 0,960 13: tensão no pino A0, V =
0,951 14: tensão no pino A0, V = 0,970
15: tensão no pino A0, V = 0,983
Lendo os sinais analógicos usando um servidor Web
Este projecto ilustra a medição da tensão de entrada analógica no pino A0 de ESP8266 usando um simples servidor HTTP (Web) em
execução no tabuleiro. Podemos ler o valor de um sinal de entrada analógico, inserindo um par endereço IP / porta no campo de endereço
do navegador da Web em execução em algum lugar em uma rede.
Nessas configurações, a placa Wi-Fi funciona um servidor Web (HTTP), que é um caso especial de um servidor TCP, porque um protocolo HTTP é
baseado em um conjunto de protocolos TCP. Um navegador da Web (Google Chrome, no nosso exemplo) vai enviar / receber dados de / para um
servidor HTTP. Na verdade, um navegador da Web é um cliente TCP que envia pedidos baseados em especificações do protocolo HTTP para o
servidor HTTP. Usando um navegador da Web economiza muito tempo, especialmente em sistemas sem fio simples, uma vez que não precisa
escrever qualquer código fonte do cliente mais.
Nós não irá considerar o protocolo HTTP em profundidade; você pode encontrar vários documentos, literatura e tutoriais sobre
este assunto na Internet. Nós só irá discutir aspectos práticos da concepção de "Web (HTTP) - navegador Web" sistemas sem
fio de rede usando nodemcu eo PC. Uma configuração de rede muito simples é mostrada na Fig.8.
Fig.8
No acima configuração de rede Wi-Fi, o conselho nodemcu Wi-Fi funciona um servidor Web (HTTP), enquanto o PC desktop /
notebook executa o navegador Web. O código-fonte MicroPython do HTTP Server é mostrado na Listagem 13. Listagem 13.
de importação máquina Pin
importação tomada pinNum = [5,4,0]
pinos = [ 'pin5', 'pin4', 'pin0'] estado =
[0,0,0] para i no intervalo (0,3):
pinos [i] = Pin (pinNum [i], Pin.IN, Pin.PULL_UP)

addr = ( '192.168.0.107', 8081)
socketServidor = socket.socket (socket.AF_INET, socket.SOCK_STREAM) serverSocket.bind (addr)
serverSocket.listen (3) enquanto Verdadeiro:
cl, addr = serverSocket.accept () cl_file =

cl.makefile ( 'rwb', 0) while True:
A linha = cl_file.readline () se não linha

ou linha == b '\ r \ n':
ruptura
SINP = ''
para i no intervalo (0,3):
Estado [i] = pinos [i] .value () SINP +
= str (estado [i])
# Prepare a resposta
response = 'HTTP / 1.1 200 OK \ r \ nContent-Type: text / html \ r \ n \ r \ n' <! DOCTYPE
html> resposta + = "" "<html> <body>
<H3> Estado de esp8266 Pinos [5: 4: 0] = [% s] </ h3> </ body>
</ Html> \ n """ % SINP
# Enviar a resposta para o cliente

cl.send (resposta)
cl.close ()
Salvar o código acima na HTTPServer.py arquivo e iniciar a aplicação invocando a ampy

utilidade como é mostrado abaixo:
$ Ampy --port / dev / ttyUSB0 executar HTTPServer.py Para ler a entrada A0 na ESP8266 bordo remoto, devemos entrar
“192.168.0.107:8081” no campo de endereço de um navegador da Web. Isto é ilustrado na Fig.9.

Fig.9
Alternativamente, podemos colocar o código fonte do Servidor HTTP no main.py arquivo e gravar o arquivo na memória
flash de esp8266. Neste caso, o código fonte MicroPython do main.py
arquivo na placa ESP8266 será parecido com o seguinte ( Listagem 14). Listagem 14.
da máquina de importação ADC tomada

de importação tempo de importação rede
de importação


ADC (0) # ADC objeto addr = (
'192.168.0.107', 8081)


quebrar
Dn = adc.read () vin
= LSB * Dn
Svin = "{:} .3f" formato (vin).
<H3> tensão no pino A0 =% sV </ h3> </ corpo>
</ Html> \ n """ % Svin

cl.send (resposta)
cl.close ()
Para reescrever a main.py arquivo no diretório raiz do ESP8266, podemos usar o ampy utilidade como é mostrado abaixo:
$ Ampy --port / dev / ttyUSB0 colocar HTTPServer.py /main.py Após reset, o servidor
HTTP inicia a execução na placa esp8266.

Lendo entradas digitais: projeto 1
Este projeto ilustra como ler sinais digitais nos pinos de entrada do conselho esp8266. Neste sistema, a aplicação
TCP Server é executado no nodemcu. O servidor lê pins GPIO5 ( “5”),
GPIO4 ( “4”) e GPIO0 ( “0”) configurado como entradas digitais com resistências pull-up. Para testar esta aplicação, que pode alimentar
sinais digitais para esses pinos como é mostrado na Fig.10.
Fig.10
O código-fonte MicroPython do TCP Server é mostrado na Listagem 15. Listagem 15.
de importação máquina de rede de

importação Pin socket tempo de
importação de importação


pinNum = [5,4,0]
pinos = [ 'pin5', 'pin4', 'pin0'] estado

= [0,0,0]
pinos [i] = Pin (pinNum [i], Pin.IN, Pin.PULL_UP)

'192.168.0.101' = 55000 porta
# ligam-se à porta
True:
se sASCII == 'GPIN':
S1 = ''
para i no intervalo (0,3): estado [i] =
pinos [i] .value () s1 + = str (estado
[i])
clientSocket.send (s1.encode ( 'utf8')) clientSocket.close () Salvar este código-fonte em TCPServer.py e reescrever o main.py
arquivo no diretório raiz do sistema de arquivos usando o MicroPython ampy utilitário: $ ampy --port / dev / ttyUSB0 colocar
TCPServer.py /main.py Para iniciar o aplicativo, você deve reiniciar a placa esp8266.
O código-fonte Python da aplicação cliente TCP em execução no PC é mostrada na Listagem 16. Listagem 16.
import sys tomada

de importação
adc = str (sys.argv [1])

s.send (adc.encode ( 'UTF-8')) # UTF-8 codificação é utilizado sRecv =
s.recv (512)
s.close ()
imprimir ( 'Entradas [5-4-0] = [' + sRecv.decode ( 'utf8') + ']') Guardar o código acima na TCPClient.py Arquivo. A linha de
comando e saída produzida pela aplicação TCP Cliente é mostrado abaixo (o TCP Server em esp8266 já deve estar em
execução): $ python TCPClient.py GPIN Entradas [5-4-0] = [101]
$ python TCPClient.py GPIN Entradas

[5-4-0] = [100]
$ python TCPClient.py GPIN Entradas
[5-4-0] = [010]
Lendo entradas digitais: Projeto 2
Neste projeto, a leitura das entradas digitais 5-4-0 do conselho esp8266 é realizada por um cliente TCP que periodicamente (a cada
5 s) envia dados obtidos a um TCP Server em execução no PC com um endereço IP 192.168.0.100. O servidor aguarda TCP para
solicitações de entrada na porta 55000. O Python código-fonte do TCP Server ( TCPServer.py) é mostrada em Listagem 17.
Listagem 17.
tomada de importação
"192.168.0.100" port = 55000
# ligam-se à porta

print ( "aguarda TCP Server para solicitações de entrada na
192.168.0.100:55000 ... ") try:
while True:
clientSocket.recv (512) clientSocket.close ()
imprimir ( 'Entradas [5-4-0] = [' + sRecv.decode ( 'utf8') + ']'), exceto

KeyboardInterrupt:
serverSocket.close ()
imprimir ( 'TCP Server está sendo desligado ...') O código fonte MicroPython do TCP Cliente ( TCPClient.py) que deve ser
executado no tabuleiro ESP8266 é mostrado na Listagem 18. Listagem 18.
de importação máquina Pin tempo de

importação tomada importação
pinNum = [5,4,0]
pinos [i] = Pin (pinNum [i], Pin.IN, Pin.PULL_UP) hospedeira =
'192.168.0.100' porto = 55000 = 0 CNT
enquanto cnt <10: # 10 medições

clientSocket = socket.socket (socket.AF_INET, socket.SOCK_STREAM)

clientSocket.connect ((host, port)) s1 = ''

Estado [i] = pinos [i] .value () s1 + =
str (estado [i])
clientSocket.send (s1.encode ( 'UTF-8'))
clientSocket.close () time.sleep (5) CNT + 1 =
Para testar este sistema, devemos primeiro lançar o TCP Server no PC, em seguida, executar o TCP Cliente no ESP8266
executando o ampy comando: $ ampy --port / dev / ttyUSB0 executar mainTCPClient.py O TCP Server irá produzir o seguinte
resultado: $ python TCPServer.py
TCP Server aguarda solicitações de entrada em ... Entradas [5-4-0] = [011] Entradas [5-4-0] =
[011] Entradas [5-4-0] = [011 192.168.0.100:55000 ] Entradas [5-4-0] = [011] Entradas [5-4-0] =
[010] Entradas [5-4-0] = [010] Entradas [5-4-0] = [110] Entradas [5-4-0] = [110] Entradas [5-4-0]
= [100]
Entradas [5-4-0] = [100]
entradas [5-4-0] = [100]
Lendo entradas digitais usando um servidor Web
É possível ler pinos de entrada digitais 5,4 e 0, utilizando um servidor HTTP (Web) que corre na placa esp8266 com um endereço
IP 192.168.0.107. O servidor HTTP espera para solicitações de entrada na porta 8080.
O código-fonte MicroPython do servidor HTTP ( HTTPServer.py) é mostrada em Listagem 19. Listagem 19.
de importação máquina Pin
importação tomada pinNum = [5,4,0]
pinos [i] = Pin (pinNum [i], Pin.IN, Pin.PULL_UP) addr = (
'192.168.0.107', 8080)


ruptura
SINP = ''
= str (estado [i])
<H3> Estado de esp8266 Pinos [5: 4: 0] = [% s] </ h3>

</ Body>
</ Html> \ n """ % SINP

cl.send (resposta)
cl.close ()
Para iniciar HTTP Server em ESP8266, devemos usar o ampy utilidade como é mostrado abaixo: $ ampy --port / dev /
ttyUSB0 executar HTTPServer.py
Nota que se você terminar este aplicativo pressionando Ctrl-C, é preciso reiniciar a placa ESP8266 antes de lançar
o servidor HTTP mais uma vez. O navegador da Web fornece a seguinte saída ( Fig.11).
Fig.11
É possível colocar o código fonte do Servidor HTTP ( HTTPServer.py) no main.py arquivo no diretório raiz de um sistema de arquivos
MicroPython para que o nosso servidor irá começar cada vez que o conselho ESP8266 é alimentado / reset.
O código-fonte MicroPython do HTTP Server será parecido com o seguinte ( Listagem 20). Listagem 20.
de importação máquina Pin soquete

importação tempo de importação rede
de importação

sta_if.connect ( 'TP-LINK_77D8', 'password') #CONNECT para minha casa Wi-Fi time.sleep rede (2)
pinNum = [5,4,0]
pinos [i] = Pin (pinNum [i], Pin.IN, Pin.PULL_UP) addr = (
'192.168.0.107', 8080)


ruptura
SINP = ''
= str (estado [i])
<H3> Estado de esp8266 Pinos [5: 4: 0] = [% s] </ h3> </ body>
</ Html> \ n """ % SINP

cl.send (resposta)
cl.close ()
Escrever este arquivo para ESP8266 pode ser realizado pela ampy Programa: $ ampy --port / dev /
ttyUSB0 colocar HTTPServer.py /main.py
Após a escrita for concluída, reiniciar a placa ESP8266 para iniciar o servidor HTTP.

Programmig Esp8266-Based Wireless Syste in MicroPython - En.pt

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Programmig Esp8266-Based Wireless Syste in MicroPython - En.pt

Enviado por

Direitos autorais:

Formatos disponíveis

Programação ESP8266 baseada em

Sistemas sem fio em

Por Yury Magda

Copyright © 2017 por Yury Magda. Todos os direitos reservados.

sistema de arquivos na placa ESP8266 Usando WebREPL

Programação de sistemas de rede sem fio com saídas digitais ESP8266

Lendo os sinais analógicos de projecto: 1 os sinais

analógicos de Leitura: 2 projecto

Lendo os sinais analógicos usando um entradas digitais

na janela Terminal: $ ls -l / dev / ttyU *

$ Esptool.py --port / dev / ttyUSB0 erase_flash esptool.py

Correndo Cesanta pisca-pisca toco ... Apagar Flash

ttyUSB0 --baud 460.800 write_flash --flash_size = detectar 0 esp8266- 20161110-v1.8.6.bin

No meu caso, o comando produziu o seguinte resultado:

No Ubuntu 16.04, tela é lançado pela entrada: $ tela / dev /

> > > máquina de importação

execute os seguintes comandos: import esp

comando para executar o código em uma placa!

$ Ampy --port / / porta serial prazo test.py

ilustra esta abordagem:

podemos usar o ls comando: $ ampy --port / dev / ls ttyUSB0

arquivo especificado a partir da placa: $ ampy --port / dev / ttyUSB0 rm test.py

- - version Mostra a versão e sai.

Recuperar um arquivo do tabuleiro. ls

>>> webrepl_setup importação

>>> webrepl_setup importação

As alterações serão activadas após a reinicialização Você

MicroPython v1.8.6-7-gefd0927 on 2016/11/10; módulo ESP com ESP8266

> > > rede de importação

> > > sta_if.active (True)

PING 192.168.0.101 (192.168.0.107) 56 (84) bytes de dados. 64 bytes de

def do_connect ():

estação esp8266 será atribuído o endereço IP 192.168.0.107 em uma rede 192.168.0.0.

de trabalho”) para o TCP cliente 1. Além disso, o

O código-fonte MicroPython do servidor TCP é mostrado na Listagem 3. Listagem 3.

sta_if = network.WLAN (network.STA_IF) ap_if =

se não sta_if.isconnected ():

# criar um objeto de soquete

'192.168.0.107' = 55000 porta

# fila para 5 pedidos

serverSocket.listen (5) while

pino = int (sParam [1]) val =

Neste código de fonte, a sequência

sta_if = network.WLAN (network.STA_IF) ap_if =

se não sta_if.isconnected ():

socketServidor = socket.socket (socket.AF_INET, socket.SOCK_STREAM) hospedeira =

serverSocket.bind ((host, port))

sParam = sASCII.split (' ') se

O código-fonte Python do TCP Cliente ( TCPClient.py) em execução no PC é mostrada na Listagem

import sys tomada

s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) hospedeira = "192.168.0.107";

# ligação ao nome de host na porta.

código-fonte apresentado na Listagem 4.

sta_if = network.WLAN (network.STA_IF) ap_if =

se não sta_if.isconnected ():

O código-fonte MicroPython da aplicação TCP Server é mostrado na Listagem 6. Listagem 6.

# criar um objeto de soquete

# a fila até 5 pedidos

pino = int (sParam [1])

o ampy utilitário: $ ampy --port / dev / ttyUSB0 executar TCPServer.py

$ Ampy --port / dev / ttyUSB0 executar mainTCPServer_GPOUT2.py ^ C

$ Ampy --port / dev / ttyUSB0 executar mainTCPServer_GPOUT2.py

\ NOSError: [Errno 98] EADDRINUSE \ r \ n ')