🤖 ROBÓTICA NO ENSINO FUNDAMENTAL I — 5º ANO ⬤

• Criar um pôster (físico ou digital) que documente o projeto do Semáforo Sonoro de forma clara, atraente e informativa.
• Incluir no pôster elementos obrigatórios: título chamativo, foto do robô montado, diagrama de blocos (entrada → processo → saída), trecho do código, lista de materiais e nome dos integrantes.
• Aplicar princípios de design de comunicação visual: hierarquia, contraste, legibilidade e equilíbrio.
• Desenvolver a identidade visual da equipe, com cores, elementos gráficos e logotipo que representem o projeto.
• Produzir material de apoio para a apresentação na Feira de Robótica, garantindo que o público possa entender o projeto rapidamente.
• Desenvolver habilidades de curadoria e documentação de projetos de engenharia.

📚 Conteúdo Programático

Design de Comunicação Visual:

• Hierarquia visual: organizar informações por importância (título maior, subtítulos, corpo de texto)
• Contraste: usar cores diferentes para destacar elementos importantes
• Legibilidade: escolher fontes e tamanhos adequados para leitura à distância
• Equilíbrio: distribuir elementos de forma harmoniosa no espaço

Documentação de Projetos:

• Como apresentar um projeto de engenharia de forma clara e atraente
• Elementos essenciais: título, imagem, diagrama, código, materiais, autores
• Público-alvo: adaptar a linguagem para diferentes níveis de conhecimento

Diagrama de Blocos:

• Entrada (Input): botões, sensores, dados recebidos
• Processo (Processamento): código, lógica, tomada de decisões
• Saída (Output): LEDs, buzzer, matriz de LEDs, ação do robô

Identidade Visual:

• Logotipo: criar um símbolo que represente o projeto
• Paleta de cores: escolher cores que transmitam a mensagem desejada
• Tipografia: escolher fontes que sejam legíveis e atraentes

📋 Habilidades BNCC e RCP-PR

🛠️ Materiais

Opção Física:

Opção Digital:

Materiais Complementares:

🔧 Montagem do Hardware

Não se aplica - Esta semana é focada em documentação, não em montagem de hardware. No entanto, os alunos devem fotografar o robô (micro:bit + LEDs) para usar no pôster. A foto deve mostrar claramente a montagem, com boa iluminação e fundo neutro.

Dicas para a foto:

• Colocar o robô sobre uma superfície clara (papel branco)
• Iluminar bem, de preferência com luz natural
• Tirar a foto de cima (vista superior) para mostrar todas as conexões
• Incluir uma legenda na foto identificando os componentes

💻 Código Micro:bit

Não há código novo - Apenas o trecho do código do Semáforo que será incluído no pôster. Selecionar o trecho mais importante (a sequência do semáforo) e colocá-lo de forma legível.

Trecho do código a ser incluído no pôster:

// Sequência do Semáforo
acenderLED(ledVerde)   // Sinal VERDE - SIGA
basic.pause(5000)      // 5 segundos

acenderLED(ledAmarelo) // Sinal AMARELO - ATENÇÃO
basic.pause(2000)      // 2 segundos

acenderLED(ledVermelho) // Sinal VERMELHO - PARE
basic.pause(5000)      // 5 segundos

// A sequência se repete automaticamente

Diagrama de Blocos (Entrada → Processo → Saída):

┌─────────────────────────────────────────────────────────────┐
│                    SEMÁFORO SONORO                         │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ENTRADA          PROCESSO              SAÍDA              │
│  (Input)          (Processamento)       (Output)           │
│                                                             │
│  ┌─────────┐     ┌──────────────┐      ┌──────────────┐   │
│  │ Botão   │ ──  │ Código do    │ ──  │ LED VERDE    │   │
│  │ (A/B)   │     │ Semáforo     │      │ (SIGA)       │   │
│  └─────────┘     │ - Sequência  │      └──────────────┘   │
│                  │ - Temporização│      ┌──────────────┐   │
│  ┌─────────┐     │ - Lógica     │ ──  │ LED AMARELO  │   │
│  │ Sensor  │ ──  │ - Condicional│      │ (ATENÇÃO)    │   │
│  │ (Toque) │     └──────────────┘      └──────────────┘   │
│  └─────────┘                            ┌──────────────┐   │
│                                         │ LED VERMELHO │   │
│  ┌─────────┐                            │ (PARE)       │   │
│  │ Tempo   │                            └──────────────┘   │
│  │ (pause) │                            ┌──────────────┐   │
│  └─────────┘                            │ BUZZER       │   │
│                                         │ (Sons)       │   │
│                                         └──────────────┘   │
└─────────────────────────────────────────────────────────────┘

⏱️ Detalhamento Minuto a Minuto (50 min)

♿ Orientações para Adaptações e Inclusão

📊 Critérios Operacionais de Avaliação (com pontuação)

• Ensaio completo da apresentação do projeto (fala + demonstração) com cronômetro, simulando condições reais de Feira.
• Implementar o "Modo Noturno" no semáforo (LED amarelo piscando) usando o botão A do micro:bit.
• Identificar e corrigir falhas no código e na montagem durante o ensaio, documentando os problemas e soluções.
• Praticar técnicas de respiração e controle da ansiedade para apresentações.
• Desenvolver a capacidade de diagnosticar erros e propor soluções rapidamente (depuração).
• Aplicar feedback construtivo entre equipes durante os ensaios.

📚 Conteúdo Programático

Ensaio Simulado:

• Apresentação em condições reais (público, cronômetro, pressão)
• Gestão do tempo: controle de 4 minutos para cada apresentação
• Postura e comunicação: linguagem corporal, contato visual, tom de voz

Resolução de Problemas:

• Diagnosticar e corrigir erros de código e hardware
• Métodos de depuração: verificação passo a passo, teste de componentes individuais
• Documentação de bugs e soluções

Modo Noturno:

• Implementar um novo comportamento no código
• Usar variáveis para controlar diferentes modos
• Condicional: if (modoNoturno) { ... } else { ... }
• Botões como entrada: input.onButtonPressed()

Ansiedade e Performance:

• Técnicas de respiração para reduzir ansiedade
• Mentalidade de crescimento: errar é parte do processo
• Feedback construtivo: dar e receber críticas de forma produtiva

📋 Habilidades BNCC e RCP-PR

🛠️ Materiais

🔧 Montagem do Hardware

Revisão e Teste:

1. Verificar todas as conexões elétricas (LEDs, resistores, buzzer, GND)
2. Testar o código original (semáforo normal)
3. Garantir que o micro:bit está com bateria suficiente

Desafio: Adicionar o "Modo Noturno":

O Modo Noturno é um comportamento onde o semáforo fica com o LED amarelo piscando, indicando atenção em horários de baixo fluxo de veículos. No código, usamos o botão A para ativar/desativar este modo.

💻 Código Micro:bit (Com "Modo Noturno")

// ==============================================================
// PROJETO: SEMÁFORO SONORO COM MODO NOTURNO
// DESCRIÇÃO: 
//   Este projeto simula um semáforo com três LEDs (vermelho, amarelo e verde)
//   e sons associados a cada estado. Além disso, possui um "Modo Noturno"
//   que, quando ativado pelo botão A, faz o LED amarelo piscar continuamente,
//   simulando um semáforo em operação reduzida durante a madrugada.
// 
// AUTOR: Equipe Robô na Veia
// VERSÃO: 2.0 (com Modo Noturno)
// ==============================================================

// ==============================================================
// 1. VARIÁVEIS GLOBAIS
// ==============================================================

// Cada LED está conectado a um pino digital do micro:bit.
// Atribuímos os números dos pinos a nomes simbólicos para facilitar a leitura.
let ledVermelho = 0   // LED vermelho no pino P0 (pino digital 0)
let ledAmarelo = 1    // LED amarelo no pino P1 (pino digital 1)
let ledVerde = 2      // LED verde no pino P2 (pino digital 2)

// Variável booleana (verdadeiro/falso) que controla o modo noturno.
// Inicialmente, o modo noturno está desativado (false).
// Quando o usuário pressionar o botão A, esta variável será invertida.
let modoNoturno = false

// ==============================================================
// 2. FUNÇÃO PARA ACENDER UM LED ESPECÍFICO
// ==============================================================

// Esta função recebe um número de pino (0, 1 ou 2) e acende o LED
// correspondente, garantindo que todos os outros LEDs estejam apagados.
// Isso evita que dois LEDs fiquem acesos ao mesmo tempo.
function acenderLED(pino: number) {
  // Desliga todos os LEDs escrevendo 0 (nível baixo) em cada pino.
  // O comando pins.digitalWritePin(pino, valor) controla o pino:
  //   - valor 0 = desligado (0 volts)
  //   - valor 1 = ligado (3,3 volts)
  pins.digitalWritePin(DigitalPin.P0, 0)
  pins.digitalWritePin(DigitalPin.P1, 0)
  pins.digitalWritePin(DigitalPin.P2, 0)

  // Liga o LED no pino especificado (escreve 1 no pino desejado).
  // Como os outros estão em 0, apenas este LED acende.
  pins.digitalWritePin(pino, 1)
}

// ==============================================================
// 3. FUNÇÃO PARA TOCAR UM SOM
// ==============================================================

// Esta função gera um tom (beep) com uma frequência e duração determinadas.
// O micro:bit possui um alto-falante ou saída para fones de ouvido.
// A frequência é medida em Hertz (Hz) e a duração em milissegundos (ms).
function tocarSom(frequencia: number, duracao: number) {
  // A função playTone da biblioteca 'music' reproduz um tom puro.
  // Exemplo: 523 Hz é a nota Dó (agudo), 262 Hz é Dó grave.
  music.playTone(frequencia, duracao)
}

