Instalação do PlatformIO: guia de Arduino, ESP32 e Pico no VS Code
Instalação do PlatformIO no VS Code: configure Uno, ESP32 e Pico com o platformio.ini, adicione bibliotecas com lib_deps, carregue o código e migre do Arduino IDE.
Instalar o PlatformIO adiciona uma única extensão ao VS Code e permite programar placas como o Arduino Uno, o ESP32 e o Raspberry Pi Pico a partir de um só ambiente profissional. Resumindo: instale o VS Code, procure PlatformIO IDE na aba Extensões e instale, espere as ferramentas necessárias serem baixadas na primeira abertura e depois crie um novo projeto na tela PIO Home escolhendo a sua placa. O resto acontece em um pequeno arquivo de configuração chamado platformio.ini: qual placa, qual framework, quais bibliotecas e qual velocidade da porta serial usar, tudo fica escrito ali.
O Arduino IDE é uma ótima ferramenta para aprender, mas, conforme os projetos crescem, você sente os limites dele: o autocompletar de código é básico, as bibliotecas são compartilhadas entre todos os projetos, uma atualização de biblioteca pode quebrar um projeto antigo e as configurações da placa não ficam salvas junto com o projeto. O PlatformIO resolve esses problemas. Neste guia você vai instalá-lo passo a passo, criar seu primeiro projeto, definir três placas diferentes em um só projeto com o platformio.ini, adicionar uma biblioteca, carregar o código, abrir o Monitor Serial e aprender a migrar projetos existentes do Arduino IDE. Na última seção vamos comparar as duas ferramentas de forma imparcial para você decidir qual combina mais com você.

