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

• Observar a rotina escolar (corredores, salas, pátio, biblioteca) e identificar problemas que poderiam ser resolvidos com automação simples (loop + condicional + sensores).
• Listar critérios de viabilidade: segurança, materiais disponíveis, tempo, impacto real.
• Decidir, em equipe, UM problema para ser atacado durante todo o bimestre.
• Desenvolver o olhar investigativo próprio do pensamento computacional: observar, perguntar, registrar.

📚 Conteúdo Programático

Metodologia de Projeto: Observação, levantamento de requisitos, análise de viabilidade. A engenharia começa com a pergunta certa, não com a resposta.

Sensores do micro:bit:

• Botões A e B — sensores de toque (entrada digital)
• Acelerômetro — sensor de movimento (detecta inclinação, tremor, queda)
• Matriz de LEDs — saída visual (mostra números, letras, ícones)
• Sensor de luz — os LEDs também funcionam como sensor de luz ambiente!

Pensamento Computacional: Decomposição do problema em partes (entrada, processamento, saída). Qual é a entrada? O sensor. Qual é o processamento? A lógica do SE/REPITA. Qual é a saída? O LED, o som (se tiver alto-falante).

Critérios de Viabilidade: Segurança, Materiais, Tempo, Impacto.

📋 Habilidades BNCC e RCP-PR

EF04CI01, Competência 4 (BNCC), RCP-PR (Autoria de sistemas simples), RCP-PR (Programação colaborativa).

🧰 Materiais (Kit Detetives)

💻 Código de Demonstração dos Sensores

// ============================================================
// DEMONSTRAÇÃO DOS SENSORES DO MICRO:BIT
// Use este código para mostrar aos alunos o que cada sensor faz
// ============================================================

// ------------------------------------------------------------------
// BLOCO 1: BOTÃO A – MEDIÇÃO DA INTENSIDADE LUMINOSA
// ------------------------------------------------------------------
// Quando o botão A for pressionado, o micro:bit lê o valor do sensor
// de luz ambiente (que fica na superfície da placa, próximo aos LEDs).
// O valor retornado é um número entre 0 (escuro total) e 255 (muito claro).
// Esse número é exibido no visor de LED durante alguns segundos.
// ------------------------------------------------------------------
input.onButtonPressed(Button.A, function () {
  // Lê o nível de luz e armazena na variável 'luz'
  let luz = input.lightLevel()
  // Mostra o valor numérico no visor (os LEDs acendem formando o número)
  basic.showNumber(luz)
})

// ------------------------------------------------------------------
// BLOCO 2: BOTÃO B – ACELERÔMETRO (INCLINAÇÃO E MOVIMENTO)
// ------------------------------------------------------------------
// Quando o botão B for pressionado, o micro:bit lê os valores de
// aceleração nos eixos X (horizontal) e Y (vertical) do acelerômetro.
// A aceleração é medida em milig (miligravidade), sendo aproximadamente
// 1000 mg quando o micro:bit está parado na horizontal (medindo a gravidade).
// Os valores são exibidos como texto no visor, com o formato "X=... Y=...".
// ------------------------------------------------------------------
input.onButtonPressed(Button.B, function () {
  // Lê a aceleração no eixo X (esquerda/direita)
  let x = input.acceleration(Dimension.X)
  // Lê a aceleração no eixo Y (frente/trás)
  let y = input.acceleration(Dimension.Y)
  // Exibe uma mensagem de texto com os dois valores medidos
  basic.showString("X=" + x + " Y=" + y)
})

// ------------------------------------------------------------------
// BLOCO 3: LOOP INFINITO – ANIMAÇÃO DE "ESPERA" (BACKGROUND)
// ------------------------------------------------------------------
// Este bloco executa continuamente enquanto o micro:bit estiver ligado.
// Ele não interfere nos botões, pois os eventos são assíncronos.
// A função 'showLeds' exibe um padrão de LEDs; aqui desenhamos uma
// matriz 5x5 totalmente apagada (todos os pontos são '.').
// Em seguida, pausamos por 1 segundo, limpamos a tela e pausamos
// mais 1 segundo. O efeito visual é um "pisca-pisca" sutil: a tela
// fica apagada o tempo todo, mas as pausas alternam entre o estado
// de "padrão vazio" e "tela limpa" – na prática, não há mudança
// visível, mas serve para demonstrar o uso do loop forever e pausas.
// Se desejar, você pode substituir o padrão vazio por uma animação
// (por exemplo, um coração) para tornar o efeito mais perceptível.
// ------------------------------------------------------------------
basic.forever(function () {
  // Exibe uma matriz 5x5 com todos os LEDs apagados
  basic.showLeds(`
    . . . . .
    . . . . .
    . . . . .
    . . . . .
    . . . . .
  `)
  // Aguarda 1000 milissegundos (1 segundo)
  basic.pause(1000)
  // Limpa completamente a tela (todos os LEDs apagados)
  basic.clearScreen()
  // Aguarda mais 1 segundo
  basic.pause(1000)
})

⏱️ Minuto a Minuto (50 min)

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

• TEA: Oferecer lista de problemas pré-selecionados ("Apaga-luz", "Avisa-giz", "Organiza-fila").
• Altas habilidades: Escolher problema com duas camadas (apaga luz + tranca porta).
• Deficiência motora: Usar gravador de voz no tablet para registrar as observações.
• Baixa visão: Descrever os problemas oralmente e usar maquetes táteis.
• TDAH: Fornecer uma checklist com etapas da caminhada para manter o foco.

