Flash ESP-01 (ESP8266) sem adaptador USB para serial usando Raspberry Pi: 3 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

Este Instructable o orienta sobre como começar a programar seu microcontrolador ESP8266 em um módulo WIFI ESP-01. Tudo que você precisa para começar (além do módulo ESP-01, é claro) é

• Raspberry Pi
• Fios de ligação
• Resistor de 10K

Eu queria reformar uma lâmpada de cabeceira velha em uma lâmpada noturna LED moderna controlada por Alexa. Nada extravagante apenas ligando / desligando usando o comando de voz. Encomendei online o módulo WIFI mais simples do ESP-01, relé e fio com LEDs, e esqueci totalmente de pedir o adaptador USB para serial para programar o microcontrolador ESP8266. Mas como eu tinha um Raspberry Pi e tanto o Raspberry Pi quanto a placa ESP-01 tinham pinos UART, concluí que poderia usar meu RPi para programar ESP8266 sem o adaptador.

Etapa 1: Configurar Rapberry Pi

Usei Raspberry Pi 3 Modelo B +, no entanto, as instruções devem funcionar em outras versões, especialmente no modelo B.

Portanto, comecemos pelo princípio - precisamos habilitar o UART no Pi.

Definições de configuração do Go RPi. Na janela do terminal, execute

$ sudo raspi-config

Vá para 5 Opções de interface e selecione P6 Serial. Em seguida, você perguntou Deseja que um shell de login seja acessível via serial? selecione uma vez que não queremos usar o UART para executar o Pi sem cabeça, mas para se comunicar com outros dispositivos, portanto, na tela a seguir quando perguntado Deseja que o hardware da porta serial seja habilitado? selecione. Reinicie o Pi conforme solicitado. O UART agora deve estar habilitado para comunicação serial no pino RX e TX do Raspberry Pi 3. Nota: após isso deve aparecer uma nova entrada enable_uart = 1 no final de /boot/config.txt.

Etapa 2: conecte o ESP-01 ao Raspberry Pi

Agora vamos começar a conectar tudo.

Em primeiro lugar, identifique em seu RPi 3,3V os pinos de alimentação e GND (aterramento) para alimentar o microcontrolador ESP8266, os pinos TXD (transmitir) e RXD (receber) para se comunicar e dois pinos de uso geral para operar o ESP8266 (pinos que podem ser definidos altos ou baixo). Procure a disposição dos pinos em pinout.xyz ou digite o terminal:

$ pinagem

Em segundo lugar, identifique os pinos necessários no ESP-01. Mas, no início, precisamos ter conhecimento dos pinos ESP-01. Encontrei vários recursos úteis disponíveis na Internet para ajudá-lo nesse sentido. Este é o mais curto, enquanto este dá uma explicação muito melhor. Resumindo: Existem 8 pinos, vamos precisar de 7 deles, nomeadamente pinos de alimentação VCC e GND (terra) para alimentação, pinos TXD e RXD para comunicação e RST (reinicialização), CH_PD (Chip Power Down, às vezes rotulado CH_EN ou chip enable) e GPIO0 para operar o módulo. Normalmente, o ESP8266 opera em um modo normal, mas ao enviar um código para o ESP8266, ele deve estar no modo flash. Para o modo de operação normal ou normal, o módulo precisa ser conectado à alimentação (obviamente), mas também o pino CH_PD deve ser conectado ao VCC por meio de um pull-up de 10K (este valor varia em recursos diferentes, encontrei valores abaixo de 3K) resistor na inicialização. por outro lado, para entrar no modo de piscar ou de programação, você precisa aterrar o pino GPIO0 na inicialização. Para evitar o fluxo de corrente irrestrito via GPIO0 quando aterrado, é recomendado conectar GPIO0 ao aterramento por meio de algum resistor de baixa resistência 300Ω - 470Ω (mais sobre isso aqui). O pino RST como o nome sugere redefine (ou reinicia) o MCU. Durante a operação normal, ele pode ser conectado ao VCC por meio de um resistor pull-up de 10K, mas deve ser aterrado para reiniciar o microcontrolador. Embora seja sempre possível usar botões físicos para aterrar os pinos RST e GPIO0 (ou mesmo juntar os fios manualmente para simular um botão), é muito mais agradável usar os pinos Raspberry Pi para definir a tensão alta e baixa no RST e GPIO0 do módulo alfinetes. Além disso, não há necessidade de resistores de 10K e 470Ω.