O que é o PlatformIO e como ele funciona?
O PlatformIO é um ecossistema de desenvolvimento de código aberto para sistemas embarcados. No centro dele está uma ferramenta de linha de comando escrita em Python chamada PlatformIO Core; a extensão do VS Code a torna prática com botões, menus e a tela PIO Home. Quando você compila um projeto, o PlatformIO primeiro lê o platformio.ini e depois baixa do próprio repositório o compilador necessário (avr-gcc para o Uno, o toolchain Xtensa para o ESP32, arm-none-eabi-gcc para o Pico), o framework e as bibliotecas, e compila o seu código. Esses pacotes são baixados uma única vez e guardados na pasta .platformio do seu diretório de usuário; os projetos seguintes reutilizam os mesmos pacotes. Conhecer os conceitos abaixo facilita muito a leitura do arquivo:
| Conceito | Significado | Exemplo |
|---|---|---|
| Plataforma (platform) | O pacote de compilador e ferramentas de carregamento de uma família de microcontroladores | atmelavr, espressif32, raspberrypi |
| Board (placa) | Uma placa específica dentro de uma plataforma; mapa de pinos, velocidade de clock e informações de memória | uno, nanoatmega328, esp32dev, pico |
| Framework | A base de software sobre a qual o seu código é escrito | arduino, espidf |
| Ambiente (env) | A seção que define juntos a plataforma, a placa, o framework e as configurações extras | [env:uno] |
| Biblioteca | Um pacote de código pronto adicionado ao projeto com lib_deps | adafruit/DHT sensor library (nome da biblioteca) |
| PIO Home | A tela para abrir projetos e buscar placas e bibliotecas | O ícone de casinha na barra de status |
Instalação do PlatformIO passo a passo
- Baixe o Visual Studio Code no site oficial e instale. No Windows, marcar Add to PATH durante a instalação facilita o uso do terminal.
- Abra o VS Code e clique na aba Extensões (Extensions) à esquerda, ou use o atalho Ctrl+Shift+X (Cmd+Shift+X no macOS).
- Digite PlatformIO IDE na caixa de busca e instale a extensão publicada pela PlatformIO com o botão Install. A extensão C/C++ necessária vem junto automaticamente.
- Uma notificação “Installing PlatformIO Core” aparece no canto inferior direito. Dependendo da velocidade da sua internet, isso leva alguns minutos; não feche o VS Code enquanto isso.
- Quando a instalação terminar, o VS Code pede para reiniciar. Depois de reiniciar, aparece um ícone do PlatformIO na borda esquerda e um ícone de casinha na barra de status inferior.
- Clique no ícone de casinha para abrir a tela PIO Home. Se essa tela aparecer sem problemas, a instalação está concluída.
Criando seu primeiro projeto e a estrutura de pastas
Clique no botão New Project no PIO Home. Na janela que abrir, dê um nome ao projeto (por exemplo blink-uno), digite Arduino Uno na caixa Board e escolha na lista, deixe o framework como Arduino e escolha o local. Quando você clica em Finish, o PlatformIO baixa pela primeira vez o pacote de plataforma necessário para a placa escolhida; por isso o primeiro projeto pode levar alguns minutos, enquanto os próximos abrem em segundos. Depois que o projeto é criado, o VS Code abre a pasta e você vê esta estrutura:
| Pasta / arquivo | Para que serve |
|---|---|
| platformio.ini | O coração do projeto: configurações de placa, framework, bibliotecas e porta |
| src/ | O seu código-fonte; o programa começa pelo main.cpp |
| include/ | Os seus próprios arquivos de cabeçalho (.h) |
| lib/ | Bibliotecas locais do projeto que você adiciona à mão (cada uma em sua própria subpasta) |
| test/ | Uma pasta reservada para testes unitários |
| .pio/ | Saída da compilação e bibliotecas baixadas; é recriada se for apagada |
| .vscode/ | Configurações do VS Code e do IntelliSense; geradas automaticamente |
O que é o arquivo platformio.ini?
O platformio.ini é um arquivo de texto simples no formato INI. Cada seção [env:nome] que começa com colchetes define um ambiente de compilação. A placa e a velocidade da porta que você escolhe no menu Ferramentas do Arduino IDE ficam escritas aqui como texto; assim, quando você leva o projeto para outro computador ou passa para um amigo, as configurações vão junto com o código. Linhas que começam com ponto e vírgula são comentários. Quando adicionamos a velocidade do Monitor Serial ao arquivo criado para o Uno, ele fica assim:
1; PlatformIO proje ayarları / PlatformIO project settings
2[env:uno]
3platform = atmelavr
4board = uno
5framework = arduino
6; Seri monitör hızı, Serial.begin ile aynı olmalı / Monitor speed, must match Serial.begin
7monitor_speed = 115200| Configuração | O que faz | Valor de exemplo |
|---|---|---|
| platform | O pacote de plataforma a usar; a versão também pode ser fixada | atmelavr, [email protected] |
| board | ID da placa | uno, megaatmega2560, esp32dev, pico |
| framework | Framework de software | arduino |
| monitor_speed | Velocidade do Monitor Serial (padrão 9600) | 115200 |
| upload_port | Porta de carregamento (encontrada automaticamente se ficar vazia) | COM5, /dev/ttyUSB0 |
| upload_speed | Baud rate do carregamento (principalmente em placas ESP) | 921600 |
| lib_deps | Bibliotecas a baixar automaticamente | adafruit/DHT sensor library@^1.4.4 (biblioteca na versão 1.4.4 ou compatível) |
| build_flags | Flags e macros extras para o compilador | -D LED_PIN=2 |
| monitor_filters | Filtros aplicados à saída do Monitor Serial | time, esp32_exception_decoder |
Primeiro código: main.cpp e a diferença do Arduino.h
O arquivo main.cpp na pasta src equivale ao arquivo .ino do Arduino IDE, mas há duas diferenças importantes. Primeiro, o arquivo precisa começar com uma linha #include que adiciona o cabeçalho Arduino.h; o Arduino IDE faz isso nos bastidores, o PlatformIO não. Segundo, um arquivo .cpp segue as regras reais do C++: o compilador precisa conhecer uma função antes de você chamá-la. O Arduino IDE gera os protótipos das funções para você; no PlatformIO, você define a função antes de usá-la ou escreve um protótipo de uma linha no topo do arquivo. O exemplo abaixo é um programa blink que funciona igualmente no Uno, no ESP32 e no Pico:
1#include <Arduino.h>
2
3// LED_PIN platformio.ini'den gelebilir / LED_PIN may come from platformio.ini
4#ifndef LED_PIN
5#define LED_PIN LED_BUILTIN // Uno: 13, Pico: GP25
6#endif
7
8void blinkLed(int count); // prototip / prototype
9
10void setup() {
11 Serial.begin(115200);
12 pinMode(LED_PIN, OUTPUT);
13 Serial.println("PlatformIO hazir / ready");
14}
15
16void loop() {
17 blinkLed(3);
18 delay(1000);
19}
20
21void blinkLed(int count) {
22 for (int i = 0; i < count; i++) {
23 digitalWrite(LED_PIN, HIGH);
24 delay(150);
25 digitalWrite(LED_PIN, LOW);
26 delay(150);
27 }
28 Serial.print("Yanip sondu / Blinked: ");
29 Serial.println(count);
30}Compilação, carregamento e Monitor Serial
| Ação | Barra de status / menu | Comando no terminal |
|---|---|---|
| Compilar (Build) | Sinal de visto | pio run |
| Carregar (Upload) | Seta para a direita | pio run -t upload (comando para gravar o firmware) |
| Carregar e abrir o monitor | Menu do PlatformIO > Upload and Monitor | pio run -t upload -t monitor (grava e abre o monitor serial) |
| Monitor Serial | Ícone de tomada | pio device monitor (abre o monitor serial) |
| Limpar | Lixeira | pio run -t clean (apaga os arquivos de compilação) |
| Listar portas | PIO Home > Devices | pio device list (lista as portas disponíveis) |
| Compilar um ambiente específico | Seletor de ambiente (env:...) | pio run -e esp32dev |
| Instalar uma biblioteca | PIO Home > Libraries | pio pkg install -l "adafruit/DHT sensor library" (instala a biblioteca) |
Para o Monitor Serial funcionar direito, o valor de monitor_speed no platformio.ini precisa ser igual à velocidade do Serial.begin() no seu código; caso contrário, você verá caracteres estranhos na tela. O PlatformIO geralmente encontra sozinho a placa conectada, mas, se o computador tiver mais de um dispositivo serial, ele pode tentar carregar na porta errada. Nesse caso, liste as portas com pio device list e escreva a correta nas linhas upload_port e monitor_port. Se o Monitor Serial do Arduino IDE ou outro programa de terminal estiver com a porta aberta, o carregamento para com o erro “Access is denied” ou “Resource busy”; basta fechar esse programa. Para conhecer melhor o Monitor Serial em si, veja também o post Monitor Serial do Arduino. O comando pio sempre funciona no terminal PlatformIO Core CLI aberto pelo menu do PlatformIO.
Definindo Uno, ESP32 e Pico em um só projeto
Um dos pontos mais fortes do PlatformIO é conseguir compilar o mesmo código para várias placas. Você escreve uma seção [env:...] separada para cada placa; se colocar as configurações em comum na seção sem nome [env], todos os ambientes as herdam. A tabela abaixo resume os valores básicos de três placas populares:
| Valor | Arduino Uno | ESP32 DevKit | Raspberry Pi Pico |
|---|---|---|---|
| platform | atmelavr | espressif32 | raspberrypi |
| board | uno | esp32dev | pico |
| framework | arduino | arduino | arduino (core Arduino Mbed) |
| LED integrado | D13 | GPIO 2 (na maioria das placas DevKit) | GP25 |
| Método de carregamento | USB-serial e bootloader | USB-serial e esptool | USB e modo BOOTSEL |
| monitor_speed típico | 9600 ou 115200 | 115200 | 115200 |
1[platformio]
2; Varsayılan ortam / Default environment
3default_envs = uno
4
5; Tüm ortamlarda ortak ayarlar / Settings shared by all environments
6[env]
7framework = arduino
8monitor_speed = 115200
9
10[env:uno]
11platform = atmelavr
12board = uno
13
14[env:esp32dev]
15platform = espressif32
16board = esp32dev
17upload_speed = 921600
18monitor_filters = esp32_exception_decoder
19; Dahili LED GPIO 2 / Onboard LED on GPIO 2
20build_flags = -D LED_PIN=2
21
22[env:pico]
23platform = raspberrypi
24board = picoA linha default_envs decide qual ambiente os botões de compilar e carregar da barra de status usam; se você não escrevê-la, o PlatformIO compila todos os ambientes do arquivo, um depois do outro. Você pode trocar de placa na hora pelo seletor de ambiente da barra de status, ou carregar direto no ESP32 digitando pio run -e esp32dev -t upload no terminal. A flag -D LED_PIN=2 no ambiente do ESP32 define a macro LED_PIN no código; como o Uno e o Pico não têm essa flag, o código recorre ao valor de LED_BUILTIN (13 e 25). Assim, um único main.cpp roda nas três placas sem nenhuma alteração. Para ver rapidamente a disposição dos pinos das placas, use a ferramenta Pinagem.
Configurações do PlatformIO para o ESP32
No PlatformIO, as placas ESP32 são carregadas com o esptool, assim como no Arduino IDE. upload_speed = 921600 reduz bastante o tempo de carregamento; se o seu cabo for longo ou de baixa qualidade e aparecerem erros, baixe para 460800 ou 115200. O filtro esp32_exception_decoder converte o despejo de endereços sem sentido que aparece no Monitor Serial quando a placa trava em nomes de funções e números de linha; ele é muito valioso para rastrear erros Guru Meditation. Se o carregamento travar na etapa “Connecting...”, segure o botão BOOT da placa e solte quando o carregamento começar; as soluções detalhadas estão no post ESP32 Failed to Connect. Outro detalhe que vale conhecer é a versão do core: a plataforma oficial espressif32 do PlatformIO usou por muito tempo a versão 2.x do core Arduino-ESP32; se você precisar de APIs específicas da 3.x, pode mudar para a plataforma pioarduino, mantida pela comunidade. Você vê qual core está sendo usado pela versão do framework-arduinoespressif32 na linha PACKAGES, no início da saída da compilação. Se quiser que o seu código compile nas duas versões, pode diferenciá-las com a macro ESP_ARDUINO_VERSION_MAJOR.
Raspberry Pi Pico e PlatformIO
Com board = pico, a plataforma oficial raspberrypi usa o core RP2040 oficial do Arduino, baseado no Mbed OS. Muitos usuários preferem o core arduino-pico de Earle Philhower, que oferece mais recursos e melhor compatibilidade com bibliotecas; no PlatformIO ele é usado por meio de um pacote de plataforma separado, mantido pela comunidade, e da configuração board_build.core = earlephilhower. Qualquer que seja o core escolhido, no primeiro carregamento pode ser preciso ligar o Pico na USB segurando o botão BOOTSEL; a placa aparece no computador como uma unidade chamada RPI-RP2 e, depois que o PlatformIO carrega o programa, reinicia sozinha. Nos carregamentos seguintes geralmente não é preciso usar o botão. Um aviso importante: o PlatformIO não suporta MicroPython. Se você quer programar o Pico com MicroPython, use um editor como o Thonny; para mais detalhes, veja os posts Fundamentos de MicroPython e O que é o Raspberry Pi Pico?.
Adicionando bibliotecas: lib_deps
No PlatformIO, as bibliotecas são instaladas separadamente para cada projeto, e não para o computador inteiro. O método mais limpo é adicionar uma linha lib_deps ao platformio.ini: na primeira compilação, o PlatformIO baixa a biblioteca do registro (registry) e a coloca na pasta .pio/libdeps/. Você também pode buscar o nome exato da biblioteca na aba Libraries do PIO Home e adicioná-la com o botão Add to Project; esse botão escreve a linha lib_deps para você. Abaixo há um exemplo que liga um sensor DHT11 ao pino D2 do Uno; para a ligação do sensor, veja o post Sensor de temperatura e umidade DHT11.
1[env:uno]
2platform = atmelavr
3board = uno
4framework = arduino
5monitor_speed = 115200
6; Kütüphaneler ilk derlemede otomatik iner / Libraries download on first build
7lib_deps =
8 adafruit/DHT sensor library@^1.4.4
9 adafruit/Adafruit Unified Sensor@^1.1.91#include <Arduino.h>
2#include <DHT.h>
3
4#define DHT_PIN 2 // Uno D2 pini / Uno pin D2
5#define DHT_TYPE DHT11
6
7DHT dht(DHT_PIN, DHT_TYPE);
8
9void setup() {
10 Serial.begin(115200);
11 dht.begin();
12}
13
14void loop() {
15 delay(2000); // DHT11 en fazla 1 Hz / DHT11 max 1 Hz
16 float h = dht.readHumidity();
17 float t = dht.readTemperature();
18 if (isnan(h) || isnan(t)) {
19 Serial.println("Sensor okunamadi / Read failed");
20 return;
21 }
22 Serial.print("Sicaklik / Temp: ");
23 Serial.print(t, 1);
24 Serial.print(" C Nem / Hum: ");
25 Serial.print(h, 0);
26 Serial.println(" %");
27}Na notação de versões, ^1.4.4 permite as versões 1.4.4 e superiores, mas abaixo de 2.0.0; ~1.4.4 aceita só correções 1.4.x; se você escrever apenas 1.4.4, a versão fica totalmente fixada. Fixar versões garante que, quando você abrir o projeto daqui a um ano, o mesmo código compile do mesmo jeito. Se você colocar uma biblioteca que não está no registro, ou uma que você mesmo escreveu, na pasta lib do projeto como uma subpasta com o nome dela, o PlatformIO a encontra automaticamente. Se quiser comparar com o funcionamento das bibliotecas no Arduino IDE, leia o post Como instalar biblioteca no Arduino.
Migrando um projeto do Arduino IDE para o PlatformIO
- Crie um novo projeto no PIO Home e escolha a mesma placa que você usava no Arduino IDE.
- Cole o conteúdo do arquivo .ino em src/main.cpp; acrescente as outras abas .ino da mesma pasta ao final do main.cpp e copie os arquivos .h e .cpp para a pasta src.
- Adicione a linha #include do Arduino.h bem no topo do arquivo.
- Escreva um protótipo no topo do arquivo para cada função que você criou além de setup() e loop().
- Encontre as bibliotecas que você usa em PIO Home > Libraries e adicione-as ao lib_deps; se você escrever o mesmo número de versão do Arduino IDE, terá o mesmo comportamento.
- Escreva a velocidade do Serial.begin() na linha monitor_speed e compile o projeto. Corrija um a um os avisos que sobrarem na lista de erros.
Como alternativa, você pode importar uma pasta existente diretamente com o botão Import Arduino Project do PIO Home. O PlatformIO converte os arquivos .ino da pasta src em .cpp durante a compilação e tenta gerar os protótipos. Porém, como essa conversão pode errar em códigos complexos e o IntelliSense não funciona com eficiência total em arquivos .ino, migrar para o main.cpp é mais saudável a longo prazo. Se tiver dificuldade em interpretar as mensagens de compilação, as explicações do post erros de compilação do Arduino valem também para o PlatformIO.
Arduino IDE ou PlatformIO?
| Característica | Arduino IDE 2.x | PlatformIO (VS Code) |
|---|---|---|
| Instalação | Um único pacote, alguns minutos | VS Code mais a extensão; as ferramentas são baixadas na primeira configuração |
| Autocompletar de código | Básico | IntelliSense avançado, ir para a definição, renomear em massa |
| Configurações da placa | No menu Ferramentas, não ficam salvas com o projeto | No platformio.ini, vão junto com o projeto |
| Bibliotecas | Compartilhadas em todo o computador | Separadas por projeto, versões podem ser fixadas |
| Várias placas | Trocadas pelo menu a cada vez | Vários ambientes em um só projeto |
| Estrutura de arquivos | .ino; o nome da pasta precisa ser igual ao nome do arquivo | src, include, lib; .cpp e .h padrão |
| Protótipos de funções | Gerados automaticamente | Escritos à mão (automáticos ao importar .ino) |
| Controle de versão com Git | Possível, mas as configurações da placa ficam de fora | Fácil; tudo, exceto a pasta .pio, é versionado |
| Depuração e testes | Depurador em algumas placas | Depurador (debug probe) e suporte a testes unitários |
| Facilidade para iniciantes | Muito alta | Média; exige um curto período de adaptação |
Resumindo: se você está acendendo seu primeiro LED ou fazendo um projeto escolar com poucos arquivos, o Arduino IDE basta e confunde menos. Se você lida com várias placas, código em vários arquivos, controle de versão com Git ou trabalho em equipe, o PlatformIO economiza muito tempo. As duas ferramentas não se excluem; você pode usar as duas no mesmo computador. Se ainda não instalou o Arduino IDE, comece pelo post Como instalar o Arduino IDE.
Erros comuns e como resolvê-los
| Sintoma | Causa provável | Solução |
|---|---|---|
| 'xyz' was not declared in this scope (não declarado neste escopo) | Falta o protótipo da função | Escreva o protótipo antes do setup() ou mova a função para cima |
| fatal error: DHT.h: No such file or directory (arquivo não encontrado) | A biblioteca não está no lib_deps ou foi adicionada a outro ambiente | Adicione a biblioteca à seção [env] correta e compile de novo |
| Caracteres estranhos no Monitor Serial | monitor_speed diferente da velocidade do Serial.begin() | Deixe os dois valores iguais (ex.: 115200) |
| A placa não aparece, sem porta | Cabo só de carga, ou falta o driver CH340/CP2102 | Use um cabo de dados, instale o driver, confira com pio device list |
| Access is denied / Resource busy (porta ocupada) | A porta está aberta em outro programa | Feche o Monitor Serial do Arduino IDE e outros terminais |
| ESP32: Failed to connect, Wrong boot mode (mensagem de erro: falha na conexão, modo de boot incorreto) | A placa não entrou no modo de download | Inicie o carregamento segurando o botão BOOT |
| O carregamento no Pico não começa | A placa não está no modo BOOTSEL | Conecte segurando o BOOTSEL e confira se a unidade RPI-RP2 aparece |
| Permission denied: /dev/ttyUSB0 no Linux | Falta a regra udev ou a permissão do usuário | Instale o arquivo 99-platformio-udev.rules e adicione seu usuário ao grupo dialout |
| No Windows, a compilação para com erros de caminho sem sentido | Caracteres fora do alfabeto inglês ou espaços no nome de usuário | Mova a pasta do core para C:\platformio com PLATFORMIO_CORE_DIR |
| Travado na etapa Installing PlatformIO Core | Problema de internet, antivírus ou Python | Reinicie o VS Code e confira o log em Output > PlatformIO |
Primeiros projetos para testar com o PlatformIO
- Blink em várias placas: carregue o projeto de três ambientes acima no Uno, no ESP32 e no Pico, um de cada vez, para entender como funciona o seletor de ambiente.
- Registro de sensor com horário: mostre os dados do DHT11 no Monitor Serial com marcação de horário usando a configuração monitor_filters = time.
- Servidor web via Wi-Fi: no projeto de servidor web com ESP32, divida o código em vários arquivos .cpp e .h para montar uma estrutura organizada.
- Atualizações sem fio: com o OTA no ESP32, carregue o código pelo Wi-Fi definindo upload_protocol = espota e escrevendo o endereço IP da placa na linha upload_port.
- Máquina de estados: escreva a lógica da máquina de estados no Arduino em um arquivo de classe separado e aproveite a estrutura de pastas do PlatformIO.
- Temporização sem delay: escreva um programa que executa várias tarefas ao mesmo tempo usando millis().
Embora a instalação do PlatformIO leve um pouco mais de tempo que a do Arduino IDE no começo, o arquivo platformio.ini mantém todas as configurações do projeto em um só lugar e, com o tempo, ele se torna a ferramenta que mais economiza seu tempo. Depois de concluir a instalação, o primeiro passo é compilar e carregar um projeto simples de LED e, em seguida, partir para projetos com bibliotecas e várias placas. No app BlueGrays, você encontra projetos de LED piscando, projetos iniciais com ESP32 e Pico e projetos com sensores como o DHT11 e o HC-SR04, passo a passo, com esquema do circuito e código, e pode testá-los levando o código direto para o seu próprio projeto no PlatformIO.
Perguntas frequentes
O PlatformIO é grátis?
Sim. O PlatformIO Core e a extensão PlatformIO IDE para o VS Code são de código aberto e de uso gratuito. Em projetos de hobby, escolares ou comerciais, você não precisa pagar nenhuma licença pelas definições de placas, pelo gerenciador de bibliotecas nem pelos recursos de compilação e carregamento.
Código do Arduino IDE funciona no PlatformIO?
Sim, porque ao escolher framework = arduino são usados o mesmo core do Arduino e as mesmas funções. Basta mover o código para src/main.cpp, adicionar o include do Arduino.h no topo, escrever os protótipos das funções e adicionar as bibliotecas que você usa ao lib_deps.
Por que a instalação do PlatformIO demora tanto?
Na primeira configuração são baixados o PlatformIO Core, o ambiente Python e as ferramentas básicas; no primeiro projeto também são baixados o compilador e o framework da placa escolhida. Como os pacotes do ESP32 podem ter centenas de megabytes, isso pode levar 5–15 minutos, dependendo da sua conexão. Depois que os pacotes são baixados, os projetos seguintes abrem rápido.
O PlatformIO suporta MicroPython?
Não, o PlatformIO foi feito para frameworks baseados em C/C++, como Arduino e ESP-IDF. Se você quer programar um Raspberry Pi Pico ou um ESP32 com MicroPython, use um editor como o Thonny. Se preferir, também pode programar a mesma placa com o framework Arduino no PlatformIO.
Como adicionar uma biblioteca no PlatformIO?
O jeito mais fácil é abrir a aba Libraries no PIO Home, buscar a biblioteca e escolher o seu projeto com Add to Project. Isso adiciona uma linha lib_deps ao platformio.ini, e a biblioteca é baixada automaticamente na primeira compilação. Suas próprias bibliotecas podem ser colocadas como subpastas na pasta lib do projeto.
Como escolher a porta COM no PlatformIO?
Na maioria das vezes, o PlatformIO encontra a placa conectada automaticamente. Se houver vários dispositivos seriais, você pode fixar a porta pelo seletor de porta da barra de status ou escrevendo as linhas upload_port = COM5 e monitor_port = COM5 no platformio.ini. Você vê quais portas estão conectadas com o comando pio device list.
Projetos para montar depois desta leitura
Ver todos os projetos
LED piscante
O primeiro contato com a eletrônica: acender e apagar um único LED. O Arduino acende e apaga o LED em intervalos curtos, fazendo a luz piscar rapidamente.