📊 Critérios Operacionais de Avaliação

• Planejar o projeto por escrito: objetivo, materiais, algoritmo em português estruturado (passo a passo).
• Produzir a primeira versão do "Manual do Robô" um texto instrucional claro, com linguagem objetiva, para que outro grupo possa operá-lo.
• Reconhecer a importância da documentação na engenharia (e na vida).
• Desenvolver a abstração: traduzir a solução do problema em passos lógicos, sem se perder em detalhes.

📚 Conteúdo Programático

Texto Instrucional: Características (linguagem clara, verbos no imperativo, sequência lógica, uso de imagens/símbolos). Por que um manual precisa ser detalhado? Porque o leitor não pode adivinhar o que está na sua cabeça.

Algoritmo em Português Estruturado: Traduzir o problema em passos lógicos, usando palavras como `REPITA`, `SE`, `ENTÃO`, `SENÃO`, `ENQUANTO`. É a ponte entre o pensamento e o código.

Decomposição: Quebrar o problema em partes: entrada (sensores), processamento (lógica), saída (LEDs, sons).

Versionamento: Todo bom projeto tem versões. A versão 1.0 é o planejamento; depois vêm as melhorias.

📋 Habilidades BNCC e RCP-PR

EF04LP11, Competência 5 (BNCC), RCP-PR (Programação colaborativa), RCP-PR (Autoria de sistemas simples).

🧰 Materiais (Kit Manual)

💻 Algoritmo em Português Estruturado (Exemplo)

ALGORITMO: Apaga-Luz 3000
VERSÃO: 1.0

INÍCIO

REPITA PARA SEMPRE:
  LEIA o sensor de luz (lightLevel)
  SE o sensor de luz for MENOR que 50 (está escuro) ENTÃO
    MOSTRE no LED: "LUZ" (para avisar)
    ESPERE 2 segundos
    APAGUE o LED
  SENÃO
    NÃO faça nada (está claro)
  FIM SE
FIM REPITA

FIM

⏱️ Minuto a Minuto (50 min)

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

• Dislexia: Permitir gravação de áudio do manual ou usar símbolos (setas, carinhas em vez de texto).
• Deficiência visual: Manual em braille ou letra grande (tamanho 24+) com relevo.
• TDAH: Template com campos coloridos e espaços bem delimitados.
• Deficiência intelectual: Oferecer frases prontas para completar ("O robô ______ quando o sensor detectar ______.").
• Altas habilidades: Incluir uma seção "E se...?" com possíveis variações (desafio extra de criatividade).

📊 Critérios Operacionais de Avaliação

• Construir a estrutura física do robô (ou protótipo) usando materiais recicláveis, de acordo com o manual.
• Posicionar o micro:bit e os sensores nos locais adequados (ex: micro:bit como "cérebro", LEDs como "olhos").
• Conectar a estrutura ao micro:bit (usando o suporte de pilhas para alimentação externa).
• Desenvolver a criatividade e a persistência ao lidar com materiais que não se comportam como o esperado.

📚 Conteúdo Programático

Prototipagem: Transformar um projeto em modelo físico testar forma, função e encaixes. É o momento de errar no barato para acertar no caro.

Propriedades dos Materiais: Rigidez, flexibilidade, peso, aderência. Por que papelão não segura um micro:bit pesado? Por que fita adesiva não é tão boa quanto cola quente?

Movimento e Energia: Como o micro:bit transforma energia elétrica em luz (LEDs) e movimento (através do acelerômetro). Conexão com EF04CI01.

Integração Hardware-Software: Conectar o micro:bit à estrutura física. O micro:bit vai no "cérebro" do robô, os LEDs são os "olhos", os botões são as "mãos".

📋 Habilidades BNCC e RCP-PR

EF04CI01, Competência 4 (BNCC), RCP-PR Integrar hardware ao planejamento, RCP-PR (Programação colaborativa).

🧰 Materiais (Kit Prototipagem)

💻 Código de Teste do Robô

// ============================================================
// TESTE DO ROBÔ VERSÃO 1.0
// Este código testa se o micro:bit está funcionando no robô
// ============================================================

/*
 * CORREÇÕES REALIZADAS:
 * ---------------------
 * 1. Adicionada variável 'bloqueado' para impedir que o loop principal
 *    (forever) interrompa a exibição de mensagens (botão A) ou a dança (botão B).
 * 2. Loop principal agora mostra um ícone de coração intercalado com tela limpa,
 *    criando um efeito de "batimento" visível (antes era todo apagado).
 */

// --- Variável global de controle: impede que o forever interrompa ações dos botões ---
// 'bloqueado' é uma flag booleana. Quando true, o loop principal (forever) 
// não executa seu conteúdo principal, garantindo que ações iniciadas por botões
// não sejam interrompidas. Isso evita concorrência entre o loop e os eventos.
let bloqueado = false

// --- Quando o robô ligar, ele se apresenta ---
// Ao iniciar, o micro:bit exibe a palavra "ROBO" rolando na matriz de LEDs.
// Isso confirma que o programa foi carregado e o hardware está funcionando.
basic.showString("ROBO")

