Pular para o conteúdo principal

Laboratório 02

Documentação de Apoio para Atividade de Laboratório

A documentação desta atividade de laboratório é complementar a documentação principal da disciplina.

Utilize como base a descrição apresentada no Moodle da disciplina.

TarefaTemplateInícioFimConteúdo
LAB02TPL0230-Mar-202606-Apr-2026Configuração do Ambiente ESP32 (Parte 02);

Checklist — Configuração do Ambiente ESP32 (Parte 02)​

  • Verificar git --version
  • Abrir o VS Code
  • Abrir a extensão PlatformIO IDE
  • Instalar a extensão Wokwi
  • Ativar/configurar o Wokwi
  • Criar um projeto ESP32
  • Selecionar o framework Arduino
  • Executar o primeiro Build
  • Criar wokwi.toml
  • Criar diagram.json
  • Executar a simulação
  • Verificar o Serial Monitor
  • Atualizar o repositório no GitHub
  • Executar git push
  • Confirmar que o projeto está disponível no GitHub
  • Logout
Estrutura organizacional dos repositórios
ELT73A-S22-2026-2
├── Times
│   ├── Grupo-A
│   ├── ...
│   ├── Grupo-P  # (Professor)
│   └── Grupo-N  # (Notas)
└── Repositórios
    ├── lab02-template
    ├── lab02-grupo-a
    ├── ...
    ├── lab02-grupo-p  # (Professor)
    └── lab02-grupo-n  # (Notas)

Verifique o seu ambiente de desenvolvimento​

O Git é a ferramenta de gerenciamento de código-fonte mais utilizada por desenvolvedores profissionais.

  • O Git é um sistema de controle de versão distribuído gratuito e de código aberto, projetado para lidar com tudo, desde projetos pequenos até muito grandes, com rapidez e eficiência.
winget install --id Git.Git -e --source winget

Configurações do git:

git config --list --show-origin

Configure o nome de usuário para todos os repositórios locais ligados às suas transações de commit:

git config --global user.name "Your Name"

Configure o email de usuário para todos os repositórios locais ligados às suas transações de commit:

git config --global user.email "you@example.com"

É recomendado verificar se a instalação do seu Git não está realizando nenhuma transformação entre LFs e CRLFs.

git config --global core.autocrlf false

Configure o git para usar o Visual Studio Code como editor padrão para tarefas como escrever mensagens de commit ou rebases interativos

git config --global core.editor "code --wait"

Habilite a coloração automática da saída da linha de comando do Git:

git config --global color.ui auto

Configura o Git para usar main como o nome do branch padrão sempre que você inicializar um novo repositório localmente:

git config --global init.defaultBranch main

Liste as configurações aplicadas:

git config --list --show-origin

Clone o repositório inicial do LAB02​

Escolha o seu grupo e entre com o comando abaixo para criar o repositório no GitHub:

1. Crie e entre na pasta-mãe da disciplina:

mkdir "%USERPROFILE%ELT73A" & cd /d "%USERPROFILE%ELT73A"

2. Clone e entre no repositório do laboratório:

git clone https://github.com/ELT73A-S22-2026-2/lab02-grupo-a.git && cd lab02-grupo-a

3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code :

code . --profile "ESP32IO"
Como fazer commit da atualizações

Verifique o status do repositório:

git status

Adicione os arquivos modificados:

git add .

Realize o commit das alterações:

git commit -m "Descrição breve das alterações realizadas!"

Envie para o repositório remoto (GitHub):

git push

Vizualize o log de alterações:

git log

Vizualize no GitHub:

gh repo view --web

Repositório do Grupo A para Laboratório 02:

ELT73A-S22-2026-2/lab02-grupo-a
  1. Copie o link do repositório acima.
  2. Abra a página de envio da atividade no Moodle (botão abaixo).
  3. Clique em Adicionar envio.
  4. Cole o link no campo Texto online.
  5. Clique em Salvar mudanças.
  6. Confira se o status mudou para Enviado para avaliação.
