Placas

A Raspberry Pi Pico W

O Pico com um chip sem fio integrado. No MicroPython e no CircuitPython o chip é modelado a partir de seus pinos e entra na rede simulada do Mokxi.

A visão geral, com exemplos rodando, está na página da placa e O modelo da Raspberry Pi Pico W (todos os registradores).

Para um sketch Arduino, o WiFi é simulado por trás de uma caixa de correio, e o LED funciona de qualquer jeito.

O que é

The same RP2040 on the same board outline with the same forty pins as the Raspberry Pi Pico, rodando no mesmo modelo. O núcleo, o GPIO do SIO, o TIMER, a UART0 e o PWM são os da Pico, nos mesmos endereços, e um programa compilado para uma Pico aqui é o mesmo ELF que uma Pico W executa.

O que a placa real adiciona é uma CYW43439: WiFi de 2,4 GHz (802.11n) e Bluetooth, num chip ao lado do RP2040 com sua própria antena gravada na ponta da placa.

A CYW43439 e um sketch Arduino

Esta seção e a próxima falam de sketches Arduino. MicroPython e CircuitPython acessam a interface do chip real, que é modelada para eles: veja MicroPython e CircuitPython abaixo.

Para um sketch, quase nada desse chip é modelado. Sem protocolo SPI, sem blob de firmware, sem driver, sem registradores e sem Bluetooth: sem LE, sem GATT, sem pareamento, nem um stub. Um sketch que chame Bluetooth não compila aqui, porque o runtime não o declara.

A única exceção é o seu GPIO 0, que é o LED da placa, porque é um pino que um sketch realmente aciona; veja abaixo. No hardware real, o chip precisa ser alimentado e ter o firmware carregado antes que esse pino faça algo, o que o core do Arduino arruma na inicialização; aqui ele funciona desde a primeira instrução, e isso é uma simplificação, não um modelo da sequência.

Isso é deliberado. Um stub que devolvesse "não conectado" seria uma mentira com cara plausível, e um que devolvesse "conectado" seria pior.

O que a placa tem é uma rede simulada, descrita abaixo, e o que ela é além disso é tudo aquilo que a Pico é (o núcleo, os temporizadores, o PWM, a UART, os pinos) na placa que as pessoas realmente compraram. Se um rádio real é o ponto do seu projeto, esta placa no Mokxi não é a ferramenta para isso, e nenhuma outra é: não há rádio neste produto.

WiFi, simulated

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

No lugar disso, existe uma rede simulada. Um bloco que é do próprio Mokxi e não do chip (uma caixa de correio em 0x4FFF_E000, onde um RP2040 real não tem nada mapeado) carrega WiFi.h, HTTPClient.h e WebServer.h, então o código Arduino que um tutorial te dá funciona 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 atribui 192.168.4.2, e um sketch pode buscar 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.

Uma caixa de correio também é a forma honesta aqui. A parte sem fio de um Pico W real é uma CYW43439 do outro lado de uma ligação SPI de três pinos, dirigida por um blob binário fechado, não um conjunto de registradores documentados no RP2040, assim como o rádio de um ESP32 não é um conjunto de registradores documentados no próprio chip. Então isto é uma interface de comandos, que é onde está a costura real. Para um sketch, a própria CYW43439 não é modelada, e o Bluetooth não é simulado de forma nenhuma.

O bloco está mapeado num Pico W e não num Pico comum, então WiFi.h compila para uma placa e se recusa para a outra, e os programas de exemplo das duas placas não são intercambiáveis.

Quatro exemplos vêm com esta placa: WiFi: conectar na rede, WiFi: buscar a previsão do tempo, Laboratório de API: buscar JSON e WiFi: uma lâmpada numa página web.

Sketches escritos para arduino-pico

The Pico W's Arduino core is arduino-pico, and its WiFi examples build here as they are written: HelloServer with WebServer and LEAmDNS.h, BasicHttpsClient with a WiFiMulti and HTTPClient, and the WiFiServer ones with server.accept(). Its own calls are here too: WiFi.connected(), WiFi.noLowPowerMode(), WiFi.end(), http.setInsecure() and rp2040.getFreeHeap(). A few compile and do nothing, because what they reach is not simulated, and the serial monitor says so once: WiFi.ping() answers -1, MDNS.begin("picow") names nothing that resolves, and an https:// address still fails after setInsecure().

Duas coisas para mudar num sketch copiado: o nome e a senha da rede, que precisam corresponder aos da própria placa (Mokxi-Lab e breadboard, a menos que você os mude na placa), e qualquer endereço fora de .mokxi, que ninguém responde. Um sketch num Raspberry Pi Pico comum não compila com WiFi.h de jeito nenhum, porque essa placa não tem chip sem fio; troque a placa por um Pico W.

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

O LED não está no GP25

Esta é a parte que pega as pessoas, e pega também numa mesa real.

O LED verde de um Pico está no GP25. O de um Pico W não está. Num Pico W, GP23, GP24 e GP25 vão todos para a CYW43439 no lugar dele (WL_ON, WL_D e WL_CS), e o LED fica no GPIO 0 da própria CYW43, alcançado pela mesma ligação que o rádio usa.

Então digitalWrite(25, HIGH) não acende nada aqui, e também não acende nada num hardware real.