// ==============================================================
// 4. FUNÇÃO PARA APAGAR TODOS OS LEDs
// ==============================================================

// Função simples que desliga todos os LEDs simultaneamente.
// Útil para o modo noturno, onde o LED amarelo pisca (liga/desliga).
function apagarTodosLEDs() {
  // Escreve 0 em todos os pinos, desligando todos os LEDs.
  pins.digitalWritePin(DigitalPin.P0, 0)
  pins.digitalWritePin(DigitalPin.P1, 0)
  pins.digitalWritePin(DigitalPin.P2, 0)
}

// ==============================================================
// 5. BOTÃO A: ATIVA/DESATIVA O MODO NOTURNO
// ==============================================================

// O micro:bit possui dois botões: A e B. Aqui usamos o botão A como
// um interruptor para o modo noturno.
// A função 'input.onButtonPressed' é executada sempre que o botão é pressionado.
input.onButtonPressed(Button.A, function () {
  // Inverte o valor da variável modoNoturno:
  //   - Se era false, passa para true (ativa o modo noturno)
  //   - Se era true, passa para false (desativa o modo noturno)
  // O operador '!' (negação lógica) inverte o valor booleano.
  modoNoturno = !modoNoturno

  // Feedback visual para o usuário: mostra um ícone na matriz de LEDs
  // do micro:bit para indicar qual modo foi ativado.
  if (modoNoturno) {
    // Se o modo noturno foi ATIVADO, exibe um "V" (check) – símbolo de "SIM".
    // IconNames.Yes é um ícone pré-definido que representa um "V".
    basic.showIcon(IconNames.Yes)
  } else {
    // Se o modo noturno foi DESATIVADO, exibe um "X" – símbolo de "NÃO".
    basic.showIcon(IconNames.No)
  }

  // Aguarda 500 milissegundos (0,5 segundo) para que o usuário veja o ícone.
  basic.pause(500)

  // Limpa a matriz de LEDs (apaga todos os pixels) para não ficar poluído.
  basic.clearScreen()
})

// ==============================================================
// 6. LOOP PRINCIPAL
// ==============================================================

// O bloco 'basic.forever' executa o código dentro dele repetidamente,
// indefinidamente, enquanto o micro:bit estiver ligado.
// É o "loop principal" do programa.
basic.forever(function () {
  // VERIFICAÇÃO: Estamos no Modo Noturno?
  // A variável modoNoturno define qual comportamento o semáforo terá.
  if (modoNoturno) {
    // ---------- MODO NOTURNO: LED AMARELO PISCANDO ----------
    // Neste modo, o semáforo não segue a sequência normal.
    // Apenas o LED amarelo fica piscando (alternando ligado/desligado)
    // para indicar que o trânsito está em operação reduzida.

    // Acende o LED amarelo (pino P1) chamando a função acenderLED
    acenderLED(ledAmarelo)

    // Pausa de 500 ms (meio segundo) – tempo que o LED fica aceso.
    basic.pause(500)

    // Apaga todos os LEDs (incluindo o amarelo).
    apagarTodosLEDs()

    // Pausa de 500 ms – tempo que o LED fica apagado.
    basic.pause(500)

    // O loop se repete: acende -> espera -> apaga -> espera -> ...
    // Isso gera um efeito de pisca-pisca contínuo.
  } else {
    // ---------- MODO NORMAL: SEMÁFORO ----------
    // Funcionamento padrão de um semáforo com três tempos:
    // Verde (5s) -> Amarelo (2s) -> Vermelho (5s) -> (volta ao verde)

    // Sinal VERDE: permite a passagem dos veículos.
    acenderLED(ledVerde)        // Acende o LED verde (pino P2)
    tocarSom(523, 200)          // Reproduz a nota Dó (frequência 523 Hz) por 200 ms
    basic.pause(5000)           // Mantém o verde aceso por 5 segundos

    // Sinal AMARELO: atenção, preparar para parar.
    acenderLED(ledAmarelo)      // Acende o LED amarelo (pino P1)
    tocarSom(392, 200)          // Nota Sol (frequência 392 Hz) por 200 ms
    basic.pause(2000)           // Mantém o amarelo aceso por 2 segundos

    // Sinal VERMELHO: parada obrigatória.
    acenderLED(ledVermelho)     // Acende o LED vermelho (pino P0)
    tocarSom(262, 300)          // Nota Dó grave (frequência 262 Hz) por 300 ms
    basic.pause(5000)           // Mantém o vermelho aceso por 5 segundos

    // Após o vermelho, o loop recomeça e o verde é aceso novamente.
    // A sequência se repete eternamente.
  }
})

// ==============================================================
// 7. INÍCIO COM MENSAGEM
// ==============================================================

// O bloco 'basic.showString' é executado apenas uma vez, quando o micro:bit
// é ligado ou reiniciado. Mostra uma mensagem de boas-vindas na matriz de LEDs.
basic.showString("SEMAFORO")   // Exibe a palavra "SEMAFORO" rolando os caracteres
basic.pause(500)               // Pequena pausa após a mensagem
basic.clearScreen()            // Limpa a matriz para iniciar o programa principal

// ==============================================================
// FIM DO CÓDIGO
// ==============================================================

⏱️ Detalhamento Minuto a Minuto (50 min)

♿ Orientações para Adaptações e Inclusão

📊 Critérios Operacionais de Avaliação (com pontuação)

• Compreender o funcionamento de um sensor de toque capacitivo no micro:bit, entendendo como ele detecta a presença humana através da condutividade elétrica da pele.
• Programar o micro:bit para ler o valor do sensor e tomar decisões usando lógica condicional (if/else), criando um sistema que "detecta" mentiras.
• Utilizar a matriz de LEDs e o buzzer para fornecer feedback visual e sonoro (verdadeiro/falso), com ícones e sons distintos.
• Aplicar a lógica de "calibração": o sensor precisa ser calibrado para cada pessoa, pois cada indivíduo tem condutividade elétrica diferente.
• Desenvolver um sistema com múltiplos níveis de sensibilidade, ajustando o limiar para diferentes condições.
• Criar um código comentado e documentado, explicando o funcionamento do sensor e da lógica condicional.

📚 Conteúdo Programático

Sensores: O que são e como funcionam:

• Sensor de toque capacitivo: mede a capacitância do pino ao toque humano
• Como a pele humana conduz eletricidade e altera a capacitância
• Diferença entre sensor digital e analógico

Lógica Condicional:

• if: executa código se a condição for verdadeira
• else: executa código se a condição for falsa
• else if: permite múltiplas condições
• Comparadores: >, <, >=, <=, ==, !=

Variáveis:

• Armazenar e manipular dados (ex: o valor lido pelo sensor)
• Variáveis globais vs. locais
• Tipos de dados: number, boolean, string

Calibração:

• Ajustar o sensor para diferentes condições
• Por que cada pessoa tem um valor de referência diferente?
• Como implementar um sistema de calibração no código

Matriz de LEDs:

• Exibir ícones: basic.showIcon()
• Exibir texto: basic.showString()
• Desenhar padrões personalizados: basic.showLeds()

📋 Habilidades BNCC e RCP-PR

🛠️ Materiais

Hardware:

Software:

Outros:

🔧 Montagem do Hardware (Explicação Detalhada Passo a Passo)

Passo 1: Entendendo o Sensor de Toque Capacitivo

O micro:bit possui um sensor de toque capacitivo integrado nos pinos P0, P1 e P2. Isso significa que podemos usar um simples fio ou até mesmo a nossa pele para enviar um sinal ao micro:bit.

Como funciona?

• O micro:bit mede a capacitância do pino
• Quando tocamos o fio, a capacitância muda
• Essa mudança é medida pelo micro:bit e convertida em um valor numérico (0 a 1023)
• Quanto maior o contato (mais área de pele), maior a mudança na capacitância

Passo 2: Conexão Simples do Sensor de Toque

Conexão Básica (apenas fio):

• Conecte um fio jumper ao pino P0 do micro:bit
• A outra ponta do fio ficará "solta" (sem conexão)
• O aluno tocará nela para ativar o sensor

Conexão com LED de Calibração (opcional - recomendado):

• LED: ânodo (perna longa) → pino P2
• LED: cátodo (perna curta) → resistor 220Ω → GND

Passo 3: Teste de Funcionamento

Teste Manual (sem código):

1. Conecte o fio ao pino P0
2. Toque o fio com o dedo
3. O micro:bit deve detectar o toque (se programado)

Esquema de Conexão:

+------------------------------------------------------------------+
|                             MICRO:BIT                             |
|                                                                  |
|  P0 +-------- FIO SOLTO (SENSOR DE TOQUE)                        |
|  P1 +-------- (NÃO UTILIZADO)                                    |
|  P2 +-------- LED CALIBRAÇÃO (+)                                 |
|  GND +-------- LED CALIBRAÇÃO (-) através do resistor            |
|  GND +-------- FIO SOLTO (completa o circuito)                   |
|                                                                  |
+------------------------------------------------------------------+

Passo 4: Configuração do Sensor no Código

No MakeCode, usamos:

• pins.analogReadPin(AnalogPin.P0) para ler o valor do sensor (0-1023)
• Ou o bloco pino P0 é tocado? para detecção digital (toque/não toque)

Para este projeto, usaremos analogReadPin() para obter valores mais precisos.

💻 Código Micro:bit (Completo e Didático)

// ==============================================================
// PROJETO: DETECTOR DE MENTIRAS
// DESCRIÇÃO: O micro:bit "detecta" se você está mentindo usando
// um sensor de toque capacitivo.
// AUTOR: Equipe Robô na Veia
// VERSÃO: 1.0
// ==============================================================

// ==============================================================
// 1. VARIÁVEIS GLOBAIS
// ==============================================================

