Placas

A ESP8266 NodeMCU

Uma placa ESP8266 com WiFi simulado, um Xtensa LX106 a 80 MHz, pinos D0 a D8 que diferem dos números de GPIO e PWM por software.

A visão geral, com exemplos rodando, está na página da placa e O modelo do ESP8266 NodeMCU (todos os registradores).

O que é

A NodeMCU V1.0 "Amica", um módulo ESP-12E num suporte de trinta pinos, rodando em nosso próprio núcleo Xtensa na configuração LX106. O firmware é um ELF Xtensa que fala com os endereços reais do ESP8266, com uma exceção, citada abaixo, que o modelo deixa clara.

A placa tem 48,3 por 25,6 mm e suas duas fileiras de quinze pinos ficam a 0,9 polegada de distância, então ela fica sobre o canal central de uma protoboard deixando uma fileira de furos livre de cada lado. A placa que as pessoas fotografam unindo duas protoboards é a V3 "LoLin", mais larga, cujas fileiras ficam a uma polegada inteira de distância. Este componente é a V1.0.

D0 to D8 are not GPIO numbers

É isso que pega todo mundo nesta placa, por isso vem primeiro:

Serigrafia D0 D1 D2 D3 D4 D5 D6 D7 D8 RX TX
GPIO 16 5 4 0 2 14 12 13 15 3 1

digitalWrite(2, HIGH) é D4, e não D2. O runtime do Mokxi define D0 para D8, então você pode escrever digitalWrite(D2, HIGH) e significar o pino que você está vendo.

Os pinos

Quinze em cada borda longa, o soquete micro-USB embaixo.

Coluna esquerda, de cima a baixo: A0, RSV, RSV, SD3, SD2, SD1, CMD, SD0, CLK, GND, 3V3, EN, RST, GND, VIN.

Coluna direita, de cima a baixo: D0, D1, D2, D3, D4, 3V3, GND, D5, D6, D7, D8, RX, TX, GND, 3V3.

Esta é uma placa de 3,3 volts e os pinos dela não toleram 5 V. VIN é o trilho de 5 V vindo do USB.

SD0 a SD3, CMD e CLK são os seis fios do chip de flash. Eles estão no header de uma NodeMCU real e estão neste componente, e aqui não estão ligados a nada: nem acionam nem leem. Acionar um numa placa real interrompe a flash de onde seu programa roda, então um simulador que deixasse você usá-los estaria te ensinando a danificar uma placa. Os dois pinos RSV são iguais.

Dois LEDs, e ambos são invertidos

D4 (GPIO 2) tem o LED azul do módulo ESP-12 e D0 (GPIO 16) tem o da placa portadora. Ambos são ativos em nível baixo: digitalWrite(LED_BUILTIN, LOW) acende o do módulo. LED_BUILTIN é 2.

O exemplo blink escreve o LED da placa e um LED ligado em D1 em direções opostas de propósito, então os dois ficam sempre um ao contrário do outro, que é o que você vê numa mesa.

O botão FLASH é o GPIO 0, que é o D3, ativo em nível baixo. Clicar nele na placa liga o pino ao GND.

D0 não é um pino comum

O GPIO 16 (D0) é um pino do RTC, não do bloco GPIO. Três coisas decorrem disso:

  • Ele tem pull-down, enquanto todos os outros pads deste componente têm pull-up.
  • Ele não pode gerar interrupção. attachInterrupt(D0, ...) não faz nada.
  • Numa placa real é o pino que você liga ao RST para acordar do deep sleep, o que não é modelado aqui porque deep sleep também não é.

analogRead: um pino, dez bits e um divisor

A0 é o único pino analógico que o ESP8266 tem. Ele não é um GPIO e não pode ser escrito.

O pino do próprio chip converte de 0 a 1,0 V. Uma NodeMCU põe um divisor 220k/100k na frente dele, então o A0 do header vai de 0 a cerca de 3,2 V, e um potenciômetro ligado no trilho de 3,3 V quase cobre toda a faixa. O divisor faz parte da placa, e o Mokxi o modela: o pino carrega seu nó com 320 k, que é o que uma placa real faz.