LED piscando com ESP32
Ensina o uso básico de uma saída GPIO no ESP32. Fazemos um LED piscar ligando e desligando um pino digital. É a versão para ESP32 do clássico projeto blink do Arduino UNO: os comandos básicos de blink no ambiente Arduino são os mesmos, mas a disposição dos pinos e os níveis de 3,3 V dos GPIOs do ESP32 diferem dos do Arduino UNO.

Piscar o LED integrado do Raspberry Pi Pico (Pico e Pico W)
O primeiro projeto da série Raspberry Pi Pico! Fazemos o LED verde integrado piscar para verificar se a placa funciona — um primeiro experimento no estilo clássico "Hello World". SEM componentes externos, apenas o Pico e um cabo USB. O código foi escrito em MicroPython (a linguagem com suporte oficial da Raspberry Pi Foundation). Aprenda a usar a classe machine.Pin, o modo Pin.OUT, os métodos led.on()/off() e time.sleep() no Thonny IDE.

Temperatura e umidade com DHT11
Qual é a temperatura do seu quarto? O ar está úmido ou seco? O sensor DHT11 mede a temperatura e a umidade, e o Arduino mostra os valores em um display LCD de duas linhas, atualizando a cada poucos…

Medição de distância com HC-SR04 (Monitor Serial)
O sensor HC-SR04 funciona como um morcego que se orienta no escuro: emite um som que você não consegue ouvir, escuta o eco e mede a distância até o objeto à sua frente.