// A variável 'calibracao' armazena o valor de referência do sensor
// Este valor é lido quando a pessoa está em estado "neutro"
// Inicialmente zero, será atualizada pela função calibrar()
let calibracao = 0

// A variável 'limiar' define o que é considerado "verdade" ou "mentira"
// Quanto menor o limiar, mais sensível o detector (detecta variações pequenas)
// O valor 80 é um valor empírico que funciona bem na prática
let limiar = 80

// Flag para indicar se o sensor foi calibrado
// Usamos um booleano para controlar se a calibração já foi feita
// Inicialmente false, pois ainda não calibramos
let calibrado = false

// ==============================================================
// 2. FUNÇÃO DE CALIBRAÇÃO
// ==============================================================

/*
Função que calibra o sensor para a pessoa atual.
Deve ser chamada quando a pessoa está em estado "neutro"
(sem estresse, sem mentir).
*/
function calibrar() {
  // Lê o valor do sensor no pino P0 (0 a 1023)
  // A função analogReadPin() retorna um valor inteiro de 0 a 1023,
  // que representa a tensão no pino (0V a 3.3V). No caso do sensor
  // capacitivo, quanto maior a área de contato da pele (ou umidade),
  // maior a capacitância e, consequentemente, maior o valor lido.
  calibracao = pins.analogReadPin(AnalogPin.P0)

  // Marca que o sensor foi calibrado, alterando a flag para true
  // Isso permitirá que a função detectarMentira() funcione corretamente
  calibrado = true

  // Acende o LED de calibração (P2) para indicar que está pronto
  // O pino P2 é configurado como saída digital. Colocamos em nível ALTO (1)
  // para acender um LED externo (se conectado) ou podemos usar o LED interno
  // da placa, mas aqui usamos um pino genérico para sinalização externa.
  pins.digitalWritePin(DigitalPin.P2, 1)

  // Mostra um "V" (check) na matriz de LEDs para indicar calibração bem-sucedida
  // A função showIcon() exibe um ícone pré-definido na matriz 5x5
  basic.showIcon(IconNames.Yes)
  // Aguarda 500 milissegundos para que o usuário veja o ícone
  basic.pause(500)
  // Limpa a tela (matriz de LEDs) apagando todos os LEDs
  basic.clearScreen()

  // Mostra o valor calibrado no display (opcional)
  // Concatenação com string vazia para converter número em string
  basic.showString("" + calibracao)
  // Pausa para leitura do valor exibido
  basic.pause(500)
  // Limpa a tela novamente
  basic.clearScreen()
}

// ==============================================================
// 3. FUNÇÃO PARA "DETECTAR MENTIRA"
// ==============================================================

/*
Função principal do detector de mentiras.
Compara o valor atual do sensor com o valor calibrado.
Se a diferença for grande, considera-se "mentira".
*/
function detectarMentira() {
  // Verifica se o sensor foi calibrado
  // Se a flag calibrado for false, significa que a calibração ainda não foi feita
  if (!calibrado) {
    // Se não foi calibrado, pede para calibrar exibindo a mensagem "CALIBRE"
    basic.showString("CALIBRE")
    // Pausa para leitura da mensagem
    basic.pause(500)
    // Limpa a tela e sai da função (return)
    basic.clearScreen()
    return
  }

  // Lê o valor atual do sensor no pino P0
  // Este valor representa a resposta do sensor no momento da leitura
  let valorAtual = pins.analogReadPin(AnalogPin.P0)

  // Calcula a diferença entre o valor atual e o valor calibrado
  // Usamos Math.abs() para obter o valor absoluto (ignora o sinal)
  // Ou seja, se valorAtual for maior ou menor que calibracao, a diferença será positiva
  // Isso é importante porque a variação pode ser para mais ou para menos,
  // mas queremos apenas a magnitude da mudança.
  let diferenca = Math.abs(valorAtual - calibracao)

  // ==========================================================
  // LÓGICA CONDICIONAL - O CORAÇÃO DO DETECTOR DE MENTIRAS
  // ==========================================================

  // Se a diferença for maior que o limiar, é "mentira"
  // O limiar é um valor de tolerância: se a variação for pequena, consideramos verdade;
  // se for grande, consideramos mentira.
  if (diferenca > limiar) {
    // ---------- MENTIRA! ----------
    // Feedback: X vermelho + som grave
    // Mostra um "X" na matriz de LEDs (vermelho) - ícone de "não"
    basic.showIcon(IconNames.No)

    // Toca um som grave (frequência baixa) para indicar mentira
    // A função playTone() gera um tom com a frequência especificada (em Hz)
    // e duração em milissegundos. 200 Hz é um som grave e "pesado".
    music.playTone(200, 500)

    // Pisca o LED de calibração (P2) para indicar que algo está errado
    // Loop para piscar 3 vezes
    for (let i = 0; i < 3; i++) {
      // Apaga o LED (nível baixo)
      pins.digitalWritePin(DigitalPin.P2, 0)
      // Aguarda 100 ms
      basic.pause(100)
      // Acende o LED (nível alto)
      pins.digitalWritePin(DigitalPin.P2, 1)
      // Aguarda 100 ms
      basic.pause(100)
    }

    // Mostra o valor da diferença no display (opcional)
    // Útil para depuração e para o usuário ver o quanto variou
    basic.showString("D:" + diferenca)
    basic.pause(500)
    basic.clearScreen()
  } else {
    // ---------- VERDADE! ----------
    // Feedback: V (check) + som agudo
    // Mostra um "V" (check) na matriz de LEDs (verde) - ícone de "sim"
    basic.showIcon(IconNames.Yes)

    // Toca um som agudo (frequência alta) para indicar verdade
    // 800 Hz é um som mais agudo e "alegre"
    music.playTone(800, 500)

    // Mostra o valor da diferença no display (opcional)
    basic.showString("D:" + diferenca)
    basic.pause(500)
    basic.clearScreen()
  }

  // Pequena pausa antes de limpar a tela completamente
  basic.pause(1000)
  basic.clearScreen()
}

// ==============================================================
// 4. FUNÇÃO PARA RESETAR A CALIBRAÇÃO
// ==============================================================

/*
Função que reseta a calibração, permitindo calibrar para outra pessoa.
*/
function resetarCalibracao() {
  // Muda a flag para false, indicando que o sensor não está mais calibrado
  calibrado = false
  // Apaga o LED de calibração (P2) para indicar que a calibração foi perdida
  pins.digitalWritePin(DigitalPin.P2, 0)
  // Exibe a mensagem "RESET" na matriz
  basic.showString("RESET")
  // Pausa para visualização
  basic.pause(500)
  // Limpa a tela
  basic.clearScreen()
}

// ==============================================================
// 5. FUNÇÃO PARA AJUSTAR O LIMIAR
// ==============================================================

/*
Função que ajusta a sensibilidade do detector.
Quanto menor o limiar, mais sensível (mais "mentiras" são detectadas).
*/
function ajustarLimiar(direcao: number) {
  // direcao: 1 = aumentar (menos sensível), -1 = diminuir (mais sensível)
  // Multiplicamos direcao por 10 para fazer ajustes de 10 em 10
  limiar = limiar + (direcao * 10)

  // Garante que o limiar não fique negativo ou muito alto
  // Definimos limites mínimo de 10 e máximo de 200 para evitar valores extremos
  if (limiar < 10) {
    limiar = 10
  } else if (limiar > 200) {
    limiar = 200
  }

  // Mostra o novo limiar na matriz de LEDs para o usuário saber o valor atual
  basic.showString("L:" + limiar)
  // Pausa para leitura
  basic.pause(500)
  // Limpa a tela
  basic.clearScreen()
}

// ==============================================================
// 6. CONTROLE POR BOTÕES
// ==============================================================

// Botão A: Calibrar o sensor
// O usuário deve estar em estado "neutro" e tocar o sensor
// Quando o botão A for pressionado, chama a função calibrar()
input.onButtonPressed(Button.A, function () {
  calibrar()
})

// Botão B: Detectar mentira
// O usuário toca o sensor e o micro:bit decide se é verdade ou mentira
// Quando o botão B for pressionado, chama a função detectarMentira()
input.onButtonPressed(Button.B, function () {
  detectarMentira()
})

// Botão A+B: Resetar a calibração
// Quando ambos os botões forem pressionados simultaneamente, reseta a calibração
input.onButtonPressed(Button.AB, function () {
  resetarCalibracao()
})

// ==============================================================
// 7. INICIALIZAÇÃO
// ==============================================================

// Quando o micro:bit é ligado (ou reiniciado), o bloco "on start" é executado
// Mostra uma mensagem de boas-vindas na matriz de LEDs
basic.showString("DETECTOR")
// Pausa para leitura
basic.pause(500)
// Limpa a tela
basic.clearScreen()

// Mostra instruções para o usuário: como calibrar
basic.showString("A=CALIBRAR")
// Pausa para leitura
basic.pause(1000)
// Limpa a tela
basic.clearScreen()

// Mostra instruções para o usuário: como detectar
basic.showString("B=DETECTAR")
// Pausa para leitura
basic.pause(1000)
// Limpa a tela
basic.clearScreen()

// Mostra instruções para o usuário: como resetar
basic.showString("AB=RESET")
// Pausa para leitura
basic.pause(1000)
// Limpa a tela
basic.clearScreen()

Explicação do Código em Blocos (para alunos iniciantes)

Para facilitar a compreensão, aqui estão as principais partes em blocos:

1. Calibrar (Botão A):
   • ler analógico pino P0 → definir calibracao
   • mostrar ícone sim → pausar 500ms → limpar tela