// --- Loop principal: o robô "vive" ---
// Agora com um batimento cardíaco visível: coração acende e apaga.
// O 'forever' executa repetidamente enquanto o micro:bit estiver ligado.
basic.forever(function () {
    // Só executa o batimento se nenhuma ação dos botões estiver em andamento
    // Se bloqueado for true, significa que um botão foi pressionado e 
    // estamos no meio de uma animação/mensagem; então pulamos o batimento.
    if (!bloqueado) {
        // Mostra um coração (símbolo de "vida") - isso acende todos os LEDs 
        // que formam o desenho de um coração na matriz 5x5.
        basic.showIcon(IconNames.Heart)
        basic.pause(500)          // coração aceso por 500 ms (meio segundo)
        basic.clearScreen()       // apaga todos os LEDs da matriz
        basic.pause(500)          // apagado por 500 ms - isso dá o efeito de piscada
    } else {
        // Se estiver bloqueado, apenas espera um pouco para não sobrecarregar
        // a CPU com um loop vazio. 100 ms é um intervalo curto e suficiente.
        basic.pause(100)
    }
})

// --- Botão A: o robô "fala" ---
// A função é registrada como callback para o evento de pressão do botão A.
// Quando o botão A é pressionado, o micro:bit executa este código.
input.onButtonPressed(Button.A, function () {
    // Bloqueia o loop principal para não cortar a mensagem
    // Ao colocar bloqueado = true, o forever para de piscar o coração,
    // evitando que a mensagem "OI" seja interrompida ou sobreposta.
    bloqueado = true
    // Exibe "OI" rolando na matriz (agora sem interrupções)
    // A função showString percorre cada caractere, deslocando-o na tela.
    basic.showString("OI")
    // Libera o loop principal após a exibição
    // Quando a mensagem termina, liberamos o bloqueio para que o batimento 
    // seja retomado.
    bloqueado = false
})

// --- Botão B: o robô "dança" ---
// Callback para o botão B – executa uma sequência de ícones alternados.
input.onButtonPressed(Button.B, function () {
    // Bloqueia o loop principal durante a dança
    // Garante que o batimento não atrapalhe a coreografia.
    bloqueado = true
    // Repete 5 vezes a troca entre carinha feliz e triste.
    for (let i = 0; i < 5; i++) {
        // Mostra o ícone de feliz (smile) por 200 ms
        basic.showIcon(IconNames.Happy)
        basic.pause(200)
        // Mostra o ícone de triste (sad) por 200 ms
        basic.showIcon(IconNames.Sad)
        basic.pause(200)
    }
    // Ao final, apaga a tela para não deixar nenhum ícone fixo.
    basic.clearScreen()
    // Libera o loop principal após terminar a dança.
    bloqueado = false
})

⏱️ Minuto a Minuto (50 min)

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

• Deficiência motora: Usar peças de encaixe grandes (Lego Duplo) ou kits prontos.
• TEA: Fornecer modelo visual da construção esperada (foto ou desenho passo a passo).
• Baixa visão: Usar materiais contrastantes (fitas coloridas para identificar partes).
• Altas habilidades: Desafio extra: "Adicione uma segunda função" (além de apagar a luz, acende quando alguém chega).
• TDAH: Checklist visual com etapas claras: cortar → colar → testar → anotar.

📊 Critérios Operacionais de Avaliação

• Acrescentar um evento concorrente ao código principal: enquanto o robô executa a tarefa principal, ele também pisca um LED, mostra uma animação ou reage a um botão.
• Ajustar o código para que dois loops rodem "ao mesmo tempo" (paralelismo) e testar se há interferência.
• Compreender que, em sistemas reais, múltiplas tarefas podem competir por recursos (processamento, energia).
• Desenvolver a depuração ao identificar e corrigir conflitos entre eventos.

📚 Conteúdo Programático

Eventos Concorrentes: Execução paralela de dois ou mais scripts no micro:bit, `basic.forever` e `input.onButtonPressed` rodam simultaneamente. Isso simula o multitarefa dos robôs reais.

Multitarefa em Sistemas Embarcados: Como robôs (e computadores) lidam com múltiplas tarefas (time-sharing, interrupções). Exemplo: o cérebro humano também faz várias coisas ao mesmo tempo andar e conversar, por exemplo.

Interferência entre Processos: Quando um evento atrapalha o outro (ex: piscar LED consome tempo de processamento e deixa o movimento mais lento). Isso ensina sobre otimização e trade-offs.

Sincronização: Em alguns casos, precisamos que os eventos conversem entre si.

📋 Habilidades BNCC e RCP-PR

Competência 5 (BNCC), EF04CI01, RCP-PR (Autoria de sistemas simples), RCP-PR (Programação colaborativa).

🧰 Materiais (Kit Concorrência)

💻 Código com Eventos Concorrentes

// =================================================================
//  TÍTULO: EVENTOS CONCORRENTES NO micro:bit (VERSÃO DIDÁTICA)
//  PROPÓSITO: Demonstrar o funcionamento de múltiplas tarefas
//  (loops e eventos) executando em paralelo (concorrência) e
//  como elas interagem ao compartilhar a matriz de LEDs.
//  HARDWARE UTILIZADO:
//    - BBC micro:bit (placa)
//    - Matriz de LEDs 5x5
//    - Botão A
//    - Botão B
//    - Acelerômetro (sensor de movimento)
//    - Cabo USB, suporte de pilhas, computador e monitor
// =================================================================

