Pular para o conteúdo principal

Introdução

Ambiente de desenvolvimento​

Configuração do 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 git​

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

Status do git, gh e code:​

Versão do git e configurações:

git --version && git config --list --show-origin

Versão do GitHub CLI e status de login:

gh --version && gh auth status

Versão do Visual Studio Code e extensões instaladas:

code -v && code --list-extensions --profile "ESP32IO"

Logout​

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

git credential-manager erase && cmdkey /list | findstr "github" && gh auth logout

Clone o repositório inicial do LABXY (Exemplo)​

Escolha o 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%\ELT85BN21" & cd /d "%USERPROFILE%\ELT85BN21"

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

git clone https://github.com/ELT85B-N21-2026-2/labxy-grupo-a.git && cd labxy-grupo-a

3. Verifique status e abra o conteúdo do repositório no perfil ESP32IO do VS Code :

git status && code . --profile "ESP32IO"

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

ELT85B-N21-2026-2/labxy-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.

Estrutura do Laboratório XY​

Estrutura organizacional dos repositórios
ELT73A-S22-2026-2
├── Times
│   ├── Grupo-A
│   ├── ...
│   ├── Grupo-P  # (Professor)
│   └── Grupo-N  # (Notas)
└── Repositórios
    ├── lab00-template
    ├── lab00-grupo-a
    ├── ...
    ├── lab00-grupo-p  # (Professor)
    └── lab00-grupo-n  # (Notas)

Como funciona a avaliação​

Nesta disciplina, você entrega cada tarefa fazendo um commit. Ao longo das aulas, os cartões "Ponto de commit" mostram exatamente o que salvar e quando.

Como é um "Ponto de commit"​

Quando você conclui uma tarefa, encontra um cartão como este (numeração e pontos são ilustrativos):

Ponto de commit · T1 (5 pts) #

exemplo — pisca o LED_BUILTIN

git add . && git commit -m "T1: exemplo — pisca o LED_BUILTIN" && git push

Clique em Copiar no bloco de código do cartão e cole o comando no terminal, dentro da pasta do seu repositório. Feito isso, a tarefa está entregue.

Passo a passo​

  1. Faça a tarefa descrita logo antes do cartão.
  2. Copie o comando do cartão e rode no terminal. Ele é algo como: 
    git add . && git commit -m "T1: ..." && git push
  3. Pronto — esse commit registra a tarefa T1. Siga para o próximo ponto.
A mensagem do commit é o que vale

A mensagem começa com o código da tarefa (T1:, T2:, …). É por ela que a correção automática identifica o que você entregou — não altere esse prefixo e use exatamente o que o cartão copia.

Regras que importam​

  • Um commit por tarefa, na ordem. Prefira commitar cada ponto separadamente.
  • Pode refazer: se melhorar uma tarefa, faça um novo commit com o mesmo código (T2: ...). Vale sempre o mais recente.
  • Não esqueça o git push — sem enviar, seu trabalho não chega para correção.
  • Uma tarefa sem commit correspondente vale zero.

Como a nota é calculada​

  • A cada push, uma correção automática avalia cada tarefa no estado do commit dela. Por isso tudo bem reescrever o mesmo arquivo entre as partes: cada Tn é avaliado no seu próprio ponto da história.
  • Cada tarefa verifica se o projeto compila e se cumpre os requisitos daquele ponto. A nota da tarefa é proporcional ao que passou.
  • A nota final é a soma dos pontos, normalizada de 0 a 10.

Dicas rápidas​

  • Compile/teste antes de commitar.
  • Use exatamente a mensagem do cartão (o botão de copiar já traz o código certo).
  • Fez os commits na ordem T1, T2, …? Ótimo — é assim que a numeração casa com a correção.
