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 (
elt73a-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.3), 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.
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.2 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.3 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/ELT73A-S22-2026-2/lab01-grupo-a
- Commits: https://github.com/ELT73A-S22-2026-2/lab01-grupo-a/commits/main/
- Acessos: ACESSO-LAB01.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-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%\ELT73AS22\lab01-grupo-a" && code . --profile "ESP32IO"
- Grupo: Grupo-B (slug:
grupo-b) - Repositório: https://github.com/ELT73A-S22-2026-2/lab01-grupo-b
- Commits: https://github.com/ELT73A-S22-2026-2/lab01-grupo-b/commits/main/
- Acessos: ACESSO-LAB01.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-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%\ELT73AS22\lab01-grupo-b" && code . --profile "ESP32IO"
- Grupo: Grupo-C (slug:
grupo-c) - Repositório: https://github.com/ELT73A-S22-2026-2/lab01-grupo-c
- Commits: https://github.com/ELT73A-S22-2026-2/lab01-grupo-c/commits/main/
- Acessos: ACESSO-LAB01.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-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%\ELT73AS22\lab01-grupo-c" && code . --profile "ESP32IO"
- Grupo: Grupo-D (slug:
grupo-d) - Repositório: https://github.com/ELT73A-S22-2026-2/lab01-grupo-d
- Commits: https://github.com/ELT73A-S22-2026-2/lab01-grupo-d/commits/main/
- Acessos: ACESSO-LAB01.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-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%\ELT73AS22\lab01-grupo-d" && code . --profile "ESP32IO"
- Grupo: Grupo-E (slug:
grupo-e) - Repositório: https://github.com/ELT73A-S22-2026-2/lab01-grupo-e
- Commits: https://github.com/ELT73A-S22-2026-2/lab01-grupo-e/commits/main/
- Acessos: ACESSO-LAB01.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-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%\ELT73AS22\lab01-grupo-e" && code . --profile "ESP32IO"
- Grupo: Grupo-F (slug:
grupo-f) - Repositório: https://github.com/ELT73A-S22-2026-2/lab01-grupo-f
- Commits: https://github.com/ELT73A-S22-2026-2/lab01-grupo-f/commits/main/
- Acessos: ACESSO-LAB01.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-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%\ELT73AS22\lab01-grupo-f" && code . --profile "ESP32IO"
- Grupo: Grupo-G (slug:
grupo-g) - Repositório: https://github.com/ELT73A-S22-2026-2/lab01-grupo-g
- Commits: https://github.com/ELT73A-S22-2026-2/lab01-grupo-g/commits/main/
- Acessos: ACESSO-LAB01.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-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%\ELT73AS22\lab01-grupo-g" && code . --profile "ESP32IO"
- Grupo: Grupo-H (slug:
grupo-h) - Repositório: https://github.com/ELT73A-S22-2026-2/lab01-grupo-h
- Commits: https://github.com/ELT73A-S22-2026-2/lab01-grupo-h/commits/main/
- Acessos: ACESSO-LAB01.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-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%\ELT73AS22\lab01-grupo-h" && code . --profile "ESP32IO"
- Grupo: Grupo-I (slug:
grupo-i) - Repositório: https://github.com/ELT73A-S22-2026-2/lab01-grupo-i
- Commits: https://github.com/ELT73A-S22-2026-2/lab01-grupo-i/commits/main/
- Acessos: ACESSO-LAB01.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-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%\ELT73AS22\lab01-grupo-i" && code . --profile "ESP32IO"
- Grupo: Grupo-J (slug:
grupo-j) - Repositório: https://github.com/ELT73A-S22-2026-2/lab01-grupo-j
- Commits: https://github.com/ELT73A-S22-2026-2/lab01-grupo-j/commits/main/
- Acessos: ACESSO-LAB01.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-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%\ELT73AS22\lab01-grupo-j" && code . --profile "ESP32IO"
- Grupo: Grupo-K (slug:
grupo-k) - Repositório: https://github.com/ELT73A-S22-2026-2/lab01-grupo-k
- Commits: https://github.com/ELT73A-S22-2026-2/lab01-grupo-k/commits/main/
- Acessos: ACESSO-LAB01.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-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%\ELT73AS22\lab01-grupo-k" && code . --profile "ESP32IO"
- Grupo: Grupo-L (slug:
grupo-l) - Repositório: https://github.com/ELT73A-S22-2026-2/lab01-grupo-l
- Commits: https://github.com/ELT73A-S22-2026-2/lab01-grupo-l/commits/main/
- Acessos: ACESSO-LAB01.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-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%\ELT73AS22\lab01-grupo-l" && code . --profile "ESP32IO"
- Grupo: Grupo-M (slug:
grupo-m) - Repositório: https://github.com/ELT73A-S22-2026-2/lab01-grupo-m
- Commits: https://github.com/ELT73A-S22-2026-2/lab01-grupo-m/commits/main/
- Acessos: ACESSO-LAB01.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-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%\ELT73AS22\lab01-grupo-m" && code . --profile "ESP32IO"
- Grupo: Grupo-X (slug:
grupo-x) - Repositório: https://github.com/ELT73A-S22-2026-2/lab01-grupo-x
- Commits: https://github.com/ELT73A-S22-2026-2/lab01-grupo-x/commits/main/
- Acessos: ACESSO-LAB01.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-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%\ELT73AS22\lab01-grupo-x" && code . --profile "ESP32IO"
- Grupo: Grupo-P (slug:
grupo-p) - Repositório: https://github.com/ELT73A-S22-2026-2/lab01-grupo-p
- Commits: https://github.com/ELT73A-S22-2026-2/lab01-grupo-p/commits/main/
- Acessos: ACESSO-LAB01.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-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%\ELT73AS22\lab01-grupo-p" && code . --profile "ESP32IO"
- Grupo: Grupo-N (slug:
grupo-n) - Repositório: https://github.com/ELT73A-S22-2026-2/lab01-grupo-n
- Commits: https://github.com/ELT73A-S22-2026-2/lab01-grupo-n/commits/main/
- Acessos: ACESSO-LAB01.md
1. Crie e entre na pasta-mãe da disciplina:
mkdir "%USERPROFILE%\ELT73AS22" & cd /d "%USERPROFILE%\ELT73AS22"
2. Clone e entre no repositório do laboratório:
git clone https://github.com/ELT73A-S22-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%\ELT73AS22\lab01-grupo-n" && code . --profile "ESP32IO"
2.4 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.5 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, autenticacao 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, autenticacao 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 10, 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 |
| 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 elt73a-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 |
| 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
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.