// -------------------- EXPLICAÇÃO GERAL ----------------------------
// O micro:bit executa os blocos 'forever' e os manipuladores de
// eventos de forma *intercalada* (não simultânea, mas concorrente).
// Isso significa que, enquanto um loop está em execução, ele pode
// ser pausado a qualquer momento para atender a um evento (botão
// ou gesto) ou para dar vez a outro loop. A ordem de execução não
// é determinística, e isso gera efeitos interessantes (e por vezes
// conflitantes) na tela – justamente o que queremos explorar.
// -----------------------------------------------------------------

// ================================================================
//  TAREFA 1 – MONITOR DE LUZ AMBIENTE (loop principal)
//  Este loop lê continuamente o sensor de luz e exibe uma
//  representação visual na matriz de LEDs.
//  - Se estiver escuro (luz < 50): mostra a palavra "LUZ".
//  - Se estiver claro: desenha um padrão de "sol" (LEDs acesos).
//  O loop tem uma pausa de 500ms para que a tela seja visível e
//  para dar chance aos outros blocos de executarem.
// ================================================================
basic.forever(function () {
    let luz = input.lightLevel()          // lê o valor (0 a 255)

    if (luz < 50) {
        // Exibe o texto "LUZ" rolando – isso ocupa a tela por ~1s
        basic.showString("LUZ")
        basic.pause(1000)
        basic.clearScreen()
    } else {
        // Mostra um "sol" (LEDs centrais acesos) como indicador de claro
        // Desenha um SOL na matriz de LEDs 5x5
        basic.showLeds(`
            # . # . #
            . # # # .
            # # # # #
            . # # # .
            # . # . #
        `)
        basic.pause(500)
        basic.clearScreen()
        basic.pause(500)
    }
})

// ================================================================
//  TAREFA 2 – INDICADOR DE INCLINAÇÃO (loop secundário)
//  Este loop lê a orientação do acelerômetro e exibe uma seta
//  apontando para a direção da inclinação (N, S, L, O).
//  Ele também escreve na matriz, concorrendo com a Tarefa 1.
//  O resultado visual é uma alternância (ou sobreposição) entre
//  a informação de luz e a de inclinação.
// ================================================================
basic.forever(function () {
    // Obtém a direção da inclinação (0° = norte, 90° = leste, etc.)
    let direcao = input.compassHeading()   // 0 a 359 (graus)
    // Nota: O compasso exige calibragem; para efeito didático,
    // usamos o acelerômetro para detectar inclinação (roll/pitch)
    // e mostrar setas. Vamos usar uma função simplificada:
    let inclinacaoX = input.acceleration(Dimension.X)
    let inclinacaoY = input.acceleration(Dimension.Y)

    // Decide qual seta mostrar com base nos eixos X e Y
    if (Math.abs(inclinacaoX) > 200 && Math.abs(inclinacaoX) > Math.abs(inclinacaoY)) {
        // Inclinação lateral forte
        if (inclinacaoX < 0) {
            basic.showArrow(ArrowNames.West)   // inclinado para esquerda
        } else {
            basic.showArrow(ArrowNames.East)   // inclinado para direita
        }
    } else if (Math.abs(inclinacaoY) > 200) {
        // Inclinação para frente/trás
        if (inclinacaoY < 0) {
            basic.showArrow(ArrowNames.North)  // inclinado para frente
        } else {
            basic.showArrow(ArrowNames.South)  // inclinado para trás
        }
    } else {
        // Inclinação pequena: mostra um ponto central
        basic.showLeds(`
            . . . . .
            . . . . .
            . . # . .
            . . . . .
            . . . . .
        `)
    }
    basic.pause(800)   // pausa para dar visibilidade e alternância
})

// ================================================================
//  EVENTO: BOTÃO A – Mostra um rosto feliz
//  Quando pressionado, este evento é disparado imediatamente,
//  interrompendo qualquer loop em execução para exibir o ícone.
//  Após 1 segundo, a tela é limpa e os loops retomam.
// ================================================================
input.onButtonPressed(Button.A, function () {
    basic.showIcon(IconNames.Happy)   // exibe o sorriso
    basic.pause(1000)
    basic.clearScreen()
})

// ================================================================
//  EVENTO: BOTÃO B – Mostra um rosto triste
//  Funciona de maneira análoga ao botão A, mas com expressão triste.
// ================================================================
input.onButtonPressed(Button.B, function () {
    basic.showIcon(IconNames.Sad)
    basic.pause(1000)
    basic.clearScreen()
})

// ================================================================
//  EVENTO: GESTO DE "SHAKE" (balançar o micro:bit)
//  O acelerômetro detecta um movimento brusco e dispara este evento.
//  Mostra um ponto de exclamação (!) para indicar surpresa.
// ================================================================
input.onGesture(Gesture.Shake, function () {
    basic.showIcon(IconNames.Yes)    // o ícone "Yes" é um "check", mas
    // poderíamos usar "No" ou um desenho
    basic.pause(1000)
    basic.clearScreen()
})