Agora que estamos cientes das peculiaridades dos pinos do ESP-01, podemos começar a conectar tudo junto. Você pode usar a seguinte tabela como referência junto com o desenho acima:

ESP-01 Raspberry Pi

• VCC (3,3 V) pino # 1 (3,3 V)
• GND pino # 6 (GND)
• Pino TXD # 10 (RXD / BCM 15)
• RXD pino # 8 (TXD / BCM 14)
• CH_PD pino # 1 (3,3 V)
• RST pino # 3 (BCM 2)
• GPIO 0 pino # 5 (BMC 5)

Conecte o pino VCC por último. A instância em que você conectou o pino VCC ao seu módulo Wi-Fi será ativada. Use o screen ou minicom para verificar se RPi e ESP8266 podem se comunicar usando UART (nota: você pode precisar instalar o screen ou minicom primeiro, já que eles não parecem estar instalados no Raspbian por padrão).

Usando a execução da tela:

$ sudo screen / dev / serial0 115200

Usando minicom run:

$ sudo minicom -b 115200 -o -D / dev / serial0

Observação: muitos recursos online sugerem a conexão com ESP8266 em / dev / ttyAMA0, mas isso não funciona com RPi 3 ou posterior (incluindo zero W) de acordo com a documentação RPi. Em vez disso, conecte-se via / dev / serial0 ou / dev / ttyS0.

Depois de entrar na tela ou minicom, use os comandos AT para se comunicar com o ESP8266. Digite AT, pressione Enter e Ctrl + J para enviar o comando. Você deve obter OK em resposta. A lista de comandos AT disponíveis pode ser encontrada em espressiff.com ou apenas aqui.

Quando os dispositivos estão fisicamente conectados e conversam, podemos começar a programar os pinos RPi GPIO e, finalmente, o próprio ESP8266.

Etapa 3: configuração do software (Python para operar e Arduino IDE para programar)

PARTE 1. Usando python para alternar os modos ESP8266

Conforme mencionado acima, é conveniente usar os pinos GPIO do RPI para alternar os modos de operação do ESP8266. Escrevi dois códigos python básicos que colocam o ESP8266 no modo normal ou de programação.

Modo normal: para colocar o microcontrolador no modo de operação normal, só precisamos ligá-lo e conectar o CH_PD via resistor pull-up ao VCC, mas para mudar o MCU de programação para o modo normal, precisamos reiniciá-lo (pense em reiniciar). Para fazer isso no RPi, vamos puxar brevemente o GPIO do RPi conectado ao pino RST no ESP-01 (por padrão, o pino RPi que usei para redefinir é definido como HIGH). Em breve? Para mim, essa é uma questão especulativa. Você pode tentar intervalos de tempo diferentes, mas descobri que 200 - 500 ms funcionam bem. Escreva comentários se tiver uma ideia melhor. Salve seu código como reset.py

#! / usr / bin / python

importar RPi. GPIO como GPIO importar tempo GPIO.setmode (GPIO. BOARD) # define a identificação GPIO por números de pinos físicos resetPin = 3 # identifica o pino físico RPi conectado a ESP8266 pino RST GPIO.setup (resetPin, GPIO. OUT) # definir redefinir pino como saída GPIO.output (resetPin, GPIO. LOW) # queda de tensão no pino RST time.sleep (.2) # espera por.2 s GPIO.output (resetPin, GPIO. HIGH) # restaura a tensão no pino RST GPIO. cleanup () # redefinir pinos no RPI para evitar avisos futuros de tempo de execução

• Modo de programação: para colocar o MCU no modo de programação, precisamos alimentar o ESP8266 com GPIO0 aterrado ou, alternativamente, redefini-lo e aterrar o GPIO0 durante a inicialização (mais uma vez, a duração exata das quedas de tensão não é bem conhecida por mim, então não seja estritamente guiado pelos valores usados). Salve o código como flash.py ou faça o download abaixo. A sucessão de ações é a seguinte:

  • puxe o pino RST para baixo
  • puxe o pino GPIO0 para baixo
  • puxe o pino RST
  • puxe o pino GPIO0