2. Detectar Mentira (Botão B):
   • ler analógico pino P0 → definir valorAtual
   • calcular diferença = |valorAtual - calibracao|
   • se diferença > limiar → mostrar ícone não + tocar som grave
   • senão → mostrar ícone sim + tocar som agudo
3. Resetar (Botões A+B):
   • definir calibrado = falso
   • mostrar string "RESET"

⏱️ Detalhamento Minuto a Minuto (50 min)

♿ Orientações para Adaptações e Inclusão

📊 Critérios Operacionais de Avaliação (com pontuação)

• Realizar a feira de robótica para os colegas de outras turmas (2º ao 4º ano e 6º ao 9º, se houver), apresentando os robôs e explicando as soluções criadas.
• Demonstrar os robôs em funcionamento (Semáforo e Detector de Mentiras), respondendo a perguntas e interagindo com o público escolar.
• Coletar feedback do público escolar por meio de formulários ou "passaporte da feira", registrando as impressões dos visitantes.
• Gerenciar a logística de visitação, garantindo que todos os estandes sejam visitados e que as apresentações aconteçam dentro do tempo previsto.
• Utilizar a sinalização "Aberto/Fechado" (programada na semana anterior) para controlar o fluxo de visitantes em cada estande.
• Desenvolver habilidades de comunicação científica, explicando conceitos técnicos de forma acessível para diferentes públicos.

📚 Conteúdo Programático

Exposição Pública:

• Apresentação para diferentes públicos (colegas de outras idades)
• Adaptação da linguagem para diferentes níveis de conhecimento
• Uso de recursos visuais (pôsteres, diagramas, demonstrações)

Comunicação Científica:

• Como explicar conceitos técnicos de forma acessível
• Uso de analogias para facilitar a compreensão
• Como responder perguntas com clareza e segurança

Feedback e Avaliação:

• Coleta de dados sobre a compreensão do público
• Análise de formulários de feedback
• Reflexão sobre a eficácia da comunicação

Gestão de Tempo e Logística:

• Organizar a visitação em fluxo contínuo
• Rodízio de atendimento entre os membros da equipe
• Controle do tempo de cada apresentação

Demonstração de Hardware:

• Apresentar o funcionamento dos robôs ao vivo
• Explicar cada componente e sua função
• Mostrar o código e explicar a lógica

📋 Habilidades BNCC e RCP-PR

🛠️ Materiais

Estandes:

Robôs:

Para o Público:

Para a Logística:

Sinalização com LEDs "Aberto/Fechado" (da Semana 34):

🔧 Montagem do Hardware

Checklist de Manhã (antes da feira):

💻 Código Micro:bit

Códigos presentes em cada estande:

1. Semáforo Sonoro (com Modo Noturno) - da Semana 33
2. Detector de Mentiras (com calibração) - da Semana 34
3. Sinalização de Estande (Aberto/Fechado) - da Semana 34

Código da Sinalização de Estande (revisão):

// ==============================================================
// PROJETO: SINALIZAÇÃO DE ESTANDE ABERTO/FECHADO
// DESCRIÇÃO: Controla LEDs para indicar se o estande está aberto
// AUTOR: Equipe Robô na Veia
// ==============================================================
// 
// Este programa é destinado ao micro:bit e utiliza a plataforma MakeCode.
// O objetivo é simular a sinalização de um estande (ex: em uma feira)
// utilizando dois LEDs externos (verde e vermelho) conectados aos pinos
// P1 e P3, respectivamente. Quando o estande está aberto, o LED verde
// acende e o vermelho apaga, e a matriz de LEDs do micro:bit exibe um
// ícone de "sim" (checkmark). Quando fechado, o LED vermelho acende,
// o verde apaga e a matriz exibe um ícone de "não" (X). Os botões A e B
// permitem alternar entre os estados, e um tom sonoro é reproduzido
// para feedback auditivo.
// 
// Hardware necessário:
// - Micro:bit
// - Dois LEDs com resistores adequados conectados aos pinos P1 (verde) e P3 (vermelho)
// - (Opcional) Alto-falante ou buzzer no pino 0 (padrão para music.playTone)
//
// ==============================================================

// Declaração da variável global que armazena o estado atual do estande.
// 'true' significa aberto, 'false' significa fechado.
// Inicializamos com 'true' (aberto) mas depois será redefinida.
let estandeAberto = true

// ==============================================================
// FUNÇÃO: atualizarSinalizacao()
// DESCRIÇÃO: Atualiza os LEDs externos e a matriz de LEDs do micro:bit
// com base no estado atual (estandeAberto).
// Esta função é chamada sempre que o estado muda.
// ==============================================================
function atualizarSinalizacao() {
  // Verifica se o estande está aberto
  if (estandeAberto) {
    // === ESTANDE ABERTO ===
    // Acende o LED verde conectado ao pino P1 (nível lógico alto = 1)
    // O pino P1 é configurado como saída digital.
    pins.digitalWritePin(DigitalPin.P1, 1) // Verde aceso
    // Apaga o LED vermelho conectado ao pino P3 (nível lógico baixo = 0)
    pins.digitalWritePin(DigitalPin.P3, 0) // Vermelho apagado
    // Exibe na matriz de LEDs do micro:bit um ícone de "sim" (checkmark)
    // A função showIcon() exibe o ícone por padrão por 1500ms, mas como
    // não há pause, ele fica visível até que outro ícone seja exibido ou a tela limpa.
    basic.showIcon(IconNames.Yes)
  } else {
    // === ESTANDE FECHADO ===
    // Apaga o LED verde (pino P1)
    pins.digitalWritePin(DigitalPin.P1, 0) // Verde apagado
    // Acende o LED vermelho (pino P3)
    pins.digitalWritePin(DigitalPin.P3, 1) // Vermelho aceso
    // Exibe na matriz de LEDs um ícone de "não" (X)
    basic.showIcon(IconNames.No)
  }
  // Nota: A função não retorna nenhum valor; apenas atualiza os dispositivos de saída.
}

// ==============================================================
// EVENTO: Botão A pressionado
// DESCRIÇÃO: Quando o botão A é pressionado, o estande é aberto.
// ==============================================================
input.onButtonPressed(Button.A, function () {
  // Altera a variável global para 'true' (aberto)
  estandeAberto = true
  // Chama a função que atualiza a sinalização (LEDs e ícone)
  atualizarSinalizacao()
  // Reproduz um tom de 800 Hz por 200 milissegundos no alto-falante/buzzer
  // O pino padrão para áudio no micro:bit é o pino 0.
  music.playTone(800, 200)
})

// ==============================================================
// EVENTO: Botão B pressionado
// DESCRIÇÃO: Quando o botão B é pressionado, o estande é fechado.
// ==============================================================
input.onButtonPressed(Button.B, function () {
  // Altera a variável global para 'false' (fechado)
  estandeAberto = false
  // Chama a função que atualiza a sinalização
  atualizarSinalizacao()
  // Reproduz um tom de 300 Hz por 200 ms (tom mais grave para indicar fechamento)
  music.playTone(300, 200)
})

// ==============================================================
// INICIALIZAÇÃO DO PROGRAMA
// O código abaixo é executado quando o micro:bit é ligado ou reiniciado.
// ==============================================================

// Garantimos que o estado inicial seja 'true' (aberto) – redundante, pois já foi
// definido no início, mas reforça a inicialização.
estandeAberto = true
// Chama a função para configurar os LEDs e o ícone conforme o estado inicial.
atualizarSinalizacao()

// Exibe a palavra "FEIRA" na matriz de LEDs, uma letra por vez, com rolamento.
// A função showString() exibe uma mensagem de texto na tela, percorrendo
// caracteres e com um atraso padrão de 150ms entre eles.
basic.showString("FEIRA")

// Pausa a execução por 500 milissegundos (meio segundo) para que a mensagem
// "FEIRA" seja completamente exibida e visualizada antes de limpar a tela.
basic.pause(500)

// Limpa a tela (matriz de LEDs) para remover qualquer resíduo da mensagem.
// Após isso, a tela mostrará apenas o ícone definido pela última chamada de
// showIcon() (que foi executada em atualizarSinalizacao()).
basic.clearScreen()

// ==============================================================
// FIM DO PROGRAMA
// A partir daqui, o micro:bit fica em loop aguardando eventos (botões)
// e mantendo a sinalização atualizada.
// ==============================================================

⏱️ Detalhamento Minuto a Minuto (Modelo para 2 horas de feira)

Formulário de Feedback (para os visitantes):

📊 Critérios Operacionais de Avaliação (com pontuação)

• Receber pais, mães, avós e responsáveis com acolhimento e entusiasmo, criando um ambiente de celebração.
• Apresentar os robôs com ainda mais carinho e detalhes, adaptando a linguagem para um público leigo (não técnico).
• Demonstrar o funcionamento dos robôs de forma clara e emocionante, usando analogias e exemplos do dia a dia.
• Celebrar as conquistas do ano com uma cerimônia simbólica de premiação e um lanche coletivo.
• Criar memórias afetivas por meio de fotos, certificados e momentos de confraternização.
• Utilizar a sinalização "Aberto/Fechado" para gerenciar o fluxo de famílias.

📚 Conteúdo Programático

Comunicação para Público Leigo:

• Adaptar a linguagem técnica para famílias (sem jargões)
• Usar analogias com situações do cotidiano
• Explicar o "porquê" das escolhas técnicas

Celebração e Rito de Passagem:

• Cerimônia de premiação e entrega de certificados
• Ritos de passagem: marcar a transição para o 6º ano
• Reconhecimento do esforço e das conquistas

Empatia e Acolhimento:

• Receber as famílias com respeito e carinho
• Saber ouvir e responder com paciência
• Criar um ambiente onde todos se sintam bem-vindos

Confraternização:

• Lanche coletivo como momento de integração
• Fotografias para registro das memórias
• Música e celebração

📋 Habilidades BNCC e RCP-PR

🛠️ Materiais

Estandes:

Robôs:

Para as Famílias:

Confraternização:

Cerimônia:

🔧 Montagem do Hardware

Checklist de Manhã:

💻 Código Micro:bit

Códigos carregados em cada estande:

1. Semáforo Sonoro (com Modo Noturno)
2. Detector de Mentiras (com calibração)
3. Sinalização de Estande (Aberto/Fechado)

⏱️ Detalhamento Minuto a Minuto (Modelo para 1h30 de evento)

Certificados Especiais:

📊 Critérios Operacionais de Avaliação (com pontuação)

• Refletir sobre o desempenho individual e coletivo durante a feira, identificando pontos fortes e áreas de melhoria.
• Avaliar os colegas de forma construtiva, usando critérios claros e respeitosos.
• Analisar criticamente o código-fonte dos projetos desenvolvidos (Semáforo e Detector de Mentiras), identificando bugs e oportunidades de otimização.
• Reconhecer as conquistas pessoais e coletivas ao longo do ano letivo, celebrando o crescimento de cada um.
• Desenvolver a metacognição, compreendendo como o aprendizado em robótica impactou outras áreas da vida.
• Programar uma melhoria no código do Detector de Mentiras, adicionando um LED que acende quando o sensor é calibrado.

📚 Conteúdo Programático

Autoavaliação:

• Reflexão sobre desempenho, esforço, aprendizado e superação
• Identificação de pontos fortes e áreas de melhoria
• Reconhecimento do próprio crescimento

Avaliação por Pares:

• Feedback construtivo: como dar e receber críticas
• Respeito e empatia na avaliação do outro
• Critérios claros para avaliação

Metacognição:

• Pensar sobre o próprio pensamento e aprendizado
• Como o aprendizado em robótica se conecta com outras áreas
• Estratégias de aprendizado para o futuro

Revisão de Código:

• Analisar código para encontrar bugs
• Identificar oportunidades de melhoria (refatoração)
• Documentar problemas e soluções

Aprimoramento de Código:

• Adicionar novas funcionalidades a um projeto existente
• Testar e validar as alterações
• Documentar as mudanças

📋 Habilidades BNCC e RCP-PR

🛠️ Materiais

💻 Código Micro:bit

Código do Detector de Mentiras com LED de Calibração (melhoria):

// ==============================================================
// PROJETO: DETECTOR DE MENTIRAS COM LED DE CALIBRAÇÃO
// DESCRIÇÃO: O micro:bit "detecta" se você está mentindo e
// acende um LED quando calibrado.
// AUTOR: Equipe Robô na Veia
// VERSÃO: 2.0 (com LED de Calibração)
// ==============================================================

// ==============================================================
// 1. VARIÁVEIS GLOBAIS
// ==============================================================

// Variável que armazenará o valor de referência lido do sensor
// durante a calibração. Esse valor será usado como base para
// comparar as leituras futuras.
let calibracao = 0

// Limiar (ou sensibilidade) que define o quanto a leitura atual
// pode se desviar do valor de calibração para considerarmos uma
// "mentira". Quanto menor o valor, mais sensível será o detector.
let limiar = 80

// Flag booleana que indica se o processo de calibração já foi
// realizado. Inicia como 'false' (não calibrado) e muda para
// 'true' após a calibração.
let calibrado = false

// ==============================================================
// 2. FUNÇÃO DE CALIBRAÇÃO
// ==============================================================

// Esta função deve ser executada para definir o valor de referência
// do sensor. Ela lê o pino analógico P0 e armazena esse valor.
function calibrar() {
  // Lê o valor analógico (0 a 1023) do sensor conectado ao pino P0
  // e armazena na variável global 'calibracao'.
  calibracao = pins.analogReadPin(AnalogPin.P0)

  // Muda a flag 'calibrado' para 'true', indicando que a calibração
  // foi concluída com sucesso.
  calibrado = true

  // Acende o LED de calibração conectado ao pino digital P2.
  // Esse LED serve como indicador visual de que a calibração
  // está ativa e o sistema pronto para detectar mentiras.
  pins.digitalWritePin(DigitalPin.P2, 1)

  // Exibe um ícone de "sim" (check) na matriz de LEDs do micro:bit
  // para confirmar visualmente que a calibração foi bem-sucedida.
  basic.showIcon(IconNames.Yes)

  // Aguarda 500 milissegundos (meio segundo) para que o usuário
  // possa ver o ícone e o LED aceso.
  basic.pause(500)

  // Limpa a tela (matriz de LEDs), apagando o ícone exibido.
  basic.clearScreen()
}

// ==============================================================
// 3. FUNÇÃO PARA "DETECTAR MENTIRA"
// ==============================================================

// Esta é a função principal que compara a leitura atual com a
// calibração e decide se é "verdade" ou "mentira".
function detectarMentira() {
  // Primeiro, verifica se o sensor já foi calibrado.
  // Se 'calibrado' for 'false', o sistema ainda não tem um valor
  // de referência, então não pode fazer a detecção.
  if (!calibrado) {
    // Mostra a palavra "CALIBRE" na matriz de LEDs, pedindo que
    // o usuário pressione o botão A para calibrar.
    basic.showString("CALIBRE")

    // Pausa por 500 ms para a mensagem ser lida.
    basic.pause(500)

    // Limpa a tela após a pausa.
    basic.clearScreen()

    // Sai da função imediatamente, sem tentar detectar.
    return
  }

  // Lê o valor atual do sensor no pino P0 (analógico).
  let valorAtual = pins.analogReadPin(AnalogPin.P0)

  // Calcula a diferença absoluta entre o valor atual e o valor
  // de calibração. Quanto maior essa diferença, maior a variação
  // detectada pelo sensor.
  let diferenca = Math.abs(valorAtual - calibracao)

  // Lógica de decisão: se a diferença ultrapassar o limiar,
  // consideramos que é uma "mentira"; caso contrário, "verdade".
  if (diferenca > limiar) {
    // ---------- MENTIRA! ----------

    // Exibe o ícone de "não" (X) na matriz de LEDs para indicar
    // que foi detectada uma mentira.
    basic.showIcon(IconNames.No)

    // Toca um som grave (frequência 200 Hz) por 500 ms para
    // reforçar a indicação sonora de mentira.
    music.playTone(200, 500)

    // Pisca o LED de calibração (P2) três vezes de forma rápida
    // para chamar a atenção e indicar visualmente o evento.
    for (let i = 0; i < 3; i++) {
      // Apaga o LED (0 = desligado).
      pins.digitalWritePin(DigitalPin.P2, 0)
      // Pausa 100 ms para o LED ficar apagado.
      basic.pause(100)
      // Acende o LED (1 = ligado).
      pins.digitalWritePin(DigitalPin.P2, 1)
      // Pausa 100 ms para o LED ficar aceso.
      basic.pause(100)
    }
  } else {
    // ---------- VERDADE! ----------

    // Exibe o ícone de "sim" (check) para indicar que a leitura
    // está dentro do esperado, ou seja, "verdade".
    basic.showIcon(IconNames.Yes)

    // Toca um som agudo (frequência 800 Hz) por 500 ms para
    // indicar que a resposta foi verdadeira.
    music.playTone(800, 500)
  }

  // Aguarda 1 segundo (1000 ms) para que o ícone e o som sejam
  // percebidos antes de limpar a tela.
  basic.pause(1000)

  // Limpa a tela da matriz de LEDs, preparando para a próxima leitura.
  basic.clearScreen()
}

// ==============================================================
// 4. FUNÇÃO PARA RESETAR A CALIBRAÇÃO
// ==============================================================

// Esta função permite reiniciar o processo de calibração,
// desligando o LED de calibração e resetando a flag.
function resetarCalibracao() {
  // Muda a flag 'calibrado' para 'false', indicando que o sistema
  // não está mais calibrado. A próxima detecção exigirá nova calibração.
  calibrado = false

  // Desliga o LED de calibração (P2) – coloca em nível baixo (0).
  pins.digitalWritePin(DigitalPin.P2, 0)

  // Mostra a palavra "RESET" na matriz de LEDs para informar que
  // a calibração foi resetada.
  basic.showString("RESET")

  // Pausa 500 ms para visualização da mensagem.
  basic.pause(500)

  // Limpa a tela.
  basic.clearScreen()
}

// ==============================================================
// 5. CONTROLE POR BOTÕES
// ==============================================================

// Associa o botão A à função de calibração.
// Quando o usuário pressionar o botão A, o micro:bit executará
// a função 'calibrar()', lendo o valor de referência.
input.onButtonPressed(Button.A, function () {
  calibrar()
})

// Associa o botão B à função de detecção de mentira.
// Ao pressionar B, o micro:bit executa 'detectarMentira()',
// que compara a leitura atual com a calibração e exibe o resultado.
input.onButtonPressed(Button.B, function () {
  detectarMentira()
})

// Associa o pressionamento simultâneo dos botões A e B (AB)
// à função que reseta a calibração. Útil para reiniciar o processo
// sem precisar desligar o micro:bit.
input.onButtonPressed(Button.AB, function () {
  resetarCalibracao()
})

// ==============================================================
// 6. INICIALIZAÇÃO
// ==============================================================

// Quando o micro:bit ligar ou for reiniciado, este bloco é executado
// automaticamente. Ele mostra uma mensagem de boas-vindas e depois
// limpa a tela, aguardando a interação do usuário.
basic.showString("DETECTOR")   // Exibe a palavra "DETECTOR" na matriz de LEDs.
basic.pause(500)               // Pausa de meio segundo para leitura.
basic.clearScreen()            // Limpa a tela, deixando o micro:bit pronto.