TarefaTemplateInícioFimConteúdo
LAB0020-08-202627-08-2026Apresentação da Disciplina; Formação dos grupos;
LAB0127-08-202603-09-2026Visão Geral sobre IoT;
LAB0203-09-202610-09-2026A Internet na IoT;
LAB0310-09-202617-09-2026Sensores e Atuadores em IoT;
LAB0417-09-202624-09-2026Pilha de Protocolos IoT: Enlace e Rede;
LAB0524-09-202601-10-2026Pilha de Protocolos IoT: Aplicação;
LAB0601-10-202608-10-2026Computação em Nevoeiro (Fog Computing);
LAB0708-10-202615-10-2026Plataforma de Serviços IoT;
LAB0815-10-202622-10-2026Mercados de IoT: Agricultura e Energia;
LAB0922-10-202629-10-2026Mercados de IoT: Indústria e Transporte;
LAB1029-10-202605-11-2026Padrões IoT;
TarefaTemplateInícioFimConteúdo
LAB0020-08-202627-08-2026Apresentação da Disciplina; Formação dos grupos;
LAB0127-08-202603-09-2026Visão Geral sobre IoT;
LAB0203-09-202610-09-2026A Internet na IoT;
LAB0310-09-202617-09-2026Sensores e Atuadores em IoT;
LAB0417-09-202624-09-2026Pilha de Protocolos IoT: Enlace e Rede;
LAB0524-09-202601-10-2026Pilha de Protocolos IoT: Aplicação;
LAB0601-10-202608-10-2026Computação em Nevoeiro (Fog Computing);
LAB0708-10-202615-10-2026Plataforma de Serviços IoT;
LAB0815-10-202622-10-2026Mercados de IoT: Agricultura e Energia;
LAB0922-10-202629-10-2026Mercados de IoT: Indústria e Transporte;
LAB1029-10-202605-11-2026Padrões IoT;

Teste Slidev 16/9​

📌 Contexto do Projeto: Laboratório IoT (Node-RED + MQTT + SQLite3 + Docker)​

Aqui está um resumo compacto e estruturado da arquitetura e do script gerador (gen_portal.py), pronto para você copiar e colar como contexto inicial em um novo chat:

Objetivo Geral​

O projeto é um gerador em Python (gen_portal.py) que cria automaticamente um ambiente Docker para aulas de IoT. Ele expõe contêineres Node-RED isolados por grupo/turma por trás de um portal Nginx (proxy reverso) e um broker MQTT Mosquitto central.

Arquitetura & Nomenclatura​

  1. Roteamento & Nomes de Serviços:

  • Convenção de Nomes: {turma}-{identificador} (ex.: n21-a, n21-b, n21-p, n21-n).

  • Reservas de Letras Especiais:

  • p → Professor (ex.: n21-p).

  • n → Painel de Notas / Avaliador (ex.: n21-n).

  • Grupos de Alunos: Usam sequencialmente o restante do alfabeto (a, b, c... pulando n e p).

  1. Avaliador Distribuído (Container {turma}-n):
  • Possui o volume contendo todas as pastas dos alunos mapeado em modo leitura (./data:/data_grupos:ro).
  • Vem pré-configurado com um fluxo Node-RED autogerado que executa análise estática nos arquivos flows.json dos alunos (checklist de nodes, tópicos, etc.) e imprime um relatório de correção/notas no Debug.
  1. Portal Nginx:
  • Servido na porta 80.
  • Página Inicial (index.html): Mantém visual dark/neon com grid e cards estilizados. Cards de alunos usam cor padrão, o Professor recebe destaque em dourado e o Avaliador de Notas em roxo.
  • Proxy Reverso: Redireciona a rota /{servico}/ (ex: /n21-a/) para a porta 1880 do respectivo container.
  1. Autenticação & Segurança:
  • Node-RED: Cada container utiliza um settings.js customizado com autenticação via adminAuth com hashes bcrypt (2b2b).
  • São gerados dois usuários por container: {servico} (Admin) e {servico}-view (Apenas leitura).
  • As senhas geradas são exportadas para um arquivo credenciais.txt.

Comandos Úteis de Operação​

  • Gerar infraestrutura (exemplo com 2 turmas e 10 grupos cada):
python3 gen_portal.py --turma n21 --grupos 10
  • Subir o ambiente:
docker compose up -d --build
  • Desabilitar/Habilitar um grupo pontualmente:
docker compose stop n21-a-nodered   # Desabilita
docker compose start n21-a-nodered  # Habilita
  • Aplicar alterações com remoção de turmas/grupos antigos:
docker compose up -d --remove-orphans

Grok dump​

Here’s a clean PlatformIO + Arduino + ESP32 starter structure you can use in your lab templates.

labXX-template/
├── .github/
│   └── workflows/
│       └── grade.yml
├── include/
│   └── README
├── lib/
│   └── README
├── src/
│   └── main.cpp
├── test/
│   └── test_main.cpp
├── .gitignore
├── platformio.ini
└── README.md