// ================================================================
//  OBSERVAÇÕES FINAIS SOBRE CONCORRÊNCIA:
//  - Os dois loops `forever` executam indefinidamente, cada um com
//    sua própria taxa de atualização (500ms e 800ms). Como ambos
//    escrevem na mesma matriz, o que vemos na tela é uma mistura
//    (alternância) dos dois conteúdos – a menos que um deles seja
//    interrompido por um evento.
//  - Os eventos (botões e shake) têm prioridade alta: quando ocorrem,
//    o micro:bit pausa os loops e executa o bloco do evento, depois
//    retoma os loops. Isso demonstra o conceito de *interrupção*.
//  - Esse comportamento não é sincronizado; portanto, a tela pode
//    exibir fragmentos de diferentes tarefas, o que é intencional
//    para fins de aprendizado sobre concorrência e a necessidade
//    de mecanismos de exclusão mútua (como variáveis de estado)
//    em aplicações reais.
// ================================================================

⏱️ Minuto a Minuto (50 min)

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

• TDAH: Usar evento simples (apenas ligar/desligar o LED sem temporizador).
• Altas habilidades: Adicionar terceiro evento condicional ("Se detectar inclinação, muda a cor do LED").
• TEA: Oferecer diagrama visual mostrando os dois scripts paralelos.
• Deficiência intelectual: Professor auxilia na escolha de um evento único e simples.

📊 Critérios Operacionais de Avaliação

• Testar o robô em condições reais (sala de aula com variação de luz, movimento, obstáculos) e registrar sistematicamente cada bug.
• Preencher a tabela de bugs com colunas: O que aconteceu?, Qual a causa?, Como corrigimos?, Corrigido? (sim/não).
• Trabalhar em trio com papéis rotativos: piloto (opera o robô), copiloto (observa e anota), engenheiro (sugere correções). Cada rodada troca os papéis.
• Desenvolver a depuração sistemática como prática científica: observar, hipotetizar, testar, corrigir.

📚 Conteúdo Programático

Depuração (Debugging): Processo científico de identificar, isolar e corrigir erros não é "tentar de novo", é "observar, hipotetizar, testar, corrigir". O bug é um professor disfarçado.

Teste de Software: Planejar testes que cobrem diferentes cenários (luz forte, luz fraca, obstáculo, superfície lisa/áspera). Um bom teste é aquele que tenta quebrar o sistema.

Trabalho Colaborativo: Divisão de papéis com responsabilidades claras piloto não pode anotar, copiloto não pode tocar no robô, engenheiro não pode executar. Isso desenvolve disciplina e respeito mútuo.

Registro de Ocorrências: A tabela de bugs é um gênero textual técnico objetivo, claro, com dados observáveis.

📋 Habilidades BNCC e RCP-PR

Competência 5 (BNCC), EF04LP11, RCP-PR (Programação colaborativa), RCP-PR (Autoria de sistemas simples).

🧰 Materiais (Kit Caça ao Bug)

💻 Correção de Bug (Exemplo)

// ============================================================
// BLOCO 1: CÓDIGO COM BUG (antes da correção)
// ============================================================

/*
 * COMENTÁRIO DIDÁTICO:
 * O bloco abaixo contém um erro lógico muito comum em programação com microcontroladores.
 * O objetivo é acionar um alerta visual (mostrar "LUZ") sempre que o ambiente estiver escuro
 * (nível de luz < 50). Porém, o código original não limpa a tela após exibir a mensagem.
 * 
 * Como funciona o showString()?
 * - Ele exibe caracteres em rolagem (scroll) no display de LEDs.
 * - Após terminar a rolagem, o micro:bit mantém o ÚLTIMO frame (pedaço) da animação
 *   fixo na tela, a menos que você ordene explicitamente que a tela seja apagada.
 * 
 * O que acontece na prática?
 * - Se a luz estiver baixa, a mensagem "LUZ" rola uma vez e para.
 * - O último caractere ("Z") ou parte dele fica aceso para sempre, porque nunca
 *   chamamos basic.clearScreen().
 * - Quando a luz volta a ficar acima de 50, a condição não é mais verdadeira,
 *   mas como a tela nunca foi limpa, o pedaço da mensagem continua lá, dando a
 *   impressão de que o programa "travou" ou que o LED não apaga.
 */

// -- CÓDIGO COM BUG (antes da correção) --
basic.forever(function () {
    // basic.forever() é um loop infinito que executa o bloco repetidamente,
    // enquanto o micro:bit estiver ligado. Ele é ideal para ler sensores
    // continuamente.

    let luz = input.lightLevel()
    // input.lightLevel() lê a intensidade da luz ambiente através dos LEDs
    // do display. O valor retornado varia de 0 (escuro total) a 255 (muito claro).
    // Este valor é armazenado na variável 'luz'.

    if (luz < 50) {
        // Condição de teste: se o nível de luz for MENOR que 50, consideramos
        // que está escuro e devemos emitir o alerta.

        basic.showString("LUZ")
        // Exibe a palavra "LUZ" em rolagem no display.
        // ATENÇÃO AO BUG: Após a rolagem terminar, o micro:bit NÃO limpa
        // automaticamente a tela. Ele mantém o último padrão de LEDs aceso.
        // A função showString() tem um pequeno atraso interno para a animação,
        // mas, ao final, a tela fica com o último caractere visível.
        // FALTAVA O basic.clearScreen() NO ELSE!
        // O texto ficava na tela para sempre!
    }
    // Fim do if. Se a luz for >= 50, nada é executado, mas a tela continua
    // mostrando o que quer que estivesse lá (no caso, o resto do "LUZ").
    // O loop forever recomeça imediatamente, mas como a condição agora é falsa,
    // ele não faz nada novo e a tela permanece suja.
})

