Pular para o conteúdo principal

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, gh autenticado, repositório do grupo clonado e versões registradas em evidencias/t1-ambiente.txt (T1)
  • README.md do grupo com os integrantes e o primeiro push (T2)
  • Cada integrante com um pull request aprovado, e um conflito de merge resolvido (T3)
  • README.md com 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 commit Tn:
  • Logout do Git e do gh no computador do laboratório
Pontuação

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.

Antes de começar

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​

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

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:

  1. você instala e confere as ferramentas;
  2. o Git passa a saber quem você é, e o GitHub passa a aceitar os seus push;
  3. 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;
  4. o README.md do 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.md com 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.
Computador do laboratório × o seu

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)
📂 lab01-grupo-x/
  • ├── 📄.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 ambienteO que fazer no Lab 01
VS Codeinstalar e criar o settings.json do terminal (veja 1.1)
Git SCMinstalar; a configuração é a Parte 2
GitHub CLIinstalar; o login é a Parte 2
Pythoninstalar e conferir com py --version
PlatformIO, Wokwi, Drivers, Dockerficam 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.

Prompt de Comando (cmd), na pasta do repositório
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:

.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:

Terminal do VS Code
Microsoft Windows [versão 10.0.26100.xxxx]
(c) Microsoft Corporation. Todos os direitos reservados.

C:\Users\aluno\lab01-grupo-x>
Comentários no cmd

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.

Terminal (cmd)
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:

Terminal (cmd)
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:

git conferir README.md evidencias/t1-ambiente.txt (exemplo)
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ídaQuer dizer
ATENCAO: o terminal…o terminal está numa subpasta: rode o cd /d indicado antes do git add
FALTAo arquivo não está nesse caminho (pasta errada, nome errado, .txt.txt)
?? / Marquivo novo / modificado: entra no commit
!!bloqueado pelo .gitignore: o git add vai falhar
arquivo não aparecejá 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 /.

Preveja antes de rodar

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.

Terminal (cmd)
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.

Saída esperada (trecho)
github.com
✓ Logged in to github.com account seu-usuario (keyring)
- Active account: true
- Git operations protocol: https
- Token: gho_************************************
Computador compartilhado

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:

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"

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

  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.

Entre na pasta clonada e abra-a no VS Code, no perfil da disciplina:

Terminal (cmd)
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.

Terminal do VS Code (cmd), na raiz do repositório
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.

evidencias/t1-ambiente.txt (trecho; as versões variam)
== 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.

Terminal (cmd)
git add .vscode/settings.json evidencias/t1-ambiente.txt
git commit -m "T1: ambiente registrado"
git push
📂 lab01-grupo-x/
  • ├── 📂.vscode
    • └── 🔧settings.json👈 Criar Aqui
  • └── 📂evidencias
    • └── 📄t1-ambiente.txt👈 Criar Aqui
git conferir .vscode/settings.json evidencias/t1-ambiente.txt
Ponto de commit · T1 (15 pts) #

Identidade, autenticação e clone

1. Conferir os arquivos
git conferir .vscode/settings.json evidencias/t1-ambiente.txt
2. Commit T1 e push
git add .vscode/settings.json evidencias/t1-ambiente.txt && git commit -m "T1: Identidade, autenticação e clone" && git push
3. Conferir o commit e o envio
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:

README.md
# Lab 01 — Grupo X

## Integrantes

| Nome | Usuário no GitHub |
| ------ | ----------------- |
| Nome 1 | @usuario1 |
| Nome 2 | @usuario2 |

## Previsões

- **P1:** ...
- **P2:** ...
- **P3:** ...
Terminal (cmd)
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:

Terminal (cmd, cada um dos outros integrantes)
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?

Mensagens de commit nesta disciplina

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).

📂 lab01-grupo-x/
  • └── 📝README.md👈 Edite Aqui
git conferir README.md
Ponto de commit · T2 (20 pts) #

README e primeiro push

1. Conferir os arquivos
git conferir README.md
2. Commit T2 e push
git add README.md && git commit -m "T2: README e primeiro push" && git push
3. Conferir o commit e o envio
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):

Terminal (cmd, cada integrante)
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:

evidencias/t3-presenca.md
# 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:

Terminal (cmd)
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​

  1. Outro integrante abre o PR (gh pr list e gh pr view 1 --web), lê a mudança em Files changed e aprova (Review changes → Approve).
  2. Quem abriu o PR faz o merge: gh pr merge 1 --merge --delete-branch.
  3. 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:
Terminal (cmd, dono do PR com conflito)
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:

evidencias/t3-presenca.md (durante o 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:

evidencias/t3-presenca.md (resolvido)
# Presença no Lab 01

Quem fez este arquivo: Ana (@usuario-da-ana)
Quem fez este arquivo: Bruno (@usuario-do-bruno)
Terminal (cmd)
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.

Preveja antes de rodar

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:

Terminal (cmd)
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
📂 lab01-grupo-x/
  • └── 📂evidencias
    • ├── 📝t3-presenca.md👈 Criar Aqui
    • └── 📄t3-prs.txt👈 Criar Aqui
git conferir evidencias/t3-presenca.md evidencias/t3-prs.txt
Ponto de commit · T3 (30 pts) #

Branch, pull request e conflito

1. Conferir os arquivos
git conferir evidencias/t3-presenca.md evidencias/t3-prs.txt
2. Commit T3 e push
git add evidencias/t3-presenca.md evidencias/t3-prs.txt && git commit -m "T3: Branch, pull request e conflito" && git push
3. Conferir o commit e o envio
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:

README.md (trecho)
```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):

FormaUso
$ ... $expressão na linha do texto
$$ ... $$expressão em bloco, numa linha própria
bloco de código com a linguagem mathbloco, 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:

README.md (trecho)
**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):

README.md (trecho)
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 (![texto alternativo](url)):

README.md (trecho)
![Version](https://img.shields.io/badge/github-repo-blue?logo=github)
![LAB status](https://img.shields.io/badge/LAB_01-OK-green?logo=github)
![LAB status](https://img.shields.io/badge/LAB_01-OK-blue?logo=github)
![LAB status](https://img.shields.io/badge/LAB_01-TODO-red?logo=github)

Version LAB status LAB status LAB status

Na URLVira no badge
_espaço (LAB_01 → "LAB 01")
__um _
--um - (um - sozinho separa rótulo, mensagem e cor)
%20espaç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​

  1. 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 list

    Anote o número da issue (ex.: #3).

  2. Ramo. Crie o ramo t4-readme a partir da main atualizada:

    Terminal (cmd)
    git switch main
    git pull
    git switch -c t4-readme
  3. 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 (TODO em vermelho, por enquanto);
    • uma seção Fluxo de trabalho com um diagrama Mermaid (flowchart ou gitGraph) 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

    ![Grupo](https://img.shields.io/badge/ELT85B-grupo_X-blue?logo=github)
    ![LAB status](https://img.shields.io/badge/LAB_01-TODO-red?logo=github)
  4. 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.md
    git commit -m "README com badges, diagrama e fórmula"
    git push -u origin t4-readme
    gh repo view --web --branch t4-readme

    Corrija o que não renderizar (um - a mais no badge, uma } faltando na fórmula) e faça git push de novo. Quando estiver certo no GitHub, troque o badge do Lab 01 para LAB_01-OK-green e salve uma captura da página do ramo, com os badges, o diagrama e a fórmula, em evidencias/t4-readme.png.

  5. Commit e PR.

    Terminal (cmd)
    git add README.md evidencias/t4-readme.png
    git commit -m "T4: README com badges, diagrama e fórmula (closes #3)"
    git push
    gh pr create --base main --title "README com badges, diagrama e fórmula" --body "Closes #3"
  6. 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 com gh issue list --state closed.

  7. No README.md: as respostas de P1, P2 e P3 (num PR, como todo o resto).

Preveja antes de rodar

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?

📂 lab01-grupo-x/
  • ├── 📝README.md👈 Edite Aqui
  • └── 📂evidencias
    • └── 📄t4-readme.png👈 Criar Aqui
git conferir README.md evidencias/t4-readme.png
Ponto de commit · T4 (35 pts) #

README com diagramas, fórmulas e badges por issue e pull request

1. Conferir os arquivos
git conferir README.md evidencias/t4-readme.png
2. Commit T4 e push
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
3. Conferir o commit e o envio
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 mudougit status
Conferir os arquivos de uma tarefagit conferir <arquivos> (2.2)
Trazer o que os outros enviaramgit pull
Salvar e enviargit add <arquivos> → git commit -m "msg" → git push
Criar um ramo e mudar para elegit switch -c nome
Voltar para a main atualizadagit switch main → git pull
Histórico resumidogit log --oneline --graph -15
Abrir o repositório no navegadorgh repo view --web · num ramo: gh repo view --web --branch nome
Abrir / listar / juntar PRsgh pr create · gh pr list · gh pr merge N --merge --delete-branch
Issuesgh issue create · gh issue list
Desfazer mudanças não commitadas num arquivogit restore <arquivo>
Preview do Markdown no VS CodeCtrl+Shift+V (ou Ctrl+K V, ao lado)
Markdown no GitHubSintaxe
Diagramabloco 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![alt](https://img.shields.io/badge/rótulo-mensagem-cor)
ProblemaO que fazer
Permission denied / 403 no pushgh auth status; confira se você está no time do grupo; peça ao professor para conferir o acesso
Repository not foundnome errado ou você ainda não é membro da organização: gh repo view ELT85B-N21-2026-2/lab01-grupo-x
rejected ... (fetch first) no pushalguém enviou antes: git pull, resolva o conflito se houver, e git push de novo. Nunca --force
Commit sem o seu avatar no GitHubuser.email diferente do da conta (P1). Corrija o git config para os próximos commits
git: 'conferir' is not a git commandfalta o alias (ou a configuração global foi apagada): rode de novo o comando da seção 2.2
O terminal abre como PowerShellfalta 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' falhano cmd, só as aspas duplas agrupam um texto
Diagrama aparece como código no GitHubo 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 índiceso Markdown comeu um _ ou \: use o bloco com a linguagem math
Badge quebrado ou com texto erradoum - 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
Ao terminar — máquina de laboratório

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.