File contents​

platformio.ini

; PlatformIO Project Configuration File
; https://docs.platformio.org/page/projectconf.html

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200

; Optional: common build flags
build_flags =
    -DCORE_DEBUG_LEVEL=0

; Unit Testing
test_framework = unity

src/main.cpp

#include <Arduino.h>

void setup() {
  Serial.begin(115200);
  delay(1000);
  Serial.println("LAB started - ESP32 + PlatformIO");

  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(500);
  digitalWrite(LED_BUILTIN, LOW);
  delay(500);
}

test/test_main.cpp (PlatformIO Unity test)

#include <unity.h>
#include <Arduino.h>

void setUp(void) {
  // runs before each test
}

void tearDown(void) {
  // runs after each test
}

void test_led_pin_mode() {
  pinMode(LED_BUILTIN, OUTPUT);
  TEST_ASSERT_EQUAL(OUTPUT, 1); // simple example
}

void setup() {
  delay(2000);          // wait for serial / board
  UNITY_BEGIN();
  RUN_TEST(test_led_pin_mode);
  UNITY_END();
}

void loop() {
  // empty
}

.gitignore

.pio
.vscode/.browse.c_cpp.db*
.vscode/c_cpp_properties.json
.vscode/launch.json
.vscode/ipch
*.pyc
__pycache__/
.DS_Store

README.md

# LABXX - ESP32 + PlatformIO

## Requirements

- [PlatformIO](https://platformio.org/) (VS Code extension or CLI)
- ESP32 board

## Build & Upload

```bash
pio run              # compile
pio run -t upload    # upload
pio device monitor   # serial monitor
```

Run tests​

pio test

Structure​

  • src/ → main application code
  • include/ → header files
  • lib/ → private libraries
  • test/ → unit tests (Unity)

.github/workflows/grade.yml (CI – compile only)

name: Build & Test

on: [push, pull_request]

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

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

      - name: Set up Python
        uses: actions/setup-python@v5
        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

include/README and lib/README (PlatformIO placeholders)

This directory is intended for project header files / private libraries.

Updated script snippet (replace the “Create starter folder structure” part)​

# 3. Create PlatformIO starter structure
mkdir -p src include lib test .github/workflows

# platformio.ini
cat > platformio.ini << 'EOF'
[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200
test_framework = unity
EOF

# src/main.cpp
cat > src/main.cpp << EOF
#include <Arduino.h>

void setup() {
  Serial.begin(115200);
  delay(1000);
  Serial.println("LAB$lab started - ESP32 + PlatformIO");
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(500);
  digitalWrite(LED_BUILTIN, LOW);
  delay(500);
}
EOF

# test/test_main.cpp
cat > test/test_main.cpp << 'EOF'
#include <unity.h>
#include <Arduino.h>

void test_example() {
  TEST_ASSERT_TRUE(true);
}

void setup() {
  delay(2000);
  UNITY_BEGIN();
  RUN_TEST(test_example);
  UNITY_END();
}

void loop() {}
EOF

# .gitignore
cat > .gitignore << 'EOF'
.pio
.vscode/.browse.c_cpp.db*
.vscode/c_cpp_properties.json
.vscode/launch.json
.vscode/ipch
.DS_Store
EOF

# README.md
cat > README.md << EOF
# LAB$lab - ESP32 + PlatformIO

## Commands
\`\`\`bash
pio run              # build
pio run -t upload    # upload
pio device monitor   # serial
pio test             # unit tests
\`\`\`
EOF

# GitHub Actions
cat > .github/workflows/grade.yml << 'EOF'
name: Build

on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"
      - name: Install PlatformIO
        run: pip install platformio
      - name: Build
        run: pio run
EOF

# placeholders
echo "Project headers go here" > include/README
echo "Private libraries go here" > lib/README

Notes for ESP32 + PlatformIO​

ItemRecommendation
Boardesp32dev is the most common. Change to esp32-s3-devkitc-1, az-delivery-devkit-v4, etc. if needed
CICan only compile (no real hardware). Use pio run
Unit tests on devicepio test (requires connected board)
Native testsAdd a [env:native] environment if you want tests without hardware
Última atualização em por Adriano Ruseler