// ============================================================
// BLOCO 2: CÓDIGO CORRIGIDO (depois) – VERSÃO COM ALTERAÇÃO MÍNIMA
// ============================================================

/*
 * COMENTÁRIO DIDÁTICO SOBRE A CORREÇÃO APLICADA:
 * Nesta versão, optou-se por uma mudança simples: quando a luz está alta,
 * em vez de simplesmente não fazer nada (o que deixava resíduos), agora
 * exibimos a mensagem "OK" para indicar que o ambiente está claro.
 * 
 * EFEITO:
 * - Se escuro → mostra "LUZ" (rolagem, depois fica estático na tela).
 * - Se claro → mostra "OK" (rolagem, depois fica estático na tela).
 * 
 * Isso substitui a mensagem antiga pela nova, mas AINDA NÃO APAGA A TELA.
 * O problema de "ficar com resíduo" é parcialmente mitigado porque a tela
 * agora sempre mostra algo relevante (ou "LUZ" ou "OK"), mas se não houver
 * mensagem a ser mostrada (por exemplo, se a luz oscilar e o programa
 * não atualizar), ainda pode haver um frame antigo. Além disso, se desejar
 * que a tela fique completamente apagada em algum momento, seria necessário
 * chamar basic.clearScreen() explicitamente.
 * 
 * Esta abordagem é uma correção mínima que mantém o usuário informado,
 * mas não é uma limpeza total. Para um comportamento mais limpo, veja
 * a sugestão no resumo final.
 */

// -- CÓDIGO CORRIGIDO (depois) --
basic.forever(function () {
    // Loop infinito para monitoramento contínuo.

    let luz = input.lightLevel()
    // Leitura do nível de luz.

    if (luz < 50) {
        // Se estiver escuro...

        basic.showString("LUZ")
        // Exibe a mensagem "LUZ" em rolagem. Após a rolagem, a mensagem
        // permanece na tela (último frame) enquanto a condição for verdadeira.
        // Isso garante que o alerta fique visível durante todo o período escuro.
    } else {
        // Se a luz for igual ou superior a 50 (ambiente claro)...

        basic.showString("OK")
        // Exibe "OK" para indicar que a luz está normal. Essa mensagem
        // substitui a anterior, evitando que a tela fique com "LUZ" quando
        // não é mais necessário. Porém, a tela ainda não é apagada – apenas
        // atualizada com um novo texto. Se você quiser que a tela fique
        // completamente escura em vez de mostrar "OK", substitua esta linha
        // por basic.clearScreen().
    }
    // O loop recomeça imediatamente. Se a condição permanecer a mesma,
    // o showString() será chamado novamente a cada iteração, fazendo a
    // rolagem reiniciar. Isso pode causar um pequeno "pisca" ou reinício
    // da animação. Para evitar esse comportamento, seria necessário usar
    // variáveis de estado, mas essa solução mantém a simplicidade didática.
})

// ============================================================
// RESUMO FINAL PARA FIXAÇÃO DE CONCEITOS:
// ============================================================
// 1. showString() NÃO limpa a tela – ela apenas exibe e mantém o último frame.
// 2. Para um alerta persistente, mostre a mensagem enquanto a condição for verdadeira.
// 3. Para realmente limpar a tela quando a condição for falsa, use
//    basic.clearScreen() no else, em vez de mostrar outra mensagem.
// 4. Esta versão optou por mostrar "OK" como alternativa, o que é didático
//    para ilustrar a substituição de mensagens, mas não remove completamente
//    os LEDs (que ficam com o último frame de "OK").
// 5. Em loops forever, lembre-se de atualizar a tela em ambos os ramos
//    para evitar exibir informações desatualizadas.

⏱️ Minuto a Minuto (50 min)

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

• TEA: Usar tabela com símbolos (😞 = bug, ❓ = causa, ✅ = solução).
• Deficiência intelectual: Trabalhar em dupla com o professor auxiliando no registro.
• Deficiência auditiva: Usar cartões coloridos para indicar a troca de papéis.
• Altas habilidades: Criar um bug proposital para a outra equipe encontrar.
• TDAH: Rodadas mais curtas (7 min) com intervalo de 1 min entre elas.

📊 Critérios Operacionais de Avaliação

• Incorporar as correções identificadas na depuração (semana 26).
• Acrescentar pelo menos um nível extra de aninhamento (ex: `SE` dentro de `SE` dentro de `REPITA`) para lidar com múltiplas condições.
• Melhorar a estrutura física (reforçar com fita, reposicionar o micro:bit) e documentar todas as mudanças no manual (versão 2.0).
• Desenvolver a iteração como prática de engenharia: produto nunca está pronto, está sempre em evolução.

📚 Conteúdo Programático

Iteração e Refinamento: Como produtos evoluem por meio de ciclos de feedback não existe versão final, existe versão atual.