#! / usr / bin / python

importar RPi. GPIO como GPIO importar tempo GPIO.setmode (GPIO. BOARD) # define a identificação GPIO por números de pinos físicos resetPin = 3 # identifica o pino físico RPi conectado ao ESP8266 pino RST flashPin = 5 # identifica o pino físico RPi conectado ao pino ESP8266 GPIO0 GPIO.setup (resetPin, GPIO. OUT) # definir pino de redefinição como saída GPIO.setup (flashPin, GPIO. OUT) # definir pino de flash como saída GPIO.output (resetPin, GPIO. LOW) # queda de tensão no tempo de pino RST. sleep (.2) # necessidade dessa espera é especulativa GPIO.output (flashPin, GPIO. LOW) # queda de tensão no GPIO0 time.sleep (.2) # necessidade dessa espera é especulativa GPIO.output (resetPin, GPIO. HIGH) # iniciar a inicialização do ESP8266 time.sleep (.5) # esperar que o ESP8266 inicialize o GPIO.ouput (flashPin. GPIO. HIGH) # restaurar a tensão no GPIO pinGPIO.cleanup () # redefinir os pinos no RPI para evitar futuros avisos de tempo de execução

Nas permissões de mudança de terminal:

$ sudo chmod + x flash.py

$ sudo chmod + x reset.py

De agora em diante, sempre que você precisar entrar no modo de programação executado no terminal:

$ python /flash.py

após enviar o código para entrar no modo de operação normal, execute:

$ python /reset.py

Neste ponto, você também pode querer atualizar o firmware ESP8266. Existem muitos tutoriais online sobre como fazer isso, então não irei entrar em detalhes sobre como fazer isso.

PARTE 2. Configurando o Arduino IDE

se você já tem o IDE do Arduino instalado, você ainda pode querer folhear a seção certificando-se de que seu IDE está pronto para ESP8266.

No Rapberry Pi, você pode usar o Arduino IDE para programar o ESP8266. Existem duas maneiras de instalar o IDE no RPi:

• via linha de comando de repositórios usando apt-get install
• baixe e instale manualmente em arduino.cc.

Eu sugiro fortemente seguir o último caminho. A versão IDE dos repositórios parece estar obsoleta e você certamente terá que fazer mais antes de começar a programar o ESP8266. Para evitar aborrecimentos, acesse a página de download do Arduino.cc e baixe a versão ARM do Linux. Em seguida, descompacte e instale: Se o nome do arquivo baixado for semelhante a arduino-X. Y. Z-linuxarm.tar.xz, execute na pasta de download:

$ tar -xvf arduino-X. Y. Z-linuxarm.tar.xz

Isso deve descompactar o arquivo para a pasta arduino-X. Y. Z. Corre:

$ sudo./arduino-X. Y. Z/install.sh

Isso deve instalar o IDE. Após a conclusão da instalação, inicie o IDE.

• No IDE do Arduino, vá para Arquivo> Preferências. Procure por “URLs adicionais do gerente da placa” na parte inferior da janela de preferências. Digite https://arduino.esp8266.com/stable/package_esp8266com_index.json no campo “URLs adicionais do gerenciador de placa” e clique no botão “OK”.
• Vá para Ferramentas> Placa: XXX> Gerenciador de placas. Na janela, use a pesquisa ou role para baixo, selecione o menu da placa ESP8266 e clique em instalar. Aguarde a conclusão da instalação e feche a janela.
• Vá novamente para Ferramentas> Placa: XXX e procure placas ESP8266. Escolha o módulo ESP8266 genérico.

Agora o IDE está pronto para programar ESP8266. Digite ou cole o código desejado na janela IDE e salve-o. Clique em Upload. No terminal, execute flash.py, isso deve colocar sua placa no modo de programação. Aguarde alguns minutos para que o IDE termine de compilar e carregar (nota: o ESP-01 normalmente vem com 2 LEDs, o LED azul piscará enquanto o código está sendo carregado) e execute reset.py. Agora, a sua placa ESP-01 está pronta para executar funções.