Abrir envio no Moodle
Avaliação por commits

Cada cartão Ponto de commit é uma tarefa: faça-a, copie o comando do cartão e rode. A mensagem começa com o código (T1:, T2:…) — é como a correção identifica sua entrega. Um commit por tarefa; pode refazer (vale o mais recente); e não esqueça o git push. Detalhes em Como funciona a avaliação.

Crie um novo projeto no PlatformIO​

pio project init -b esp32dev -O "framework=arduino" -O "monitor_speed=115200" --sample-code
include - Put project header files here
lib - Put project specific (private) libraries here
src - Put project source files here
platformio.ini - Project Configuration File
Resolving esp32dev dependencies...
Already up-to-date.
Project has been successfully initialized!
Ponto de commit · T1 (10 pts) #

pio project init

git add . && git commit -m "T1: pio project init" && git push

Crie ou edite o arquivo src/main.cpp com a seguinte estrutura:

📂 lab02-grupo-x (git repo)/
  • └── 📂src
    • └── 📄main.cpp
src/main.cpp
#include <Arduino.h>

// Definição de pinos
#define LED_PIN 2

// Protótipos de funções (obrigatório em C/C++ padrão)
void blinkLed(uint8_t pin, uint16_t delayMs);

void setup() {
  Serial.begin(115200);
  pinMode(LED_PIN, OUTPUT);
  Serial.println("ESP32 Inicializado!");
}

void loop() {
  blinkLed(LED_PIN, 500);
}

// Implementação de funções auxiliares
void blinkLed(uint8_t pin, uint16_t delayMs) {
  digitalWrite(pin, HIGH);
  delay(delayMs);
  digitalWrite(pin, LOW);
  delay(delayMs);
}
Ponto de commit · T2 (10 pts) #

pio project init

git add . && git commit -m "T2: pio project init" && git push

ESP32 Arduino Hal Logging​

Aqui está um exemplo completo para o arquivo src/main.cpp.

Este código demonstra a diferença entre as macros nativas do ESP32 Arduino Hal Logging (log_i, log_w, log_e, etc.) e o método tradicional Serial.println(), além de realizar o piscar de LED (blink) assíncrono utilizando millis().

Código: src/main.cpp​

📂 lab02-grupo-x (git repo)/
  • └── 📂src
    • └── 📄main.cpp
src/main.cpp
#include <Arduino.h>

// Definição do pino do LED (GPIO 2 é o LED embutido na maioria das placas ESP32 DevKit)
#define LED_PIN 2

// Intervalo de tempo para o Blink (em milissegundos)
const unsigned long BLINK_INTERVAL = 500;

// Variáveis de controle de tempo
unsigned long previousMillis = 0;
bool ledState = LOW;
uint32_t counter = 0;

void setup() {
    // Configura o pino do LED como saída
    pinMode(LED_PIN, OUTPUT);

    // Inicializa a comunicação serial a 115200 baud
    Serial.begin(115200);

    // Aguarda um instante para a estabilização da conexão Serial
    delay(1000);

    Serial.println("\n==============================================");
    Serial.println("   ESP32 Lab: Teste de Logs e Blink de LED   ");
    Serial.println("==============================================\n");

    // Mensagens de Log do ESP32 (requer CORE_DEBUG_LEVEL > 0 no platformio.ini)
    log_v("Log de Verbose: Informação detalhada/baixa relevância.");
    log_d("Log de Debug: Informação para depuração do sistema.");
    log_i("Log de Info: Sistema inicializado com sucesso no pino GPIO %d.", LED_PIN);
    log_w("Log de Warning: Este é um exemplo de aviso!");
    log_e("Log de Error: Este é um exemplo de erro simulação!");
}