Aninhamento Avançado: Estruturas condicionais aninhadas para lidar com múltiplas entradas. Exemplo: `SE sensor_luz < 50 ENTÃO (SE botão_A_pressionado ENTÃO mostrar_feliz SENÃO mostrar_triste) SENÃO parar`. Isso permite comportamentos mais inteligentes e adaptativos.

Engenharia de Software: Versionamento (1.0 → 2.0) e documentação de mudanças no manual. Cada versão tem um propósito claro.

Refinamento Físico: Reforçar a estrutura, ajustar posição do micro:bit, melhorar estabilidade o corpo do robô também evolui.

📋 Habilidades BNCC e RCP-PR

Competência 5 (BNCC), EF04MA21, RCP-PR (Autoria de sistemas simples), RCP-PR (Programação colaborativa).

🧰 Materiais (Kit Refinamento)

💻 Código com Aninhamento Duplo

// ============================================================
// VERSÃO 2.0 ANINHAMENTO DUPLO
// SE dentro de SE dentro de REPITA
// ============================================================

// ------------------------------------------------------------------
// EXPLICAÇÃO GERAL DO FUNCIONAMENTO:
// Este programa executa um loop infinito (forever) que monitora
// continuamente o nível de luz ambiente e o estado dos botões A e B
// do micro:bit. 
//
// Estrutura de decisão aninhada (duplo aninhamento):
//   NÍVEL 1: Verifica se está escuro (luz < 50).
//      NÍVEL 2: Se escuro, verifica o botão A.
//               - Se A pressionado → exibe ícone feliz.
//               - Senão → exibe a palavra "LUZ".
//      NÍVEL 2: Se claro (luz >= 50), verifica o botão B.
//               - Se B pressionado → exibe ícone triste.
//               - Senão → exibe uma matriz de LEDs apagados (tela vazia)
//                         com pausas intercaladas.
//
// Todas as ações são seguidas por uma pausa e limpeza da tela para
// evitar sobreposição e dar tempo de visualização.
// ------------------------------------------------------------------

// ===== SCRIPT PRINCIPAL: loop infinito =====
basic.forever(function () {
    // Lê o valor atual do sensor de luz (0 = escuro total, 255 = claro máximo)
    let luz = input.lightLevel()

    // ==================== ANINHAMENTO NÍVEL 1 ====================
    // Condição externa: verifica se o ambiente está escuro
    if (luz < 50) {

        // ---------- ANINHAMENTO NÍVEL 2 (dentro do 'escuro') ----------
        // Verifica se o botão A está pressionado neste momento
        if (input.buttonIsPressed(Button.A)) {
            // Caso verdadeiro: mostra um ícone feliz (sorriso)
            basic.showIcon(IconNames.Happy)
            // Aguarda 500 ms para que o ícone seja visível
            basic.pause(500)
            // Limpa a tela para a próxima iteração
            basic.clearScreen()
        } else {
            // Caso contrário (botão A NÃO pressionado):
            // Exibe a palavra "LUZ" como texto rolante
            basic.showString("LUZ")
            // Pausa 1000 ms para leitura
            basic.pause(1000)
            // Limpa a tela
            basic.clearScreen()
        }
        // Fim do aninhamento nível 2 (botão A)

    } else {
        // ---------- RAMO DO NÍVEL 1: ambiente claro (luz >= 50) ----------

        // ANINHAMENTO NÍVEL 2 (dentro do 'claro'):
        // Verifica se o botão B está pressionado
        if (input.buttonIsPressed(Button.B)) {
            // Caso verdadeiro: mostra ícone triste
            basic.showIcon(IconNames.Sad)
            basic.pause(500)
            basic.clearScreen()
        } else {
            // Caso contrário (botão B NÃO pressionado):
            // Exibe uma matriz 5x5 com todos os LEDs apagados
            // (representa uma tela vazia)
            basic.showLeds(`
        . . . . .
        . . . . .
        . . . . .
        . . . . .
        . . . . .
      `)
            // Primeira pausa de 500 ms para mostrar o "vazio"
            basic.pause(500)
            // Limpa a tela (redundante, mas garante estado limpo)
            basic.clearScreen()
            // Segunda pausa para criar um efeito de piscada
            basic.pause(500)
        }
        // Fim do aninhamento nível 2 (botão B)

    }
    // Fim do aninhamento nível 1 (luz)
})
// Fim do loop forever (reinicia automaticamente)

⏱️ Minuto a Minuto (50 min)

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

• Altas habilidades: Criar uma versão 2.5 com sensor extra (acelerômetro).
• TDAH: Checklist visual com etapas claras: corrigir → testar → documentar.
• Deficiência intelectual: Professor auxilia na escolha de um único bug para corrigir por vez.
• TEA: Fornecer um diagrama do fluxo do código com o novo aninhamento.

📊 Critérios Operacionais de Avaliação

• Planejar uma apresentação de 2 minutos por equipe, com roteiro claro: problema, solução, demonstração, código principal e um bug que enfrentaram.
• Criar um cartaz (ou slide) com elementos-chave: nome do robô, foto/desenho, trecho do código mais importante.
• Ensinar estratégias para lidar com imprevistos durante a demonstração (o "bug ao vivo" é parte do show).
• Desenvolver a comunicação oral e a confiança para falar em público.

📚 Conteúdo Programático