⏱️ Detalhamento Minuto a Minuto (50 min)

Formulário de Autoavaliação:

1. "O que eu fiz de MELHOR na feira foi ____________________."
2. "Tive dificuldade em ____________________. Na próxima vez, farei diferente: ____________________."
3. "Minha parte FAVORITA do projeto como um todo foi ____________________."
4. "De 0 a 10, minha DEDICAÇÃO foi __. Porque ____________________."
5. "Uma coisa que aprendi em robótica que vou levar para a VIDA é ____________________."
6. "Se eu pudesse voltar no tempo e dar um conselho para o meu eu do início do ano, diria: ____________________."

♿ Orientações para Adaptações e Inclusão

📊 Critérios Operacionais de Avaliação (com pontuação)

• Realizar uma cerimônia simbólica de formatura do curso de robótica, criando um rito de passagem para o 6º ano.
• Entregar certificados especiais e prêmios, reconhecendo as conquistas individuais e coletivas ao longo do ano.
• Promover um momento de celebração e emoção, envolvendo alunos, professores e famílias.
• Programar o micro:bit para funcionar como um "crachá digital", exibindo o nome do aluno na matriz de LEDs.
• Criar memórias afetivas que reforcem a autoestima e o senso de pertencimento.
• Desenvolver uma animação especial de formatura na matriz de LEDs.

📚 Conteúdo Programático

Ritos de Passagem:

• Cerimônias de formatura e celebração de conquistas
• Significado dos ritos de passagem em diferentes culturas
• A transição para o 6º ano

Reconhecimento e Premiação:

• Valorização do esforço e da criatividade
• Diferentes tipos de premiação (certificados, troféus, menções honrosas)

Expressão Artística:

• Música, teatro, discursos
• Decoração do ambiente para a cerimônia

Empatia e Cooperação:

• Celebrar as conquistas do outro
• A importância do apoio da família e dos colegas

Matriz de LEDs:

• Exibir texto: basic.showString()
• Exibir animações: basic.showLeds(), basic.showIcon()
• Criar sequências de exibição

📋 Habilidades BNCC e RCP-PR

🛠️ Materiais

Certificados e Prêmios:

Ambiente:

Confraternização:

Crachá Digital:

🔧 Montagem do Hardware

Crachá Digital:

1. Conectar o micro:bit ao computador via cabo USB
2. Programar com o nome do aluno (substituir "SEU_NOME")
3. Desconectar e pendurar como um crachá usando a fita

Esquema de Conexão:

• Apenas o micro:bit (sem componentes externos)
• A matriz de LEDs exibirá o nome e a animação

💻 Código Micro:bit (Crachá Digital + Animação de Formatura)

// ==============================================================
// PROJETO: CRACHÁ DIGITAL + ANIMAÇÃO DE FORMATURA
// DESCRIÇÃO: Exibe o nome do aluno na matriz de LEDs e uma
// animação especial de formatura.
// AUTOR: Equipe Robô na Veia
// VERSÃO: 1.0
// ==============================================================

// ==============================================================
// 1. CONFIGURAÇÕES INICIAIS
// ==============================================================

// Substitua "SEU_NOME" pelo nome do aluno
// AQUI criamos uma variável chamada 'nomeAluno' para guardar um texto (string).
// Variáveis são como "caixinhas" onde guardamos informações para usar depois.
// O texto entre aspas é o valor que será exibido no display.
// IMPORTANTE: Troque "SEU_NOME" pelo seu nome para personalizar o crachá.
let nomeAluno = "SEU_NOME"

// ==============================================================
// 2. FUNÇÃO PARA EXIBIR O NOME
// ==============================================================

/*
Função que exibe o nome do aluno na matriz de LEDs.
UMA FUNÇÃO é um bloco de instruções que damos um nome.
Podemos "chamar" (executar) esse bloco várias vezes sem precisar reescrever o código.
Aqui, criamos uma função chamada 'exibirNome' para deixar o código mais organizado.
*/
function exibirNome() {
  // basic.showString() é um comando do Micro:bit que rola um texto
  // na matriz de LEDs, letra por letra, da esquerda para a direita.
  // Estamos passando para ele o conteúdo da variável 'nomeAluno'.
  basic.showString(nomeAluno)
  
  // basic.pause() faz o programa "dormir" por um determinado tempo,
  // medido em milissegundos (1 segundo = 1000 ms).
  // Aqui, paramos por 500 ms (meio segundo) para dar tempo de visualizar
  // o nome completo antes de apagar a tela.
  basic.pause(500)
  
  // basic.clearScreen() apaga TODOS os LEDs da matriz, deixando a tela
  // completamente escura. Isso garante que não fique nenhum "rastro"
  // de luz atrapalhando a próxima imagem.
  basic.clearScreen()
}

// ==============================================================
// 3. FUNÇÃO PARA ANIMAÇÃO DE FORMATURA
// ==============================================================

/*
Função que exibe uma animação especial de formatura.
Inclui chapéu de formatura, fogos de artifício e corações.
Criamos uma função separada para a animação porque ela é um bloco
independente que pode ser executado quando quisermos (por exemplo, ao ligar).
*/
function animacaoFormatura() {
  // Animação 1: Chapéu de formatura (simplificado)
  // basic.showLeds() permite desenhar uma imagem personalizada na matriz de 5x5 LEDs.
  // Cada linha entre aspas representa uma fileira de LEDs.
  // O ponto (.) significa LED apagado. O sustenido (#) significa LED aceso.
  // Neste projeto, o desenho está VAZIO (todos os pontos), mas a intenção
  // didática é que o aluno substitua por um desenho de chapéu.
  // Exemplo de chapéu: ".#.#.", "#####", etc.
  basic.showLeds(`
    . . . . .
    . . . . .
    . . . . .
    . . . . .
    . . . . .
  `)
  // Pausa de 500 ms para mostrar o chapéu (mesmo que vazio) antes de prosseguir.
  basic.pause(500)

  // Animação 2: Fogos de artifício (simplificado) usando um laço de repetição.
  // for (let i = 0; i < 3; i++) é uma estrutura de repetição (laço).
  // Ela executa o bloco de código dentro das chaves 3 vezes.
  // A variável 'i' começa em 0, vai até 2 (pois i < 3), e a cada volta aumenta 1 (i++).
  for (let i = 0; i < 3; i++) {
    // basic.showIcon() exibe um ícone pré-definido pelo Micro:bit.
    // IconNames.Stars mostra um desenho de estrelas (simulando fogos).
    basic.showIcon(IconNames.Stars)
    // Pausa de 300 ms (quase 1/3 de segundo) para vermos as estrelas.
    basic.pause(300)
    
    // IconNames.Heart exibe um coração, representando o carinho pela conquista.
    basic.showIcon(IconNames.Heart)
    basic.pause(300)
    
    // IconNames.Happy exibe uma carinha feliz, celebrando a formatura.
    basic.showIcon(IconNames.Happy)
    basic.pause(300)
  } // Aqui o laço se repete. Quando termina, seguimos para a próxima linha.
  
  // Após terminar os 3 ciclos de fogos, limpamos a tela para deixar tudo escuro
  // e pronto para a próxima etapa (exibir o nome).
  basic.clearScreen()
}

// ==============================================================
// 4. LOOP PRINCIPAL (A EXECUÇÃO DO PROGRAMA)
// ==============================================================

// Quando o micro:bit é ligado ou reiniciado, o código executa de cima para baixo.
// A primeira coisa que fazemos é chamar a função de animação de formatura.
// Isso garante que, ao dar energia, o Micro:bit já comece com a "festa".
animacaoFormatura()

// Depois que a animação terminar, chamamos a função que exibe o nome do aluno.
// O nome será rolado uma vez na tela.
exibirNome()

// basic.forever() é um bloco especial que executa o código dentro dele
// REPETIDAMENTE, para sempre, enquanto o Micro:bit estiver ligado.
// É como um loop infinito que mantém o programa vivo e reagindo.
// Diferente do código que roda apenas uma vez (como o de cima), este roda sem parar.
basic.forever(function () {
  // Dentro do loop infinito, primeiro chamamos 'exibirNome()' novamente.
  // Isso faz o nome rolar na tela.
  exibirNome()
  
  // Depois de mostrar o nome, exibimos um ícone de coração fixo na tela.
  // Isso dá um efeito intercalado: mostra o nome, depois um coração,
  // depois o nome de novo, e assim por diante.
  basic.showIcon(IconNames.Heart)
  
  // Damos uma pausa de 1000 ms (1 segundo) para o coração ficar visível
  // por um tempo agradável antes de apagar.
  basic.pause(1000)
  
  // Apagamos a tela completamente para limpar o coração antes de recomeçar o ciclo.
  basic.clearScreen()
  
  // Pequena pausa de 500 ms para dar um "respiro" entre o coração apagado
  // e a próxima exibição do nome, evitando que as imagens se misturem.
  basic.pause(500)
  // Após essa pausa, o loop volta para o início (chama 'exibirNome()' de novo)
  // e repete esse ciclo para sempre: Nome -> Coração -> (limpa) -> Nome -> ...
})

⏱️ Detalhamento Minuto a Minuto (1h30 de evento)

📊 Critérios Operacionais de Avaliação (com pontuação)

• Compreender o conceito de arrays (listas) para armazenar sequências de dados.
• Programar um jogo da memória onde o micro:bit mostra uma sequência de LEDs e o jogador deve repeti-la.
• Utilizar funções para organizar o código (ex: gerarSequencia(), mostrarSequencia(), lerJogada()).
• Aplicar conceitos de interação (botões) e feedback (LEDs e som).
• Utilizar a matriz de LEDs para exibir a sequência e o feedback do jogador.
• Desenvolver uma versão com níveis de dificuldade crescentes.