LED integrado do ESP32 piscando
Faça o LED azul integrado do ESP32 DevKit V1 piscar. Nenhum componente externo é necessário! O primeiro projeto para experimentar ao comprar um ESP32. GPIO 2 está conectado ao LED integrado.

Raspberry Pi Pico: controle de LED externo (protoboard)
O próximo passo depois do LED integrado do Pico: conectar um LED externo na protoboard e controlá-lo pelo pino GP14. Você aprende a usar qualquer pino GPIO do Pico como saída, a polaridade do LED (terminal longo = ânodo/+, terminal curto = cátodo/–) e por que um resistor limitador de corrente (220Ω) é indispensável. Sem o resistor, passa corrente demais pelo LED e ele pode queimar.

Controle de LED com botão no ESP32 (momentâneo)
O LED acende enquanto o botão está pressionado e apaga ao soltá-lo. Mostra como usar o pino de entrada digital e o resistor pull-up interno do ESP32. O modo INPUT_PULLUP dispensa um resistor externo.
Mais artigos
- Como instalar a Arduino IDE 2 no Windows, Mac e Linux (guia)
- Como instalar uma biblioteca no Arduino: Gerenciador de Bibliotecas, ZIP e manual
- O que é ESP32? Características, configuração na Arduino IDE e seu primeiro projeto com Wi-Fi
- O que é Raspberry Pi Pico? Instalação do MicroPython, pinagem e primeiros projetos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