Dez bits, de 0 a 1023, que também é a faixa de PWM desta placa, então o exemplo knob alimenta a leitura direto no duty.

Isto é a única coisa nesta placa que não está num endereço real. A Espressif nunca publicou os registradores de ADC do ESP8266 (o SDK chama system_adc_read() de dentro de um blob binário), então, em vez de inventar um endereço e deixar você supor que é o do chip, o Mokxi põe três registradores próprios lá e avisa. O que isso significa na prática: se você levar uma compilação daqui para uma NodeMCU real, analogRead é a única chamada que você precisaria mudar. Nada mais.

analogWrite é software, a faixa é 1023, e custa algo ao núcleo

O ESP8266 não tem nenhum hardware de PWM. Não um LEDC reduzido: nenhum. O core Arduino ESP8266 gera suas formas de onda a partir de um handler de timer, e este runtime também: oito pinos ao mesmo tempo, 1 kHz por padrão, analogWriteFreq(40..60000).

Duas coisas decorrem disso, e ambas são reais:

  • analogWrite aceita de 0 a 1023, não de 0 a 255. analogWrite(pin, 255) é um quarto do brilho, não o brilho total. É o que o core real faz, e copiar isso foi a escolha entre surpreender você aqui ou surpreender você na bancada. analogWriteRange(255) faz um sketch de Uno se comportar.
  • O core acorda duas vezes por período para mover o pino. Em um ESP32 um LED com fade é de graça; aqui não. As duas placas estão aqui, e a diferença entre elas é uma das coisas mais úteis que este par ensina.

Serial

Serial é a UART0 em TX e RX, que é a porta onde está a ponte USB, e ela está ligada ao monitor serial. Os bytes saem na taxa de baud que você definir.

Serial1 não é modelada. Em um ESP8266 real o pino TX da UART1 é o GPIO 2, que também é o LED do módulo, e é por isso que você não pode ter os dois.

Para uma segunda porta, SoftwareSerial.h funciona em quaisquer dois pinos, exceto D0 (o GPIO 16 não tem interrupção), com as chamadas da EspSoftwareSerial, a biblioteca que acompanha o core do ESP8266: SoftwareSerial gps(D5, D6); gps.begin(9600);. Cada borda no pino de recepção é cronometrada numa interrupção contra o contador de ciclos, então várias portas recebem ao mesmo tempo e listen() não para as outras. Somente 8N1.

What is modeled

O Xtensa LX106 no ABI call0: dezesseis registradores e sem janela de registradores, que é o que seu compilador emite e por que uma imagem de ESP32 falha neste core em vez de se comportar mal silenciosamente. Ao redor dele: o bloco GPIO e o IO_MUX, os registradores RTC que são o GPIO 16, a UART0, o conversor TOUT, e CCOUNT e CCOMPARE0 por trás de millis(), micros(), delay() e do PWM por software.

Esse é o conjunto de que pinMode, digitalWrite, digitalRead, analogRead, analogWrite, millis, micros, delay, attachInterrupt e Serial precisam, em seus endereços reais, com o ADC como a exceção declarada.

WiFi, simulated

Não há rádio. Nunca vai haver: um MAC 802.11 não é algo que este modelo pudesse reproduzir com honestidade.

O que existe no lugar é uma rede simulada. Um bloco que é do próprio Mokxi, e não do chip (uma caixa de correio em 0x6FFF_E000, onde um ESP8266 real não tem nada mapeado), dá suporte a WiFi.h, HTTPClient.h e WebServer.h, então o código Arduino que um tutorial te dá roda aqui: a placa entra num ponto de acesso cujo nome e senha são propriedades da placa, WiFi.status() percorre os mesmos estados no mesmo intervalo de um a três segundos, o DHCP lhe aluga o 192.168.4.2, e um sketch pode baixar uma página ou servir uma.