📚 Conteúdo Programático

Arrays:

• O que são arrays (listas) e para que servem
• Como criar e manipular arrays: let lista: number[] = []
• Adicionar elementos: array.push(valor)
• Acessar elementos: array[indice]
• Percorrer arrays: for (let i = 0; i < array.length; i++)

Funções:

• Dividir o código em partes menores e reutilizáveis
• Criar funções com parâmetros e retorno
• Organizar a lógica do jogo em funções

Interatividade:

• Usar botões para entrada do usuário
• Capturar eventos: input.onButtonPressed()
• Gerenciar o fluxo do jogo com estados

Lógica de Jogo:

• Sequência: gerar, mostrar, ler, verificar
• Níveis de dificuldade: aumentar o tamanho da sequência
• Game over: quando o jogador erra

Matriz de LEDs:

• Controlar LEDs individuais: led.plot(x, y), led.unplot(x, y)
• Acender LED por posição (0-24): calcular coordenadas (x, y)
• Exibir padrões e animações

Game Design:

• Feedback visual (LEDs) e sonoro (buzzer)
• Níveis de dificuldade progressivos
• Pontuação (score)

📋 Habilidades BNCC e RCP-PR

🛠️ Materiais

Hardware:

Software:

Outros:

🔧 Montagem do Hardware

Esta semana utilizamos apenas o micro:bit (sem componentes externos):

• A matriz de LEDs exibirá as sequências
• Os botões A e B controlam o jogo
• O buzzer integrado fornece feedback sonoro

Conexão:

1. Conectar o micro:bit ao computador via cabo USB
2. Abrir o MakeCode
3. Programar o jogo
4. Testar no próprio micro:bit

💻 Código Micro:bit (Jogo da Memória Completo)

// ==============================================================
// PROJETO: JOGO DA MEMÓRIA COM MICRO:BIT
// DESCRIÇÃO: O micro:bit mostra uma sequência de LEDs que o
// jogador deve repetir. Versão com níveis.
// AUTOR: Equipe Robô na Veia
// VERSÃO: 1.0
// ==============================================================

// ==============================================================
// 1. VARIÁVEIS GLOBAIS
// ==============================================================

// Array para armazenar a sequência de LEDs (0 a 24)
// Cada número representa a posição de um LED na matriz 5x5
// Exemplo: posição 0 = canto superior esquerdo, 24 = canto inferior direito
let sequencia: number[] = []

// Nível atual do jogo (começa em 1)
// Cada novo nível adiciona mais um LED à sequência
let nivel = 0

// Índice da jogada atual (qual LED o jogador deve acertar)
// Controla em qual posição da sequência o jogador está
let jogadaAtual = 0

// Flag para controle do jogo (true = jogando, false = parado)
// Indica se o jogo está ativo ou não
let jogando = false

// Tempo entre os LEDs (ms) - controla a velocidade do jogo
// Quanto menor o valor, mais rápida a exibição da sequência
let tempoEspera = 500

// Pontuação do jogador
// A cada nível concluído com sucesso, ganha-se 10 pontos
let pontos = 0

// ==============================================================
// 2. FUNÇÃO PARA GERAR UMA SEQUÊNCIA ALEATÓRIA
// ==============================================================

/*
Gera um novo LED aleatório e o adiciona ao final da sequência.
A posição do LED é um número entre 0 e 24.
*/
function gerarSequencia() {
  // Gera um número aleatório entre 0 e 24 (posição de um LED)
  // Math.randomRange(0, 24) retorna um inteiro aleatório no intervalo fechado [0, 24]
  let novoLED = Math.randomRange(0, 24)
  // Adiciona o novo LED ao final da sequência usando o método push do array
  // Assim, a sequência cresce a cada nível
  sequencia.push(novoLED)
}

// ==============================================================
// 3. FUNÇÃO PARA MOSTRAR A SEQUÊNCIA NA MATRIZ DE LEDS
// ==============================================================

/*
Exibe a sequência de LEDs na matriz, um por vez.
Cada LED acende por um breve período, acompanhado de um som.
O jogador deve prestar atenção para depois repetir a ordem.
*/
function mostrarSequencia() {
  // Limpa a matriz de LEDs, apagando todos os pontos acesos
  basic.clearScreen()

  // Para cada LED armazenado na sequência (do primeiro ao último)
  for (let i = 0; i < sequencia.length; i++) {
    let posicao = sequencia[i] // Pega o número da posição (0 a 24)

    // Calcula as coordenadas x e y a partir da posição (0 a 24)
    // x = coluna (0-4), y = linha (0-4)
    let x = posicao % 5 // Resto da divisão por 5 -> dá um valor entre 0 e 4
    let y = Math.floor(posicao / 5) // Divisão inteira por 5 -> também entre 0 e 4
    // Exemplo: posição 7 => x = 7%5 = 2, y = floor(7/5) = 1 -> LED na coluna 2, linha 1

    // Acende o LED na posição (x, y) – plot acende o ponto
    led.plot(x, y)

    // Toca um som para cada LED (frequência varia com a posição)
    // Frequência: 500 Hz + (posição * 20 Hz) – cria um efeito sonoro diferente para cada LED
    // music.playTone(frequencia, duração em ms) – toca um tom puro
    music.playTone(500 + posicao * 20, 200)

    // Aguarda o tempo definido para que o jogador veja o LED aceso
    basic.pause(tempoEspera)

    // Apaga o LED (unplot apaga o ponto)
    led.unplot(x, y)

    // Aguarda um curto intervalo antes do próximo LED para dar um respiro
    basic.pause(200)
  }
}

// ==============================================================
// 4. FUNÇÃO PARA INICIAR O JOGO
// ==============================================================

/*
Função que inicia o jogo, resetando todas as variáveis.
É chamada quando o botão A é pressionado e o jogo está parado.
*/
function iniciarJogo() {
  // Reseta a sequência (começa vazia), o nível e a pontuação
  sequencia = []
  nivel = 1
  pontos = 0
  jogando = true      // Ativa o jogo
  jogadaAtual = 0     // Começa do primeiro LED da sequência

  // Mostra o nível atual no display de LED (exibe "N1")
  basic.showString("N" + nivel)
  basic.pause(500)    // Pausa para leitura
  basic.clearScreen() // Limpa a tela

  // Gera a primeira sequência (apenas um LED aleatório)
  gerarSequencia()
  // Mostra a sequência para o jogador
  mostrarSequencia()

  // Após mostrar, avisa que é a vez do jogador
  basic.showString("SUA VEZ")
  basic.pause(500)
  basic.clearScreen()
}

// ==============================================================
// 5. FUNÇÃO PARA VERIFICAR A JOGADA
// ==============================================================

/*
Função que verifica a jogada do jogador.
O jogador usa os botões para confirmar a posição do LED.
(Versão simplificada - em uma versão completa, o jogador
usaria os botões para navegar e confirmar a posição)
Aqui, a verificação é automática: sempre que o jogador pressiona B,
consideramos que ele acertou o LED atual e avançamos.
*/
function verificarJogada() {
  // Verifica se o jogador acertou todos os LEDs
  // (Nesta versão simplificada, assumimos que o jogador acertou)
  // Em uma versão completa, o jogador usaria os botões para confirmar

  // Avança para o próximo nível
  nivel++
  // Incrementa a pontuação em 10 pontos
  pontos += 10

  // Mostra o novo nível
  basic.showString("N" + nivel)
  basic.pause(500)
  basic.clearScreen()

  // Gera um novo LED aleatório e adiciona à sequência (aumenta a dificuldade)
  gerarSequencia()
  // Mostra a sequência completa novamente (incluindo o novo LED)
  mostrarSequencia()

  // Avisa que é a vez do jogador novamente
  basic.showString("SUA VEZ")
  basic.pause(500)
  basic.clearScreen()
}

// ==============================================================
// 6. FUNÇÃO DE GAME OVER
// ==============================================================

/*
Função que exibe a tela de Game Over.
Ela é chamada quando o jogador erra (nesta versão simplificada, nunca é chamada,
pois sempre consideramos acerto, mas está aqui para ser usada em versões futuras).
*/
function gameOver() {
  // Mostra um X na matriz (ícone "No" representa um "X")
  basic.showIcon(IconNames.No)
  // Toca um som grave e longo para indicar o fim
  music.playTone(200, 500)
  basic.pause(1000)

  // Mostra a pontuação final precedida de "P:"
  basic.showString("P:" + pontos)
  basic.pause(1000)
  basic.clearScreen()

  // Para o jogo (desativa a flag)
  jogando = false
}

// ==============================================================
// 7. CONTROLE DO JOGO
// ==============================================================

// Botão A: Inicia o jogo (se não estiver rodando)
// input.onButtonPressed é um evento que executa a função quando o botão é pressionado
input.onButtonPressed(Button.A, function () {
  // Se o jogo não estiver ativo, inicia
  if (!jogando) {
    iniciarJogo()
  }
})

// Botão B: Jogada do jogador (versão simplificada)
// Em uma versão completa, o botão B confirmaria a posição escolhida pelo jogador
input.onButtonPressed(Button.B, function () {
  // Se o jogo estiver ativo, chama a verificação (que assume acerto)
  if (jogando) {
    verificarJogada()
  }
})

// Botão A+B (pressionados simultaneamente): Interrompe o jogo
input.onButtonPressed(Button.AB, function () {
  if (jogando) {
    jogando = false                 // Para o jogo
    basic.showString("PAUSA")       // Mostra "PAUSA" no display
    basic.pause(500)
    basic.clearScreen()
  }
})

// ==============================================================
// 8. INICIALIZAÇÃO
// ==============================================================

