Laboratório 01
Checklist — ambiente de desenvolvimento (parte 1): Git, GitHub e VS Code
- VS Code, Git, GitHub CLI (
gh) e Python 3 instalados (Parte 1) - Identidade do Git configurada,
ghautenticado, repositório do grupo clonado e versões registradas emevidencias/t1-ambiente.txt(T1) -
README.mddo grupo com os integrantes e o primeiropush(T2) - Cada integrante com um pull request aprovado, e um conflito de merge resolvido (T3)
-
README.mdcom badges, um diagrama Mermaid e uma expressão matemática, entregue por issue → branch → pull request que fecha a issue (T4) - Previsões P1–P3 respondidas no
README.md - Nenhum
push --force; cada tarefa num commitTn: - Logout do Git e do
ghno computador do laboratório
T1…T4 = 100 pts (esta aula não tem desafios): T1 15 · T2 20 · T3 30 · T4 35. O autograder
normaliza para 0–10. Vale o commit Tn: mais recente de cada tarefa.
Confira o ambiente (faça a configuração uma vez por máquina; a verificação, a cada aula):
Verificação rápida das versões instaladas:
git -v & gh --version & code -v & py --version & pio --version & wokwi-cli -V & wsl --version & docker --version
Verificação rápida de autenticação e alias:
git config --get-regexp "^(user|alias)\." & gh auth status & code --list-extensions --profile "ESP32IO"
Adicionar o comando git conferir:
git config --global alias.conferir "!f() { r=$(pwd -W 2>/dev/null || pwd); echo raiz do repositorio: $r; test -z $GIT_PREFIX || echo ATENCAO: o terminal esta em $GIT_PREFIX, fora da raiz. Antes do git add, rode: cd /d $r; test $# -eq 0 && return; for a in $@; do if [ -e $a ]; then echo ok $a; else echo FALTA $a; fi; done; echo == mudancas desde o ultimo commit:; git status --short --ignored -- $@; }; f"
Configuração do ambiente de desenvolvimento
- Git SCM
- GitHub CLI
- Python
- VS Code
- PlatformIO
- Wokwi
- Drivers
- Docker
- GCC
O Git é a ferramenta de gerenciamento de código-fonte mais utilizada por desenvolvedores profissionais.
O GitHub CLI traz o GitHub para o seu terminal.
O GitHub CLI é uma ferramenta de linha de comando que permite interagir com o GitHub diretamente pelo terminal. Está disponível para Windows, macOS e Linux.
winget install --id GitHub.cli -e --source wingetStatus de login do GitHub CLI:
gh auth status
O Python é uma linguagem de programação que permite trabalhar com rapidez e integrar sistemas de forma mais eficaz.
O Python pode ser instalado via winget:
winget install Python.Python.3.14Verifique a versão instalada:
py --version && python --version && pip --versionInstale as dependências utilizadas no curso:
py -m pip install bcrypt
Visual Studio Code: IDE e Editor de Código para Desenvolvimento de Software.
O VS Code é um editor de código-fonte gratuito criado pela Microsoft para Windows, Linux e macOS. Inclui suporte para depuração, controle Git integrado, realce de sintaxe, conclusão inteligente de código, snippets e refatoração de código.
winget install --id Microsoft.VisualStudioCode -e --source wingetExtensões instaladas do Visual Studio Code para o perfil ESP32IO:
code --list-extensions --profile "ESP32IO"Configurar o terminal do VS Code. No arquivo
.vscode/settings.json:{"terminal.integrated.defaultProfile.windows": "Command Prompt"}
PlatformIO IDE para VSCode: Sua porta de entrada para a excelência no desenvolvimento de software embarcado.
PlatformIO IDE para VSCode Desbloqueie o verdadeiro potencial do desenvolvimento de software embarcado com o ecossistema colaborativo do PlatformIO, adotando princípios declarativos, metodologias orientadas a testes e toolchains modernas para um sucesso incomparável.
code --install-extension platformio.platformio-ide --profile "ESP32IO"Acrescente
%USERPROFILE%\.platformio\penv\Scriptsao PATH do usuário (rode uma vez só):powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('Path', [Environment]::GetEnvironmentVariable('Path','User') + ';' + $env:USERPROFILE + '\.platformio\penv\Scripts', 'User')"Inicie o projeto no PlatformIO (Arduino):
pio project init -b esp32dev -O "framework=arduino" -O "monitor_speed=115200" --ide vscode --sample-codeInicie o projeto no PlatformIO (Espressif):
pio project init -b esp32dev -O "framework=espidf" -O "monitor_speed=115200" --ide vscode --sample-codeSystem Prune:
pio system prune -f
Wokwi para VSCode: Simulador de sistemas embarcados e IoT com suporte para ESP32.
Wokwi para VSCode executa a simulação dentro do VS Code, utilizando os binários compilados pelo PlatformIO.
code --install-extension wokwi.wokwi-vscode --profile "ESP32IO"Wokwi CLI: Baixe via GitHub.
curl -L -o "%USERPROFILE%\.platformio\penv\Scripts\wokwi-cli.exe" "https://github.com/wokwi/wokwi-cli/releases/latest/download/wokwi-cli-win-x64.exe"wokwi-cli -hObtenha seu token em https://wokwi.com/dashboard/ci:
setx WOKWI_CLI_TOKEN "wok_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
- Conecte o ESP32 ao computador via USB.
- Abra o Gerenciador de Dispositivos (clique com o botão direito no Menu Iniciar → Gerenciador de Dispositivos).
- Expanda a seção Portas (COM e LPT).
- Procure por um dispositivo similar a:
- Silicon Labs CP210x USB to UART Bridge (COMx)
- Driver Windows CH340/CH341 USB para porta serial
- FTDI ou “Dispositivo Serial USB (COMx)”
Anote o número da porta (ex: COM4, COM6, COM12). Se não aparecer nenhuma porta nova, o driver não está instalado. Baixe o driver correspondente (CP210x ou CH340) no site do fabricante da placa.
Instale o esptool e identifique o chip:
pip install esptoolesptool chip-id
Docker Desktop & WSL 2: O Docker Desktop no Windows 11 utiliza a arquitetura do WSL 2 para executar containers Linux nativamente com alta performance.
Habilitação e Atualização do WSL 2:
wsl --installwsl --update && wsl --set-default-version 2Instalação do Docker Desktop via Winget:
winget install --id Docker.DockerDesktop -eConfirme no terminal integrado do VS Code:
wsl --version && docker --version && docker compose versionTeste o Docker:
docker run hello-world
WinLibs (GCC + MinGW-w64): Compilador C/C++ nativo para Windows, usado pelo PlatformIO no ambiente native.
O
pio test -e nativecompila os testes com ogcc/g++do computador, e o PlatformIO não instala esse compilador. Sem ele, aparece o erro'gcc' não é reconhecido como um comando interno.WinLibs: baixe a versão mais recente (x86_64, POSIX, UCRT) via GitHub. É portátil e não precisa de administrador.
powershell -NoProfile -Command "$a = (Invoke-RestMethod https://api.github.com/repos/brechtsanders/winlibs_mingw/releases/latest).assets | Where-Object { $_.name -like 'winlibs-x86_64-posix-seh-gcc-*-mingw-w64ucrt-*.zip' -and $_.name -notlike '*llvm*' } | Select-Object -First 1; curl.exe -L -o (Join-Path $env:TEMP 'winlibs.zip') $a.browser_download_url"Descompacte em
%USERPROFILE%\mingw64e apague o.zip:tar -xf "%TEMP%\winlibs.zip" -C "%USERPROFILE%" && del "%TEMP%\winlibs.zip"Acrescente
%USERPROFILE%\mingw64\binao PATH do usuário (rode uma vez só):powershell -NoProfile -Command "[Environment]::SetEnvironmentVariable('Path', [Environment]::GetEnvironmentVariable('Path','User') + ';' + $env:USERPROFILE + '\mingw64\bin', 'User')"Feche e abra o VS Code de novo para ele ler o novo PATH. Depois confira:
gcc --version
Os laboratórios desta disciplina têm sempre a mesma forma. O grupo recebe um repositório no
GitHub, criado a partir de um template. Ali escreve o firmware do ESP32 no VS Code com o
PlatformIO, simula no Wokwi e entrega cada tarefa num commit Tn:. O autograder lê
esses commits. Mais adiante entram o broker MQTT, o Node-RED, o banco de dados e o CI, todos
rodando sobre as mesmas ferramentas.
Os Labs 01 e 02 preparam esse ambiente. O Lab 01 cuida do Git e do GitHub; o Lab 02, do PlatformIO, do Wokwi e do Docker. Nesta aula:
- você instala e confere as ferramentas;
- o Git passa a saber quem você é, e o GitHub passa a aceitar os seus
push; - o grupo pratica o fluxo que vai usar o semestre inteiro: branch, pull request, revisão e merge, inclusive quando dois mexem na mesma linha;
- o
README.mddo grupo ganha badges, um diagrama e uma fórmula: os recursos de Markdown do GitHub que os relatórios dos próximos labs usam.
Objetivos
- Instalar e verificar o ambiente: VS Code, Git, GitHub CLI e Python.
- Configurar a identidade do Git e autenticar o
gh, sem guardar senha em lugar nenhum. - Usar o fluxo de trabalho em grupo:
clone,commit,push,pull, branch, pull request, revisão e merge. - Resolver um conflito de merge sem perder o trabalho de ninguém.
- Escrever um
README.mdcom diagramas (Mermaid), expressões matemáticas (LaTeX) e badges (Shields.io).
Material
- Computador com Windows 11 e ~5 GB livres. Todos os comandos desta página são para o
Prompt de Comando (
cmd), o terminal padrão do VS Code nesta disciplina. - Uma conta no GitHub, já aceita na organização da disciplina (
ELT85B-N21-2026-2). - Nenhuma placa: os Labs 01 e 02 não precisam de ESP32 físico.
Nos computadores do laboratório o ambiente já vem instalado: faça só a Parte 2 em diante e,
no fim, o logout do Git e do gh. No seu computador, faça tudo, desde a Parte 1. O Lab 02
acrescenta o PlatformIO, o Wokwi e o Docker.
Mapa de tarefas — 4 tarefas · 100 pts
Estrutura de Arquivos do Projeto (no fim da aula)
- ├── 📄.gitignore👈 Verificar
- ├── 📂.vscode
- └── 🔧settings.json👈 Criar Aqui
- ├── 📝README.md👈 Edite Aqui
- └── 📂evidencias
- ├── 📄t1-ambiente.txt👈 Criar Aqui
- ├── 📝t3-presenca.md👈 Criar Aqui
- ├── 📄t3-prs.txt👈 Criar Aqui
- └── 📄t4-readme.png👈 Criar Aqui
Parte 1 — Instalar as ferramentas
Siga as abas da configuração do ambiente, nesta ordem. Cada aba tem o comando de
instalação (winget) e um comando para conferir. Depois de cada instalação, feche e abra o
terminal, para ele achar os programas novos.
| Aba do ambiente | O que fazer no Lab 01 |
|---|---|
| VS Code | instalar e criar o settings.json do terminal (veja 1.1) |
| Git SCM | instalar; a configuração é a Parte 2 |
| GitHub CLI | instalar; o login é a Parte 2 |
| Python | instalar e conferir com py --version |
| PlatformIO, Wokwi, Drivers, Docker | ficam para o Lab 02 |
Os repositórios da disciplina abrem sempre no perfil ESP32IO do VS Code, separado do seu
perfil do dia a dia. Se o perfil ainda não existir, o VS Code o cria vazio; as extensões do
PlatformIO e do Wokwi entram nele no Lab 02.
code --profile "ESP32IO" .
1.1 O terminal do VS Code é o Prompt de Comando
Os comandos desta disciplina são escritos para o Prompt de Comando (cmd). O PowerShell,
padrão do VS Code no Windows, trata aspas, &&, > e %VARIAVEL% de outro jeito, e um comando
copiado daqui pode falhar ou fazer outra coisa. Por isso, cada repositório tem o arquivo
.vscode/settings.json:
{
"terminal.integrated.defaultProfile.windows": "Command Prompt"
}
Crie o arquivo pelo VS Code (Explorer → nova pasta .vscode → novo arquivo
settings.json) depois de clonar o repositório (2.4), e abra um terminal novo (Ctrl+Shift+`).
O nome do terminal, à direita, tem de ser cmd, e o prompt fica assim:
Microsoft Windows [versão 10.0.26100.xxxx]
(c) Microsoft Corporation. Todos os direitos reservados.
C:\Users\aluno\lab01-grupo-x>
No cmd não existe comentário com #: o texto seria passado ao comando. Nesta página, as
explicações estão fora dos blocos de comando, ou em linhas rem.
Parte 2 — Identidade, autenticação e clone
2.1 Quem você é para o Git
Cada commit leva um nome e um e-mail. O GitHub usa o e-mail para ligar o commit à sua conta: é assim que o autograder e o professor sabem quem fez o quê no grupo.
git config --global user.name "Seu Nome Completo"
git config --global user.email "12345678+seu-usuario@users.noreply.github.com"
git config --global init.defaultBranch main
git config --global pull.rebase false
git config --global core.autocrlf true
git config --global --list
O e-mail ...@users.noreply.github.com está em GitHub → Settings → Emails ("Keep my email
address private"). Com ele, o seu e-mail pessoal não fica público no histórico do repositório.
O pull.rebase false faz o git pull juntar por merge (o fluxo desta disciplina), e o
core.autocrlf true converte os fins de linha do Windows (CRLF) para LF no repositório, e o
inverso na sua pasta. O comando git config --list --show-origin da aba Git SCM mostra de
qual arquivo vem cada configuração.
2.2 O comando git conferir
Em todas as tarefas da disciplina, antes do commit Tn:, o roteiro manda conferir os arquivos
com git conferir. É um alias do Git (um comando que você mesmo cria), configurado uma vez:
git config --global alias.conferir "!f() { r=$(pwd -W 2>/dev/null || pwd); echo raiz do repositorio: $r; test -z $GIT_PREFIX || echo ATENCAO: o terminal esta em $GIT_PREFIX, fora da raiz. Antes do git add, rode: cd /d $r; test $# -eq 0 && return; for a in $@; do if [ -e $a ]; then echo ok $a; else echo FALTA $a; fi; done; echo == mudancas desde o ultimo commit:; git status --short --ignored -- $@; }; f"
Depois, git conferir seguido dos arquivos da tarefa, de qualquer pasta do repositório:
raiz do repositorio: C:/Users/aluno/lab01-grupo-x
ok README.md
FALTA evidencias/t1-ambiente.txt
== mudancas desde o ultimo commit:
M README.md
| Na saída | Quer dizer |
|---|---|
ATENCAO: o terminal… | o terminal está numa subpasta: rode o cd /d indicado antes do git add |
FALTA | o arquivo não está nesse caminho (pasta errada, nome errado, .txt.txt) |
?? / M | arquivo novo / modificado: entra no commit |
!! | bloqueado pelo .gitignore: o git add vai falhar |
| arquivo não aparece | já está no Git e não mudou desde o último commit |
O Git roda o alias na raiz do repositório, mesmo que você esteja em src\ ou
evidencias\, por isso os caminhos são sempre a partir da raiz e com /.
P1: e se o user.email estiver errado (o e-mail do computador do laboratório, por
exemplo)? O commit é aceito pelo GitHub? O que aparece no lugar do seu avatar na lista de
commits, e o que isso significa para a sua nota num trabalho em grupo? Confira na T2.
2.3 Autenticar o gh
O GitHub não aceita a senha da conta no git push. Quem autentica é o GitHub CLI: ele
abre o navegador, você autoriza, e ele passa a atender o Git como credential helper.
gh auth login --hostname github.com --git-protocol https --web
gh auth setup-git
gh auth status
O gh auth login mostra um código de 8 caracteres e abre o navegador: cole o código e
autorize. O gh auth setup-git faz o git push usar esse login.
github.com
✓ Logged in to github.com account seu-usuario (keyring)
- Active account: true
- Git operations protocol: https
- Token: gho_************************************
No laboratório, o login fica guardado no computador até você sair. Antes de ir embora, faça o logout do fim desta página. Quem usar a máquina depois teria acesso de escrita aos seus repositórios.
2.4 Clonar o repositório do grupo
Escolha o grupo e rode o comando gerado. Ele cria o repositório do grupo a partir do template (na primeira vez) e o clona no seu computador:
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
- Grupo: Grupo-A (slug:
grupo-a) - Repositório: https://github.com/ELT85B-N21-2026-2/lab01-grupo-a
- Commits: https://github.com/ELT85B-N21-2026-2/lab01-grupo-a/commits/main/
- Acessos: ACESSO-LAB01.md
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/lab01-grupo-a.git && cd lab01-grupo-a
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab01-grupo-a" && code . --profile "ESP32IO"
- Grupo: Grupo-B (slug:
grupo-b) - Repositório: https://github.com/ELT85B-N21-2026-2/lab01-grupo-b
- Commits: https://github.com/ELT85B-N21-2026-2/lab01-grupo-b/commits/main/
- Acessos: ACESSO-LAB01.md
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/lab01-grupo-b.git && cd lab01-grupo-b
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab01-grupo-b" && code . --profile "ESP32IO"
- Grupo: Grupo-C (slug:
grupo-c) - Repositório: https://github.com/ELT85B-N21-2026-2/lab01-grupo-c
- Commits: https://github.com/ELT85B-N21-2026-2/lab01-grupo-c/commits/main/
- Acessos: ACESSO-LAB01.md
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/lab01-grupo-c.git && cd lab01-grupo-c
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab01-grupo-c" && code . --profile "ESP32IO"
- Grupo: Grupo-D (slug:
grupo-d) - Repositório: https://github.com/ELT85B-N21-2026-2/lab01-grupo-d
- Commits: https://github.com/ELT85B-N21-2026-2/lab01-grupo-d/commits/main/
- Acessos: ACESSO-LAB01.md
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/lab01-grupo-d.git && cd lab01-grupo-d
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab01-grupo-d" && code . --profile "ESP32IO"
- Grupo: Grupo-E (slug:
grupo-e) - Repositório: https://github.com/ELT85B-N21-2026-2/lab01-grupo-e
- Commits: https://github.com/ELT85B-N21-2026-2/lab01-grupo-e/commits/main/
- Acessos: ACESSO-LAB01.md
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/lab01-grupo-e.git && cd lab01-grupo-e
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab01-grupo-e" && code . --profile "ESP32IO"
- Grupo: Grupo-F (slug:
grupo-f) - Repositório: https://github.com/ELT85B-N21-2026-2/lab01-grupo-f
- Commits: https://github.com/ELT85B-N21-2026-2/lab01-grupo-f/commits/main/
- Acessos: ACESSO-LAB01.md
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/lab01-grupo-f.git && cd lab01-grupo-f
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab01-grupo-f" && code . --profile "ESP32IO"
- Grupo: Grupo-G (slug:
grupo-g) - Repositório: https://github.com/ELT85B-N21-2026-2/lab01-grupo-g
- Commits: https://github.com/ELT85B-N21-2026-2/lab01-grupo-g/commits/main/
- Acessos: ACESSO-LAB01.md
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/lab01-grupo-g.git && cd lab01-grupo-g
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab01-grupo-g" && code . --profile "ESP32IO"
- Grupo: Grupo-H (slug:
grupo-h) - Repositório: https://github.com/ELT85B-N21-2026-2/lab01-grupo-h
- Commits: https://github.com/ELT85B-N21-2026-2/lab01-grupo-h/commits/main/
- Acessos: ACESSO-LAB01.md
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/lab01-grupo-h.git && cd lab01-grupo-h
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab01-grupo-h" && code . --profile "ESP32IO"
- Grupo: Grupo-I (slug:
grupo-i) - Repositório: https://github.com/ELT85B-N21-2026-2/lab01-grupo-i
- Commits: https://github.com/ELT85B-N21-2026-2/lab01-grupo-i/commits/main/
- Acessos: ACESSO-LAB01.md
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/lab01-grupo-i.git && cd lab01-grupo-i
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab01-grupo-i" && code . --profile "ESP32IO"
- Grupo: Grupo-J (slug:
grupo-j) - Repositório: https://github.com/ELT85B-N21-2026-2/lab01-grupo-j
- Commits: https://github.com/ELT85B-N21-2026-2/lab01-grupo-j/commits/main/
- Acessos: ACESSO-LAB01.md
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/lab01-grupo-j.git && cd lab01-grupo-j
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab01-grupo-j" && code . --profile "ESP32IO"
- Grupo: Grupo-K (slug:
grupo-k) - Repositório: https://github.com/ELT85B-N21-2026-2/lab01-grupo-k
- Commits: https://github.com/ELT85B-N21-2026-2/lab01-grupo-k/commits/main/
- Acessos: ACESSO-LAB01.md
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/lab01-grupo-k.git && cd lab01-grupo-k
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab01-grupo-k" && code . --profile "ESP32IO"
- Grupo: Grupo-L (slug:
grupo-l) - Repositório: https://github.com/ELT85B-N21-2026-2/lab01-grupo-l
- Commits: https://github.com/ELT85B-N21-2026-2/lab01-grupo-l/commits/main/
- Acessos: ACESSO-LAB01.md
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/lab01-grupo-l.git && cd lab01-grupo-l
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab01-grupo-l" && code . --profile "ESP32IO"
- Grupo: Grupo-M (slug:
grupo-m) - Repositório: https://github.com/ELT85B-N21-2026-2/lab01-grupo-m
- Commits: https://github.com/ELT85B-N21-2026-2/lab01-grupo-m/commits/main/
- Acessos: ACESSO-LAB01.md
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/lab01-grupo-m.git && cd lab01-grupo-m
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab01-grupo-m" && code . --profile "ESP32IO"
- Grupo: Grupo-X (slug:
grupo-x) - Repositório: https://github.com/ELT85B-N21-2026-2/lab01-grupo-x
- Commits: https://github.com/ELT85B-N21-2026-2/lab01-grupo-x/commits/main/
- Acessos: ACESSO-LAB01.md
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/lab01-grupo-x.git && cd lab01-grupo-x
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab01-grupo-x" && code . --profile "ESP32IO"
- Grupo: Grupo-P (slug:
grupo-p) - Repositório: https://github.com/ELT85B-N21-2026-2/lab01-grupo-p
- Commits: https://github.com/ELT85B-N21-2026-2/lab01-grupo-p/commits/main/
- Acessos: ACESSO-LAB01.md
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/lab01-grupo-p.git && cd lab01-grupo-p
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab01-grupo-p" && code . --profile "ESP32IO"
- Grupo: Grupo-N (slug:
grupo-n) - Repositório: https://github.com/ELT85B-N21-2026-2/lab01-grupo-n
- Commits: https://github.com/ELT85B-N21-2026-2/lab01-grupo-n/commits/main/
- Acessos: ACESSO-LAB01.md
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/lab01-grupo-n.git && cd lab01-grupo-n
3. Abra o conteúdo do repositório no perfil ESP32IO do VS Code e compile:
cd /d "%USERPROFILE%\ELT85BN21\lab01-grupo-n" && code . --profile "ESP32IO"
2.5 Enviar o link do repositório no Moodle
- A
- B
- C
- D
- E
- F
- G
- H
- I
- J
- K
- L
- M
- X
- P
- N
Repositório do Grupo A para Laboratório 01:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo B para Laboratório 01:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo C para Laboratório 01:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo D para Laboratório 01:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo E para Laboratório 01:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo F para Laboratório 01:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo G para Laboratório 01:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo H para Laboratório 01:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo I para Laboratório 01:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo J para Laboratório 01:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo K para Laboratório 01:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo L para Laboratório 01:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo M para Laboratório 01:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo X para Laboratório 01:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo P para Laboratório 01:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
Repositório do Grupo N para Laboratório 01:
- Copie o link do repositório acima.
- Abra a página de envio da atividade no Moodle (botão abaixo).
- Clique em Adicionar envio.
- Cole o link no campo Texto online.
- Clique em Salvar mudanças.
- Confira se o status mudou para Enviado para avaliação.
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.
Entre na pasta clonada e abra-a no VS Code, no perfil da disciplina:
cd lab01-grupo-x
code --profile "ESP32IO" .
Crie o .vscode/settings.json da seção 1.1 e abra um terminal novo (Ctrl+Shift+`): ele
tem de ser o cmd. Os comandos desta aula rodam nele, na raiz do repositório.
2.6 Registrar o ambiente
Gere a evidência com as versões instaladas. O mesmo arquivo ajuda o professor a entender um erro de ambiente depois.
if not exist evidencias mkdir evidencias
(echo == ambiente %DATE% %TIME% & git --version & gh --version & call code --version & py --version & git config --global user.name & git config --global user.email & gh auth status) > evidencias\t1-ambiente.txt 2>&1
type evidencias\t1-ambiente.txt
Os parênteses juntam vários comandos, e o > arquivo 2>&1 grava a saída e os erros de
todos. O call é necessário porque o code é um arquivo .cmd: sem ele, o cmd não volta
para os comandos seguintes.
== ambiente 22/10/2026 14:05:31,27
git version 2.xx.x.windows.1
gh version 2.xx.x (aaaa-mm-dd)
https://github.com/cli/cli/releases/tag/v2.xx.x
1.1xx.x
(hash do commit do VS Code)
x64
Python 3.14.x
Seu Nome Completo
12345678+seu-usuario@users.noreply.github.com
github.com
✓ Logged in to github.com account seu-usuario (keyring)
Confira que todas as linhas têm versão e que o gh está logado. O token aparece mascarado
(gho_****): é seguro registrar.
git add .vscode/settings.json evidencias/t1-ambiente.txt
git commit -m "T1: ambiente registrado"
git push
- ├── 📂.vscode
- └── 🔧settings.json👈 Criar Aqui
- └── 📂evidencias
- └── 📄t1-ambiente.txt👈 Criar Aqui
git conferir .vscode/settings.json evidencias/t1-ambiente.txt
Identidade, autenticação e clone
git conferir .vscode/settings.json evidencias/t1-ambiente.txt
git add .vscode/settings.json evidencias/t1-ambiente.txt && git commit -m "T1: Identidade, autenticação e clone" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T1.
Parte 3 — README e primeiro push
3.1 O ciclo básico
Antes de qualquer coisa: git status. Ele diz em que ramo você está, o que mudou e o que está
pronto para o commit. Use-o o tempo todo.
3.2 O README.md do grupo
Um integrante edita o README.md. Ele vai ser a capa de todos os repositórios da disciplina:
# Lab 01 — Grupo X
## Integrantes
| Nome | Usuário no GitHub |
| ------ | ----------------- |
| Nome 1 | @usuario1 |
| Nome 2 | @usuario2 |
## Previsões
- **P1:** ...
- **P2:** ...
- **P3:** ...
git status
git add README.md
git commit -m "T2: README com os integrantes"
git push
git log --oneline -3
Os outros integrantes trazem o commit para as suas máquinas. O commit T2: aparece no
git log:
git pull
git log --oneline -3
Abra o repositório no navegador (gh repo view --web), clique em commits e confira o P1: o
seu avatar aparece ao lado do commit?
Cada tarefa entregue tem um commit cuja mensagem começa com Tn: (T1:, T2:…). O
autograder procura essas mensagens; vale o commit Tn: mais recente de cada tarefa. Commits
intermediários podem ter qualquer mensagem, desde que descritiva (corrige pino do LED, e não
asdf).
- └── 📝README.md👈 Edite Aqui
git conferir README.md
README e primeiro push
git conferir README.md
git add README.md && git commit -m "T2: README e primeiro push" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T2.
Parte 4 — Branch, pull request e conflito
4.1 Por que não todo mundo direto na main?
Se todos fazem push na main ao mesmo tempo, um sobrescreve ou atrapalha o outro, e ninguém
revisa nada. O fluxo da disciplina é: cada mudança num ramo (branch) → pull request
(PR) → alguém do grupo revisa → merge na main.
4.2 Cada integrante, no seu computador
Todos ao mesmo tempo, cada um no seu computador, partindo da main atualizada:
O git switch -c cria o ramo e muda para ele (troque ana pelo seu nome):
git switch main
git pull
git switch -c t3-ana
Crie (ou edite, se já existir no seu ramo) o arquivo evidencias/t3-presenca.md com exatamente
este conteúdo, trocando só a terceira linha:
# Presença no Lab 01
Quem fez este arquivo: Ana (@usuario-da-ana)
O -u do primeiro push liga o ramo local ao remoto; nos seguintes, basta git push:
git add evidencias/t3-presenca.md
git commit -m "presença da Ana"
git push -u origin t3-ana
gh pr create --base main --title "Presença da Ana" --body "Lab 01, T3"
4.3 Revisar, juntar e resolver o conflito
- Outro integrante abre o PR (
gh pr listegh pr view 1 --web), lê a mudança em Files changed e aprova (Review changes → Approve). - Quem abriu o PR faz o merge:
gh pr merge 1 --merge --delete-branch. - O segundo PR agora mostra This branch has conflicts that must be resolved: os dois ramos mudaram a mesma linha do mesmo arquivo. O dono do segundo PR resolve:
git switch t3-bruno
git pull origin main
git status
O git pull origin main traz a main e avisa CONFLICT (add/add). O git status mostra o
arquivo em both added: os dois ramos criaram o mesmo arquivo com conteúdos diferentes.
No VS Code, o arquivo aparece com as marcas do conflito:
# Presença no Lab 01
<<<<<<< HEAD
Quem fez este arquivo: Bruno (@usuario-do-bruno)
=======
Quem fez este arquivo: Ana (@usuario-da-ana)
>>>>>>> 52f781f13aa312d984ce2e0dc6056b2a83372c98
Entre <<<<<<< HEAD e ======= está a sua versão; entre ======= e >>>>>>>, a que
veio da main (identificada pelo hash do commit).
Resolver é editar o arquivo até ele ficar como deve ser, sem as marcas, mantendo o trabalho dos dois:
# Presença no Lab 01
Quem fez este arquivo: Ana (@usuario-da-ana)
Quem fez este arquivo: Bruno (@usuario-do-bruno)
git add evidencias/t3-presenca.md
git commit -m "resolve conflito com a presença da Ana"
git push
O PR fica verde: revise, aprove e faça o merge como antes. Repita até o PR de todos os
integrantes estar na main.
P2: se a Ana tivesse escrito na linha 3 e o Bruno numa linha 5 nova, haveria
conflito? Por que o Git consegue juntar sozinho mudanças em linhas diferentes, mas não na mesma
linha? E por que o git push --force "resolveria" o conflito do jeito errado?
4.4 Evidência
Com todos os PRs juntados, um integrante atualiza a main e registra:
git switch main
git pull
(gh pr list --state merged & echo. & git log --oneline --graph -15) > evidencias\t3-prs.txt 2>&1
type evidencias\t3-prs.txt
git add evidencias/t3-prs.txt
git commit -m "T3: PRs de todos e conflito resolvido"
git push
- └── 📂evidencias
- ├── 📝t3-presenca.md👈 Criar Aqui
- └── 📄t3-prs.txt👈 Criar Aqui
git conferir evidencias/t3-presenca.md evidencias/t3-prs.txt
Branch, pull request e conflito
git conferir evidencias/t3-presenca.md evidencias/t3-prs.txt
git add evidencias/t3-presenca.md evidencias/t3-prs.txt && git commit -m "T3: Branch, pull request e conflito" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T3.
Parte 5 — Markdown avançado no GitHub
O GitHub renderiza, além do Markdown comum, três recursos que os relatórios desta disciplina
usam o tempo todo: diagramas, expressões matemáticas e badges. Os três são texto
puro no arquivo: entram no Git, aparecem no diff do PR e são revisados como código.
5.1 Criando diagramas
Um bloco de código com a linguagem mermaid vira um diagrama. Um fluxograma simples:
```mermaid
graph TD;
A-->B;
A-->C;
B-->D;
C-->D;
```
O GitHub mostra:
O mesmo Mermaid desenha os outros diagramas desta página: flowchart, sequenceDiagram e
gitGraph. Os diagramas dos labs seguintes (circuitos MQTT, fluxos do Node-RED) vão para o
README.md assim.
5.2 Escrevendo expressões matemáticas
O GitHub usa a sintaxe do LaTeX (renderizada pelo MathJax):
| Forma | Uso |
|---|---|
$ ... $ | expressão na linha do texto |
$$ ... $$ | expressão em bloco, numa linha própria |
bloco de código com a linguagem math | bloco, sem conflito com o resto do Markdown (_, *, \) |
Por exemplo, a desigualdade de Cauchy-Schwarz. O \ no fim da linha do título força a
quebra de linha:
**The Cauchy-Schwarz Inequality**\
$$\left( \sum_{k=1}^n a_k b_k \right)^2 \leq \left( \sum_{k=1}^n a_k^2 \right) \left( \sum_{k=1}^n b_k^2 \right)$$
E uma conta que aparece no Lab 02: o resistor que limita a corrente do LED no GPIO2 (3,3 V, LED vermelho com ~2 V, corrente de ~6 mA):
O resistor do LED vale $R = \frac{V_{CC} - V_F}{I_F}$:
```math
R = \frac{3{,}3\ \text{V} - 2{,}0\ \text{V}}{6\ \text{mA}} \approx 217\ \Omega \;\Rightarrow\; 220\ \Omega
```
5.3 Static Badge
Um badge é uma imagem gerada pela URL: https://img.shields.io/badge/<rótulo>-<mensagem>-<cor>.
No Markdown, entra como qualquer imagem ():