void loop() {
    unsigned long currentMillis = millis();

    // Lógica de tempo não-bloqueante (evita o uso de delay)
    if (currentMillis - previousMillis >= BLINK_INTERVAL) {
        previousMillis = currentMillis;

        // Inverte o estado do LED
        ledState = !ledState;
        digitalWrite(LED_PIN, ledState);

        counter++;

        // Mensagem via Serial.println padrão do Arduino
        Serial.print("[Arduino Serial] Ciclo do LED: ");
        Serial.print(counter);
        Serial.print(" | Estado atual: ");
        Serial.println(ledState ? "LIGADO" : "DESLIGADO");

        // Mensagem usando o Log nativo do ESP32 a cada 5 trocas de estado
        if (counter % 5 == 0) {
            log_i("Contador atingiu %u trocas de estado.", counter);
        }
    }
}

Configurar o platformio.ini​

Este é o passo mais importante da aula. Abra o platformio.ini na raiz do projeto e deixe-o assim:

📂 lab02-grupo-x (git repo)/
  • └── 🔧platformio.ini
platformio.ini
; CORE_DEBUG_LEVEL define ate que nivel de log sera COMPILADO:
;   0 = NONE | 1 = ERROR | 2 = WARN | 3 = INFO | 4 = DEBUG | 5 = VERBOSE
build_flags =
    -D CORE_DEBUG_LEVEL=5
    -D CONFIG_ARDUHAL_LOG_COLORS=1       ; Habilita cores no console
MacroCORE_DEBUG_LEVEL ≥Uso típico
log_e("...", ...)1Erro
log_w("...", ...)2Aviso
log_i("...", ...)3Informação
log_d("...", ...)4Debug
log_v("...", ...)5Verbose
log_buf_i(buf, tam)3Dump hexadecimal

Em platformio.ini: build_flags = -DCORE_DEBUG_LEVEL=<0..5>

Erro nº 1 dos iniciantes

Se você esquecer o -DCORE_DEBUG_LEVEL, o valor padrão costuma ser 0 (NONE) e nada aparece, mesmo com o código correto. Se seus logs sumiram, comece a investigação por aqui.

Ponto de commit · T3 (10 pts) #

Teste de Logs e Blink de LED

git add src/main.cpp && git commit -m "T3: Teste de Logs e Blink de LED" && git push

Simulação com Wokwi​

Objetivo: validar lógica sem depender da bancada.

Opção A — Extensão Wokwi no VS Code​

  1. Instale Wokwi Simulator
  2. No projeto, use/crie:
    • diagram.json — circuito (ESP32, LED, fios)
    • wokwi.toml — liga o firmware do PlatformIO ao simulador (conforme docs do template)
  3. Comando típico da extensão: Start Simulator
  4. Abra o monitor serial do Wokwi e veja o mesmo Serial.println

A basic wokwi.toml file looks like this:

📂 lab02-grupo-x (git repo)/
  • ├── 🔧wokwi.toml👈 Criar Aqui
  • └── 📂src
    • └── 📄main.cpp
wokwi.toml
[wokwi]
version = 1
firmware = '.pio/build/esp32dev/firmware.bin'
elf = '.pio/build/esp32dev/firmware.elf'

Opção B — Wokwi no navegador​

  1. Acesse wokwi.com
  2. Novo projeto → ESP32
  3. Cole o conteúdo de src/main.cpp
  4. Monte LED no GPIO do LED_BUILTIN (ou no GPIO que o template usar)
  5. Start e observe LED + serial

Exemplo mínimo de ideia de diagram.json (LED no GPIO 2)​

Muitos DevKit tratam LED embutido no GPIO 2 — confirme no template.

Checklist Wokwi

  • Projeto simula e imprime no serial a mensagem do grupo
  • LED pisca conforme o loop()
  • Você não precisou da placa física para esta parte
📂 lab02-grupo-x (git repo)/
  • └── 🔧diagram.json