digitalWrite(LED_BUILTIN, HIGH) acende o LED, em ambos. LED_BUILTIN nesta placa não é um número de GPIO de jeito nenhum: o runtime o envia para a parte sem fio pela mesma caixa de correio que a rede usa, que é o caminho que o core do Arduino segue na placa real. A lâmpada na placa no editor acende junto.

Uma coisa que essa ligação não consegue carregar é um ciclo de trabalho, então analogWrite(LED_BUILTIN, …) não faz nada num Pico W. Um LED que respira precisa de um pino do cabeçalho, que é o que o exemplo Fade faz.

Ligue um LED e um resistor de 220 ohms de um pino do cabeçalho a um pino de terra e pisque esse no lugar. O exemplo blink da própria placa faz exatamente isso.

Os pinos

Exatamente os quarenta do Pico, na mesma ordem e com os mesmos nomes: veja o Raspberry Pi Pico. Esta é uma placa de 3,3 volts e seus pinos não toleram 5 V.

GP29 é WL_CLK num Pico W além de ser o divisor do VSYS, e GP24 não é o sensor de VBUS. Nada o alimenta aqui, então ele lê baixo. Nenhum dos dois está no cabeçalho de qualquer das placas.

O que é modelado, e o que não é

O mesmo que o Pico, cada linha dele, mais um bloco que não é do chip de jeito nenhum: estão lá o SIO GPIO, o TIMER de 64 bits, UART0, UART1 (Serial2, nos seus pinos), PWM, o ADC, a caixa de correio da rede simulada e o único pino da CYW43 atrás dela; PIO, DMA, SPI, I2C, USB, o RTC, a árvore de clocks, o segundo núcleo e a ROM de boot não estão, e o resto da CYW43439 também não. Essa é a placa de um sketch: sob MicroPython e CircuitPython a placa inicializa pela sua ROM com o modelo completo do chip do Pico, e a CYW43439 está nos seus pinos (abaixo). analogRead() lê GP26 a GP28 (A0 a A2) como no Pico.

The full list is in o modelo do Raspberry Pi Pico W, que diz só o que difere, e o modelo do Raspberry Pi Pico, que diz todo o resto.

Bibliotecas do Arduino

O mesmo que em a Pico: Servo.h, Wire.h (no GP4 e GP5), SPI.h, EEPROM.h (na RAM), LiquidCrystal_I2C.h, Adafruit_SSD1306.h, Adafruit_NeoPixel.h e DHT.h compilam como estão.

Os exemplos

Blink, Button, Serial, Fade e Chaser são os próprios do Pico, compilados de novo para esta placa. Blink aciona LED_BUILTIN e GP15, então a lâmpada da própria placa e uma na protoboard piscam juntas; Fade faz fade só no GP14, porque não há PWM na ligação para a lâmpada da placa. Os exemplos de controle de jogos do Pico (as quatro etapas do Fight stick, Fight stick, Leverless controller, controle estilo Mixbox e Stop the light) também estão aqui.

Quatro a mais são só desta placa, porque só ela tem rede: WiFi: conectar na rede, WiFi: buscar a previsão do tempo, Laboratório de API: buscar JSON, e WiFi: uma lâmpada numa página web, que alterna as duas lâmpadas pela aba Web.

Uma compilação para Pico W usa um bloco que um Pico comum deixa sem mapear, então as duas placas carregam strings de programa diferentes e o editor oferece a cada uma a sua própria lista.

MicroPython e CircuitPython

Escolha MicroPython (main.py) ou CircuitPython (code.py) no painel Firmware da placa e Rodar inicializa o firmware oficial do Pico W: a versão do Pico W do MicroPython v1.29.0, ou a do CircuitPython 10.3.1. Qualquer um dos dois dirige a CYW43439 como faz numa mesa real, pelos pinos do próprio chip (GP23, GP24, GP25 e GP29), e o chip é modelado na profundidade que o driver dele alcança: o barramento, o upload de firmware (aceito e descartado) e os comandos de WiFi.

  • O LED é o GPIO 0 do chip: Pin("LED") em MicroPython, board.LED em CircuitPython.
  • WiFi joins Mokxi's simulated access point, whose name and password are the board's WiFi properties (Mokxi-Lab and breadboard unless you change them). In MicroPython, network.WLAN(network.STA_IF) connects and socket, requests and urequests reach the .mokxi sites; a socket server on the board opens in the Web panel. In CircuitPython, wifi.radio.connect() connects and socketpool with adafruit_requests fetches the same sites.
  • O ponto de acesso da própria placa: WiFi.beginAP() (em 192.168.42.1, ou 192.168.4.1 em WIFI_AP_STA, como no arduino-pico) e o network.WLAN(network.AP_IF) do MicroPython (em 192.168.4.1) o iniciam, e o painel Web entra nele como um celular e abre a página da placa lá.
  • Não simulado: Bluetooth, uma segunda estação no ponto de acesso, o ponto de acesso do CircuitPython, economia de energia, TLS e qualquer rede que não a do Mokxi. No CircuitPython, wifi.radio.ap_info lança NotImplementedError, porque a portabilidade dele para o Pico W não o implementa.

Veja o Pico para MicroPython e CircuitPython no Pico para CircuitPython; o modelo do Raspberry Pi Pico W tem os detalhes.

Em outros lugares