Comunicação Oral: Estrutura de uma apresentação introdução, desenvolvimento, conclusão, com tempo controlado. Menos é mais: 2 minutos para impactar.

Design de Pôster: Hierarquia visual título grande, imagens, código destacado, legibilidade à distância. Um cartaz bom é aquele que conta a história sem que o apresentador precise falar tudo.

Gerenciamento de Imprevistos: Respirar fundo, explicar o que aconteceu, mostrar o código, não entrar em pânico. Bug ao vivo é oportunidade de mostrar competência.

Storytelling Técnico: Contar uma história o problema, a jornada, a solução, o aprendizado.

📋 Habilidades BNCC e RCP-PR

EF04LP11, Competência 4 (BNCC), RCP-PR (Programação colaborativa), RCP-PR (Autoria de sistemas simples).

🧰 Materiais (Kit Apresentação)

📝 Roteiro de 2 minutos (Exemplo)

ROTEIRO APRESENTAÇÃO DO ROBÔ "APAGA-LUZ 3000"

[0:00-0:30] INTRODUÇÃO
"Olá! Meu nome é ______ e este é o Apaga-Luz 3000. Ele resolve um
problema que temos na escola: as luzes ficam acesas mesmo quando não tem
ninguém na sala."

[0:30-1:00] COMO FUNCIONA
"O robô usa o sensor de luz do micro:bit para medir a claridade. Se
estiver escuro, ele mostra 'LUZ' no LED para avisar que alguém precisa
apagar a luz."

[1:00-1:30] DEMONSTRAÇÃO
"Vou mostrar agora. Vejam: quando eu cubro o micro:bit (simulando
escuro), ele mostra 'LUZ'. Quando eu descubro, ele para."

[1:30-2:00] BUG E APRENDIZADO
"No começo, o robô não parava de mostrar 'LUZ' porque eu esqueci de
colocar o 'limpar tela'. Aprendi que sempre precisamos apagar a tela
depois de mostrar uma mensagem."

⏱️ Minuto a Minuto (50 min)

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

• Ansiedade social: Permitir apresentação gravada em vídeo ou apenas para o professor.
• Surdez: Usar legendas ou intérprete de Libras.
• Mutismo seletivo: Permitir que um colega ajude ou usar cartão de respostas.
• TEA: Oferecer um roteiro visual com imagens e tempo estimado.

📊 Critérios Operacionais de Avaliação

• Apresentar os projetos para uma plateia real (outra turma, professores, funcionários).
• Explicar conceitos de aninhamento, eventos concorrentes e depuração de forma acessível.
• Receber feedback por adesivos coloridos e responder perguntas.
• Desenvolver a comunicação com diferentes públicos adaptar a linguagem conforme o interlocutor.

📚 Conteúdo Programático

Comunicação com Diferentes Públicos: Adaptar a linguagem para crianças menores, usar analogias; para adultos, usar termos técnicos com explicação.

Feedback: Como receber e processar críticas construtivas sem se sentir atacado. Feedback é presente, não ofensa.

Valorização do Erro: O "bug ao vivo" é uma oportunidade de mostrar resolução de problemas.

Circuitos de Apresentação: Organização de estações para que o público circule estilo feira de ciências.

📋 Habilidades BNCC e RCP-PR

Competência 4 (BNCC), EF04LP11, RCP-PR (Programação colaborativa), RCP-PR (Autoria de sistemas simples).

🧰 Materiais (Kit Mostra)

⏱️ Minuto a Minuto (50 min)

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

• Deficiência motora: Garantir cadeira e apoio para o robô.
• TEA: Oferecer um "cantinho silencioso" para descanso entre apresentações.
• Deficiência auditiva: Garantir que os visitantes saibam que podem se aproximar e ler os lábios.
• Ansiedade: Permitir que o aluno apresente sentado ou com apoio de um colega.

📊 Critérios Operacionais de Avaliação

• Apresentar a outra metade das equipes (ou repetir para público diferente).
• Realizar autoavaliação final usando uma rubrica lúdica com carinhas de robô.
• Celebrar as conquistas com certificados personalizados e menções especiais.
• Refletir sobre o próprio aprendizado o que sei fazer agora que não sabia no começo?

📚 Conteúdo Programático

Autoavaliação: Refletir sobre o próprio aprendizado o que sei fazer agora que não sabia no começo?

Celebração: Reconhecer esforço, criatividade, persistência e trabalho em equipe.

Encerramento de Ciclo: O que vem no próximo bimestre (spoiler: sensores múltiplos e aninhamento triplo).

Cultura Maker: Celebrar o feito à mão robôs feitos de sucata, código escrito por crianças.

📋 Habilidades BNCC e RCP-PR

Competência 5 (BNCC), EF04LP11, RCP-PR (Programação colaborativa), RCP-PR (Autoria de sistemas simples).

🧰 Materiais (Kit Finale)

📝 Rubrica de Autoavaliação

⏱️ Minuto a Minuto (50 min)

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

• Mutismo seletivo: Permitir que um colega ajude ou use cartão de respostas.
• TEA: Rubrica com símbolos e cores, tempo extra para preencher.
• Ansiedade: Garantir que todos recebam certificado universalmente.
• Altas habilidades: Convidar a equipe a fazer um "pitaco" sobre o próximo bimestre.

📊 Critérios Operacionais de Avaliação