| Na URL | Vira no badge |
|---|---|
_ | espaço (LAB_01 → "LAB 01") |
__ | um _ |
-- | um - (um - sozinho separa rótulo, mensagem e cor) |
%20 | espaço |
?logo=... | o ícone de um serviço (github, espressif, docker, mqtt…) |
&style=... | o estilo: flat, flat-square, for-the-badge… |
Um badge estático mostra só o que está escrito na URL: o LAB_01-OK continua verde mesmo
que nada funcione. No Lab 11, o CI ganha um badge dinâmico, que muda de cor sozinho quando
o build quebra.
Projeto integrador — README por issue e pull request
Num projeto real, o trabalho começa por uma issue (o que precisa ser feito), segue num
ramo e termina num PR que fecha a issue quando entra na main. Aqui, a issue é deixar
o README.md do grupo com a cara dos relatórios da disciplina.
Requisitos
-
Issue. Um integrante abre a issue:
Terminal (cmd)gh issue create --title "README com badges, diagrama e fórmula" --body "Badges no topo, diagrama Mermaid do fluxo do grupo e a fórmula do resistor do LED."gh issue listAnote o número da issue (ex.:
#3). -
Ramo. Crie o ramo
t4-readmea partir damainatualizada:Terminal (cmd)git switch maingit pullgit switch -c t4-readme -
README.md. Acrescente, mantendo os integrantes e as previsões:- logo abaixo do título, pelo menos dois badges: um com o nome do grupo e um de status
do Lab 01 (
TODOem vermelho, por enquanto); - uma seção Fluxo de trabalho com um diagrama Mermaid (
flowchartougitGraph) do caminho issue → branch → PR → revisão → merge que o grupo usou; - uma seção Fórmulas com a conta do resistor do LED da Parte 5.2, em bloco.
README.md (início)# Lab 01 — Grupo X - logo abaixo do título, pelo menos dois badges: um com o nome do grupo e um de status
do Lab 01 (
-
Conferir antes do PR. Veja o resultado em dois lugares:
- no VS Code, com o preview do Markdown (Ctrl+Shift+V);
- no GitHub, no próprio ramo:
Terminal (cmd)git add README.mdgit commit -m "README com badges, diagrama e fórmula"git push -u origin t4-readmegh repo view --web --branch t4-readmeCorrija o que não renderizar (um
-a mais no badge, uma}faltando na fórmula) e façagit pushde novo. Quando estiver certo no GitHub, troque o badge do Lab 01 paraLAB_01-OK-greene salve uma captura da página do ramo, com os badges, o diagrama e a fórmula, emevidencias/t4-readme.png. -
Commit e PR.
Terminal (cmd)git add README.md evidencias/t4-readme.pnggit commit -m "T4: README com badges, diagrama e fórmula (closes #3)"git pushgh pr create --base main --title "README com badges, diagrama e fórmula" --body "Closes #3" -
Revisão e merge. Outro integrante revisa: em Files changed, o botão de rich diff (ícone de documento) mostra o README renderizado. Aprova e faz o merge. A issue fecha sozinha por causa do
Closes #3. Confira comgh issue list --state closed. -
No
README.md: as respostas de P1, P2 e P3 (num PR, como todo o resto).
P3: (a) o preview do VS Code mostra a fórmula? E o diagrama Mermaid? E o GitHub mostra os
dois? Por que o mesmo arquivo README.md aparece diferente em cada lugar? (b) Os badges
aparecem com o computador sem internet? O que isso diz sobre onde a imagem é gerada? (c) Se
o firmware do Lab 02 parar de compilar, o badge LAB_01-OK-green muda de cor? Então, o que ele
garante para quem lê o README?
- ├── 📝README.md👈 Edite Aqui
- └── 📂evidencias
- └── 📄t4-readme.png👈 Criar Aqui
git conferir README.md evidencias/t4-readme.png
README com diagramas, fórmulas e badges por issue e pull request
git conferir README.md evidencias/t4-readme.png
git add README.md evidencias/t4-readme.png && git commit -m "T4: README com diagramas, fórmulas e badges por issue e pull request" && git push
git status -sb && git log -1 --stat --oneline
Só faça o commit se o passo 1 não mostrar ATENCAO (terminal fora da raiz do repositório) nem FALTA. Nas mudanças, ?? é arquivo novo e M, modificado: os dois entram no commit. !! é arquivo bloqueado pelo .gitignore, e o git add vai falhar. Um arquivo que não aparece ali já está no Git e não mudou desde o último commit. No passo 3, a primeira linha não pode ter [ahead (commit ainda não enviado), e a lista tem de trazer os arquivos da T4.
Referência rápida
| Para… | Comando |
|---|---|
| Ver em que ramo estou e o que mudou | git status |
| Conferir os arquivos de uma tarefa | git conferir <arquivos> (2.2) |
| Trazer o que os outros enviaram | git pull |
| Salvar e enviar | git add <arquivos> → git commit -m "msg" → git push |
| Criar um ramo e mudar para ele | git switch -c nome |
Voltar para a main atualizada | git switch main → git pull |
| Histórico resumido | git log --oneline --graph -15 |
| Abrir o repositório no navegador | gh repo view --web · num ramo: gh repo view --web --branch nome |
| Abrir / listar / juntar PRs | gh pr create · gh pr list · gh pr merge N --merge --delete-branch |
| Issues | gh issue create · gh issue list |
| Desfazer mudanças não commitadas num arquivo | git restore <arquivo> |
| Preview do Markdown no VS Code | Ctrl+Shift+V (ou Ctrl+K V, ao lado) |
| Markdown no GitHub | Sintaxe |
|---|---|
| Diagrama | bloco de código com a linguagem mermaid |
| Fórmula na linha | $ ... $ |
| Fórmula em bloco | $$ ... $$ ou bloco de código com a linguagem math |
| Badge estático |  |
| Problema | O que fazer |
|---|---|
Permission denied / 403 no push | gh auth status; confira se você está no time do grupo; peça ao professor para conferir o acesso |
Repository not found | nome errado ou você ainda não é membro da organização: gh repo view ELT85B-N21-2026-2/lab01-grupo-x |
rejected ... (fetch first) no push | alguém enviou antes: git pull, resolva o conflito se houver, e git push de novo. Nunca --force |
| Commit sem o seu avatar no GitHub | user.email diferente do da conta (P1). Corrija o git config para os próximos commits |
git: 'conferir' is not a git command | falta o alias (ou a configuração global foi apagada): rode de novo o comando da seção 2.2 |
| O terminal abre como PowerShell | falta o .vscode/settings.json (1.1), ou a pasta aberta não é a raiz do repositório. Abra um terminal novo depois de criar o arquivo |
Comando com 'aspas simples' falha | no cmd, só as aspas duplas agrupam um texto |
| Diagrama aparece como código no GitHub | o bloco tem de começar com três crases e mermaid, e a sintaxe tem de estar certa: o GitHub mostra o erro no lugar do diagrama |
Fórmula aparece com $ ou sem os índices | o Markdown comeu um _ ou \: use o bloco com a linguagem math |
| Badge quebrado ou com texto errado | um - a mais na URL: no rótulo e na mensagem, - vira -- e espaço vira _ |
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
Antes de sair, faça logout para não deixar sua conta do GitHub ativa nesta máquina. Rode os comandos abaixo no Prompt de Comando (cmd), não no PowerShell.
1. Apague a credencial do GitHub salva pelo git, encerre a sessão do gh e remova seu nome e e-mail da configuração global:
(echo protocol=https&echo host=github.com) | git credential reject
gh auth logout --hostname github.com
git config --global --unset user.name
git config --global --unset user.email
Para conferir, este comando não deve mostrar nada:
cmdkey /list | findstr /i github
2. Pare os containers do lab:
for /f "delims=" %i in ('docker compose ls -q') do docker compose -p %i down
3. No navegador, saia da sua conta em github.com e feche todas as janelas.