// Quando o micro:bit é ligado (ou reiniciado), mostra a tela inicial
// basic.showString exibe caracteres rolando no display de LEDs
basic.showString("MEMORIA")
basic.pause(500)
basic.clearScreen()

// Instrução para o usuário: pressionar o botão A para iniciar
basic.showString("A=INICIAR")
basic.pause(1000)
basic.clearScreen()

// ==============================================================
// 9. LOOP PRINCIPAL (PARA MOSTRAR O STATUS)
// ==============================================================

// basic.forever executa um bloco de código repetidamente enquanto o micro:bit estiver ligado
basic.forever(function () {
  // Se o jogo não está rodando, exibe a mensagem de instrução periodicamente
  if (!jogando) {
    basic.showString("A=INICIAR")
    basic.pause(2000) // Espera 2 segundos para não ficar piscando muito rápido
    basic.clearScreen()
  }
  // Se o jogo estiver rodando, o forever não faz nada (apenas espera eventos)
})

⏱️ Detalhamento Minuto a Minuto (50 min)

♿ Orientações para Adaptações e Inclusão

📊 Critérios Operacionais de Avaliação (com pontuação)

• Encerrar o ano letivo com uma celebração descontraída e emocionante, celebrando todas as conquistas do ano.
• Assistir ao vídeo de melhores momentos (produzido ao longo do ano) como recordação afetiva.
• Distribuir as lembrancinhas finais (broches de circuito impresso) e os diários de bordo encadernados.
• Promover um momento de despedida que reforce o sentimento de pertencimento e orgulho.
• Programar uma animação de despedida na matriz de LEDs do micro:bit.
• Criar um "show de luzes" coletivo, onde todos os micro:bits piscam juntos.

📚 Conteúdo Programático

Culminância Festiva:

• Celebração do encerramento do projeto anual
• Reconhecimento de todas as conquistas

Memória e Afeto:

• Registro audiovisual das experiências vividas
• O poder das lembranças na construção da identidade

Rito de Despedida:

• Transição emocional para o 6º ano
• Encerramento de um ciclo e início de outro

Autoria e Protagonismo:

• Reconhecimento do próprio trabalho
• Orgulho do que foi construído

Animações com LEDs:

• Criar uma sequência de imagens na matriz
• Sincronizar vários micro:bits para um show de luzes

📋 Habilidades BNCC e RCP-PR

🛠️ Materiais

Multimídia:

Lembrancinhas:

Confraternização:

Micro:bits:

🔧 Montagem do Hardware

Animação de Despedida:

1. Conectar o micro:bit ao computador via cabo USB
2. Programar com o código da animação
3. Testar a animação
4. Repetir para todos os micro:bits

Show de Luzes Coletivo:

• Todos os alunos ligam seus micro:bits ao mesmo tempo
• As animações devem estar sincronizadas (opcional)
• O professor pode fazer uma contagem regressiva para o "show"

💻 Código Micro:bit (Animação de Despedida + Show de Luzes)

// ==============================================================
// PROJETO: ANIMAÇÃO DE DESPEDIDA + SHOW DE LUZES
// DESCRIÇÃO: Exibe uma animação especial de despedida na
// matriz de LEDs, seguida de um show de luzes.
// AUTOR: Equipe Robô na Veia
// VERSÃO: 1.0
// ==============================================================

// ==============================================================
// 1. FUNÇÃO PARA ANIMAÇÃO DE DESPEDIDA
// ==============================================================

/*
Função que exibe uma animação de despedida na matriz de LEDs.
Inclui coração grande, coração pequeno, estrela e "FIM".
*/
function animacaoDespedida() {
  // ------------------------------------------------------------
  // Animação 1: Coração grande (ocupando toda a matriz)
  // A matriz de LEDs do micro:bit tem 5 linhas e 5 colunas.
  // Cada caractere '#' representa um LED aceso, '.' representa um LED apagado.
  // O desenho abaixo forma um coração grande, preenchendo quase toda a tela.
  // ------------------------------------------------------------
  basic.showLeds(`
    . # # # .
    # # # # #
    # # # # #
    . # # # .
    . . # . .
  `)                    // Exibe o padrão de LEDs na matriz
  basic.pause(500)      // Pausa a execução por 500 milissegundos (meio segundo)
                        // para que o desenho fique visível antes de mudar

  // ------------------------------------------------------------
  // Animação 2: Coração pequeno (no centro)
  // Aqui usamos um padrão vazio para limpar a tela,
  // mas a intenção é exibir um coração pequeno (no centro).
  // O código atual está mostrando uma tela vazia, o que pode ser
  // um erro de digitação, pois não forma um coração.
  // Na prática, o efeito é uma tela apagada por 500ms.
  // ------------------------------------------------------------
  basic.showLeds(`
    . . . . .
    . . . . .
    . . . . .
    . . . . .
    . . . . .
  `)                    // Exibe tela completamente apagada
  basic.pause(500)      // Pausa por 500ms

  // ------------------------------------------------------------
  // Animação 3: Estrela
  // O micro:bit possui ícones pré-definidos. 'IconNames.Stars'
  // representa o ícone de uma estrela (com vários pontinhos).
  // ------------------------------------------------------------
  basic.showIcon(IconNames.Stars)  // Exibe o ícone de estrela
  basic.pause(500)                 // Pausa por 500ms

  // ------------------------------------------------------------
  // Animação 4: Feliz
  // Ícone de um rosto feliz (sorriso).
  // ------------------------------------------------------------
  basic.showIcon(IconNames.Happy)  // Exibe o ícone de rosto feliz
  basic.pause(500)                 // Pausa por 500ms

  // ------------------------------------------------------------
  // Animação 5: Palavra "FIM"
  // A função showString exibe caracteres em sequência na matriz,
  // rolando o texto da esquerda para a direita (ou mostrando letra por letra).
  // Aqui exibirá "F" "I" "M" um após o outro.
  // ------------------------------------------------------------
  basic.showString("FIM")          // Exibe a string "FIM" na matriz
  basic.pause(500)                 // Pausa por 500ms após terminar a exibição
}

// ==============================================================
// 2. FUNÇÃO PARA SHOW DE LUZES
// ==============================================================

/*
Função que exibe um show de luzes na matriz de LEDs.
Inclui pisca-pisca e onda de LEDs.
*/
function showDeLuzes() {
  // ------------------------------------------------------------
  // Fase 1: Pisca-pisca rápido
  // Este loop repete 10 vezes o acendimento e apagamento de todos os LEDs.
  // ------------------------------------------------------------
  for (let i = 0; i < 10; i++) {   // i é o contador, vai de 0 a 9 (10 iterações)
    // Acende todos os LEDs da matriz 5x5
    // Para isso, percorremos todas as coordenadas x (coluna) de 0 a 4
    // e y (linha) de 0 a 4.
    for (let x = 0; x < 5; x++) {   // x representa a coluna (0 a 4)
      for (let y = 0; y < 5; y++) { // y representa a linha (0 a 4)
        led.plot(x, y)              // Acende o LED na posição (x, y)
      }                             // Fim do loop y
    }                               // Fim do loop x
    basic.pause(100)                // Mantém todos acesos por 100ms

    // Apaga todos os LEDs
    for (let x = 0; x < 5; x++) {
      for (let y = 0; y < 5; y++) {
        led.unplot(x, y)            // Apaga o LED na posição (x, y)
      }
    }
    basic.pause(100)                // Mantém todos apagados por 100ms
  }                                 // Fim do loop de 10 repetições

  // ------------------------------------------------------------
  // Fase 2: Onda de LEDs
  // Percorre cada linha (y) e dentro de cada linha, cada coluna (x),
  // acendendo um LED por vez em ordem, criando um efeito de "onda".
  // ------------------------------------------------------------
  for (let linha = 0; linha < 5; linha++) {   // linha varia de 0 a 4
    for (let coluna = 0; coluna < 5; coluna++) { // coluna varia de 0 a 4
      led.plot(coluna, linha)   // Acende o LED na posição (coluna, linha)
      basic.pause(50)           // Pausa de 50ms para cada LED, criando efeito de movimento
    }                           // Fim do loop coluna
    basic.pause(100)            // Após completar uma linha, pausa de 100ms
  }                             // Fim do loop linha

  // ------------------------------------------------------------
  // Limpa a tela
  // Após o show, apaga todos os LEDs para preparar a próxima parte.
  // ------------------------------------------------------------
  basic.clearScreen()           // Desliga todos os LEDs da matriz
}

// ==============================================================
// 3. LOOP PRINCIPAL
// ==============================================================

// Quando o micro:bit é ligado (ou resetado), o código executa
// as funções na ordem em que aparecem.
// A primeira função chamada é a animação de despedida.
animacaoDespedida()   // Executa a animação de despedida (corações, estrela, "FIM")

// Depois que a animação termina, executa o show de luzes.
showDeLuzes()         // Executa o show com pisca-pisca e onda

// Após a execução das funções acima, o programa entra em um loop infinito
// que mantém o micro:bit mostrando um coração piscando.
// A função basic.forever executa o bloco de código repetidamente enquanto
// o micro:bit estiver ligado.
basic.forever(function () {
  // Exibe o ícone de coração (preenchido)
  basic.showIcon(IconNames.Heart)   // Mostra o coração na matriz
  basic.pause(1000)                 // Aguarda 1 segundo (1000ms) com o coração aceso

  // Apaga a tela (remove o coração)
  basic.clearScreen()               // Desliga todos os LEDs
  basic.pause(1000)                 // Aguarda 1 segundo com a tela apagada

  // O loop se repete: coração aceso, apagado, aceso, apagado...
})   // Fim do bloco forever

⏱️ Detalhamento Minuto a Minuto (50 min)

📊 Critérios Operacionais de Avaliação (com pontuação)