O que está por trás disso é software, e nada disso está escondido. Não há 802.11, nem canal, nem varredura, nem WPA2, nem TCP, nem TLS e não há internet de verdade: quatro nomes inventados sob .mokxi resolvem e nenhum outro, e nada que um sketch faça pode alcançar a rede do seu navegador. WiFiClientSecure compila e depois falha, dizendo que TLS não é simulado. Os painéis Web e Cloud na parte de baixo do editor abrem com essa frase e não a deixam sair da tela.

A única exceção é Internet de verdade, um interruptor no painel Cloud para quem está logado (mais dele com o Pro) que fica desligado toda vez que uma página carrega. Com ele ligado, uma requisição por um nome fora de .mokxi, https:// incluído, sai pelo gateway do Mokxi e a resposta volta para o sketch. Veja Internet de verdade.

Esta é a parte com um rádio e nenhuma documentação para ele: o WiFi do ESP8266 é um blob binário no SDK e a Espressif nunca publicou seus registradores. Este modelo não tenta adivinhá-los. O que ele oferece no lugar é uma caixa de correio que é honestamente do Mokxi, num endereço que honestamente não é do componente.

Três exemplos acompanham esta placa: WiFi: conectar na rede, WiFi: buscar a previsão do tempo e WiFi: uma lâmpada numa página web.

WiFi, simulado é como usar; WiFi simulado é o contrato, limite por limite.

O que não é

Um rádio de qualquer tipo. Nada de 802.11, nem PHY, nem canal, nem WPA2, e nenhum registrador do próprio rádio do componente, porque a Espressif nunca publicou um. Num componente cuja razão de existir é o WiFi, essa é a maior coisa faltando aqui, e ela é dita primeiro em vez de por último, e é por isso que a seção acima dela é a rede simulada e não esta.

Também ausentes: a flash e o cache que a mapeia, então sem PROGMEM leitura da flash, sem SPIFFS, sem LittleFS e sem OTA. FRC1 e FRC2, os dois timers de hardware. O relógio aqui é o próprio contador de ciclos do core, que é um registrador que nenhum modelo precisa adivinhar. Deep sleep e o RTC, seu contador e sua memória. SPI, I2S e a UART1 de hardware. Não há periférico I2C neste chip para começar; o core do Arduino o emula por software, e isso também não está aqui. Os eFuses. Os watchdogs são modelados: um sketch que não cede o controle por 3 a 5 s recebe o "Soft WDT reset" do core, e um que o desligou com ESP.wdtDisable() o reset do watchdog de hardware em cerca de 8,4 s.

Binários do SDK do fabricante e do core Arduino não rodam aqui: o runtime é nosso.

Compilando o seu sketch

Edite o sketch e aperte Rodar: ele compila na aba, como em todas as outras placas daqui. Para este chip o compilador é o próprio clang da Espressif, que tem o back end Xtensa, então a primeira compilação baixa um toolchain separado (clang-v3, cerca de 80 MB, uma vez) e as compilações seguintes o reaproveitam. Nada é enviado por upload. Um exemplo intocado ainda roda seu programa pré-compilado; mude uma linha e Rodar compila o seu.

Aritmética de ponto flutuante funciona: o LX106 não tem FPU, então somas de float e double são feitas em software, como num ESP8266 real. Compilando no navegador tem o relato completo.

The full list of what the model implements, and a plain account of which addresses are as real as this part allows, which are believed and which three are invented, is in o modelo do ESP8266 NodeMCU. A seção 6 é a que se deve ler antes de levar uma compilação daqui para o silício de verdade.

As bibliotecas padrão do Arduino que as outras placas compilam (Servo.h, Wire.h, EEPROM.h, Adafruit_SSD1306.h e as demais) também estão no caminho de include aqui, mas ainda não foram verificadas nesta placa.

Os exemplos

Blink, Button, Serial, Fade, Knob e os três de WiFi: WiFi: conectar à rede, WiFi: buscar a previsão do tempo e WiFi: uma lâmpada em uma página web. Cada um roda seu programa pronto até você mudá-lo, e então Rodar compila a sua versão.

Em outros lugares