diagram.json
{
  "version": 1,
  "author": "Uri Shaked",
  "editor": "wokwi",
  "parts": [
    {
      "type": "wokwi-esp32-devkit-v1",
      "id": "esp",
      "top": 0,
      "left": 0,
      "attrs": {}
    },
    {
      "type": "wokwi-led",
      "id": "led1",
      "top": -3.33,
      "left": 153.33,
      "attrs": { "color": "red" }
    },
    {
      "type": "wokwi-resistor",
      "id": "r1",
      "top": 64,
      "left": 149.33,
      "rotate": 90,
      "attrs": {}
    }
  ],
  "connections": [
    ["esp:TX0", "$serialMonitor:RX", "", []],
    ["esp:RX0", "$serialMonitor:TX", "", []],
    ["esp:GND.1", "led1:C", "black", ["h0"]],
    ["led1:A", "r1:1", "green", ["v0"]],
    ["r1:2", "esp:D2", "green", ["h0", "v38"]]
  ]
}
Ponto de commit · T4 (15 pts) #

Configurando o Wokwi

git add diagram.json wokwi.toml && git commit -m "T4: Configurando o Wokwi" && git push

Tipos de Dados e Constantes no ESP32​

Bits, Bytes e Operadores no ESP32​

Estruturas de Controle no ESP32​

CI workflow​

Example workflow (.github/workflows/grade.yml):

📂 lab02-grupo-x (git repo)/
  • └── 📂.github
    • └── 📂workflows
      • └── 🚀grade.yml
.github/workflows/grade.yml
name: Build & Test

on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v5

      - name: Cache PlatformIO
        uses: actions/cache@v5
        with:
          path: |
            ~/.cache/pip
            ~/.platformio/.cache
            ~/.platformio/packages
          key: ${{ runner.os }}-pio-${{ hashFiles('platformio.ini') }}

      - name: Set up Python
        uses: actions/setup-python@v7
        with:
          python-version: "3.12"

      - name: Install PlatformIO
        run: pip install platformio

      - name: Build project
        run: pio run

      # Uncomment if you want native/unit tests in CI
      # - name: Run tests
      #   run: pio test -e native
Ponto de commit · T5 (15 pts) #

GitHub action

git add .github/workflows/grade.yml && git commit -m "T5: GitHub action" && git push

Wokwi for CI and GitHub Actions (TODO)​

GitHub action for using Wokwi Embedded Systems Simulator in your CI workflow.

VS Code Terminal Configuration​

Configure Git Bash como terminal integrado do Visual Studio Code para evitar problemas de formatação de texto e comandos:

📂 lab02-grupo-x (git repo)/
  • └── 📂.vscode
    • └── 🔧settings.json
.vscode/settings.json
"terminal.integrated.defaultProfile.windows": "Git Bash",

Crie um gh alias para deploy-esp32io​

gh alias set deploy-esp32io 'tag="$1"; gh release create "$tag" .pio/build/esp32dev/firmware.bin .pio/build/esp32dev/firmware.elf --generate-notes' --shell

Como funciona:

Esse alias que você configurou faz o seguinte fluxo em uma única linha de comando:

  1. Recebe o parâmetro tag — o primeiro argumento passado ao comando (gh deploy-debug v1.0.0 define tag="v1.0.0").
  2. Executa o gh release create — cria um release no GitHub com a tag informada.
  3. Anexa os artefatos — inclui tanto o firmware.bin (usado para gravar no ESP32) quanto o firmware.elf (útil para depuração).
  4. Gera notas automaticamente — o parâmetro --generate-notes faz o GitHub compilar um changelog básico com commits e PRs desde o último release.

Ou seja, com um único comando você publica uma nova versão do firmware no GitHub, já com os dois arquivos necessários: o .bin para flash e o .elf para debug.

Uso:

gh deploy-esp32io v1.0.0

Rápida verificação do upload​

Assim que o comando terminar, você poderá verificar o upload diretamente em seu terminal usando:

gh release view v1.0.0 --web
Ponto de commit · T6 (10 pts) #

publica o release do firmware

git commit --allow-empty -m "T6: publica o release do firmware" && git push
gh deploy-esp32io v1.0

Logout do seu ambiente dev, git e gh​

Para o git "esquecer" suas informações salvas:

git credential-manager erase && cmdkey /list | findstr "github" && gh auth logout
Última atualização em por Adriano Ruseler