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

"Micro:bit: O Pequeno Gigante que Vai Comandar Seu Robô (e Talvez Salvar o Mundo)"

🎯 Objetivos Operacionais

• Cognitivos: Identificar os componentes do micro:bit (botões A e B, matriz de LEDs 5×5, acelerômetro, porta USB, conector de bateria, pinos de entrada/saída).
• Procedimentais: Conectar o micro:bit ao computador via cabo USB e reconhecer quando a placa estA alimentada.
• Atitudinais: Manipular o hardware com cuidado, responsabilidade e entusiasmo, tratando a placa como um "objeto de estudo valioso".

📖 Conteúdo ProgramAtico

• Componentes do micro:bit: visor de 25 LEDs (matriz 5×5), botões A e B, acelerômetro (sensor de movimento), bússola (sensor magnético), porta USB, conector para bateria, pinos de entrada/saída (0, 1, 2, 3V, GND).
• Conexão USB e fonte de energia (bateria externa).
• Cuidados com a placa: não molhar, não bater, não morder (sim, precisa ser dito).
• Identificação da luz de alimentação (LED amarelo/verde na parte traseira).

📜 Habilidades BNCC e RCP-PR

• BNCC Competência Geral 4: Comunicação com linguagens digitais familiarização com interfaces e hardware.
• EF04CI01 (BNCC Ciências): Identificar a relação entre movimento e energia discussão sobre a bateria como fonte de energia e o cabo USB como transmissor.
• RCP-PR: Uso de sensores e interfaces reconhecimento dos componentes que serão utilizados ao longo do bimestre.

🧰 Materiais

🔧 Explicação Detalhada da Montagem do Hardware

Passo 1 Identificação dos componentes (5 min):

• Matriz de LEDs: 25 LEDs organizados em 5 linhas × 5 colunas na parte frontal. "É aqui que o robô vai 'mostrar' as coisas para a gente!"
• Botão A: lado esquerdo da placa, próximo ao conector USB.
• Botão B: lado direito da placa.
• Acelerômetro: chip interno que detecta movimento não é visível a olho nu, mas fica na parte traseira da placa.
• Bússola (magnetômetro): outro chip interno que detecta campos magnéticos também na parte traseira.
• Porta USB: na parte superior, para conexão ao computador.
• Conector de bateria: na parte inferior, para conectar o suporte de pilhas.
• Pinos (edge connector): na parte inferior, com identificações (0, 1, 2, 3V, GND).

Passo 2 Conexão ao computador (5 min):

• Conectar o cabo USB à porta do micro:bit e à porta USB do computador.
• Observar se a luz de alimentação (LED amarelo/verde) acende na parte traseira da placa.
• "Se a luz acendeu, o cérebro estA ligado!"

Passo 3 Fonte de energia (bateria) (5 min):

• Mostrar o suporte de pilhas e conectar à placa (no conector inferior).
• Explicar que isso permite que o robô funcione sem o computador "É tipo tirar o cordão umbilical!"
• Cuidado: ensinar a desconectar a bateria quando não estiver usando para economizar energia.

💻 Código a ser desenvolvido

Nenhum código nesta semana foco no reconhecimento do hardware. Mas o professor pode, para motivar, mostrar um programa pré-carregado no micro:bit que exibe um coração piscante ao ser ligado.

⏱️ Detalhamento Minuto a Minuto

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

• TEA: Usar cores para destacar cada componente (adesivos coloridos nos botões A = vermelho, B = azul). Oferecer um "mapa do micro:bit" impresso com os nomes.
• TDAH: Atividade prAtica de 10 minutos com a placa; alternar com momentos de escuta e registro.
• Deficiência visual: Placa em relevo (se disponível) ou descrição detalhada; botões podem ser sentidos; usar uma placa ampliada impressa em relevo com cola quente.
• Deficiência auditiva: Instruções escritas na lousa e apoio visual com imagens ampliadas de cada componente.
• Deficiência física (motora): Auxiliar na conexão do cabo USB se necessArio; permitir que colegas ajudem.
• Altas habilidades: Desafiar a pesquisar outros componentes do micro:bit (Bluetooth, rAdio, pinos) e trazer a informação na próxima aula.

📊 Critérios Operacionais de Avaliação

"Hello, World! ou melhor, 'OlA, LEDs!' Seu Primeiro Programa (e a Primeira Vez que Você Vai Gritar de Alegria)"

🎯 Objetivos Operacionais

• Cognitivos: Compreender o conceito de sequência de comandos e como o micro:bit executa instruções em ordem.
• Procedimentais: Programar a matriz de LEDs para exibir um coração piscante usando o ambiente MakeCode.
• Atitudinais: Celebrar a primeira programação com entusiasmo, reconhecendo o valor do erro e da tentativa.

📖 Conteúdo ProgramAtico

• O que é um programa? Sequência de instruções (como uma receita de bolo).
• Ambiente MakeCode: interface, blocos, simulação e transferência para o micro:bit.
• Comandos: mostrar ícone, pausar, limpar tela.
• Estrutura de um programa: quando iniciar como ponto de partida.

📜 Habilidades BNCC e RCP-PR

• EF04MA16 (BNCC MatemAtica): Descrever a posição de objetos usando coordenadas a matriz 5×5 como sistema de coordenadas (linhas e colunas).
• EF04MA21 (BNCC MatemAtica): Compreender padrões e regularidades os algoritmos como sequências lógicas.
• BNCC Competência Geral 5: Pensamento computacional criação de algoritmos simples.
• RCP-PR: Autoria de sistemas simples primeiro programa funcional.

🧰 Materiais

🔧 Explicação Detalhada da Montagem do Hardware

Passo 1 Conectar o micro:bit ao computador (2 min):

• Conectar o cabo USB à porta do micro:bit e à porta USB do computador.
• Verificar se a luz de alimentação acendeu.

Passo 2 Abrir o MakeCode (2 min):

• Abrir o navegador e acessar makecode.microbit.org.
• Clicar em "Novo Projeto".
• Dica: Se a internet estiver instAvel, usar a versão offline do MakeCode (disponível para download).

Passo 3 Programar (10 min):

• Seguir a programação guiada abaixo.

Passo 4 Transferir o programa (5 min):

• Clicar em "Download" (botão roxo/azul).
• O arquivo .hex serA baixado.
• Arrastar o arquivo .hex para o micro:bit (que aparece como um pen drive chamado "MICROBIT").
• Aguardar a luz piscar (indica que a transferência foi concluída).
• "Pronto! O robô agora tem um coração!"

💻 Código a ser desenvolvido

// ============================================
// PROGRAMA: CORAÇÃO PISCANTE
// ============================================
// Este é o primeiro programa dos alunos!
// O micro:bit vai mostrar um coração,
// apagar e mostrar de novo.
// ============================================

// "onStart" é o "start" do programa.
// Tudo que estA aqui dentro executa quando o
// micro:bit liga (ou quando o programa é carregado).
// É como o "era uma vez" de uma história.
basic.showLeds(`
    . # # # .
    # # # # #
    # # # # #
    . # # # .
    . . # . .
`)
// "showLeds" acende os LEDs no formato de um coração.
// O robô estA mostrando que tem coração!

basic.pause(500)
// "pause(500)" espera meio segundo
// (500 milissegundos).
// É como "dar um tempinho" para a gente ver
// o que o robô fez.

basic.clearScreen()
// "clearScreen" apaga todos os LEDs.
// Tudo escuro de novo...

basic.pause(500)
// "pause(500)" espera meio segundo
// (500 milissegundos).
// É como "dar um tempinho" para a gente ver
// o que o robô fez.

basic.showLeds(`
    . # # # .
    # # # # #
    # # # # #
    . # # # .
    . . # . .
`)
// "showLeds" acende o coração de novo.

// ============================================
// EFEITO: O coração vai aparecer, sumir e aparecer de novo
// mas só uma vez! Por quê?
// Porque o programa termina após a última instrução.
// Ele só faz uma vez. É tipo um "oi" e tchau.
// ============================================

Desafio para os alunos: Mudar o ícone para uma carinha feliz 😊 ou uma estrela ⭐. "Quem consegue fazer o robô mostrar uma estrela em vez de um coração?"

⏱️ Detalhamento Minuto a Minuto

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

• TEA: Usar blocos de cores contrastantes. Oferecer um roteiro visual com os passos (impresso). Trabalhar em duplas com um colega de apoio.
• TDAH: Dividir em micro-desafios: "Primeiro, encontre o bloco 'mostrar ícone'." "Agora, encontre o 'pausar'." Recompensas imediatas (carimbos, adesivos).
• Deficiência visual: Ampliar a tela (Ctrl + +). Usar comandos de voz (leitor de tela). Descrever o que estA acontecendo na simulação. Permitir que toquem no micro:bit para sentir os LEDs acesos.
• Deficiência auditiva: Instruções escritas passo a passo. Usar a simulação visual do MakeCode que mostra os LEDs acendendo.
• Altas habilidades: Desafiar a criar um ícone personalizado usando a grade 5×5 (botão "Desenhar" no MakeCode). Ou fazer o coração piscar em ritmos diferentes.

📊 Critérios Operacionais de Avaliação

"VariAveis: O Robô Aprende a Contar e Nunca Mais Esquece! (Diferente de Você com o Nome dos Alunos)"

🎯 Objetivos Operacionais

• Cognitivos: Compreender o conceito de variAvel como um "espaço de memória" que armazena um valor que pode mudar.
• Procedimentais: Criar um programa com variAvel para contar quantas vezes o botão A foi pressionado e zerar com o botão B.
• Atitudinais: Desenvolver organização e lógica na programação, entendendo que variAveis ajudam a "lembrar" informações.

📖 Conteúdo ProgramAtico

• O que é uma variAvel? (caixa com nome e valor como uma gaveta etiquetada).
• Criar variAveis no MakeCode (bloco variAvel).
• Incrementar (aumentar) uma variAvel: contador = contador + 1.
• Exibir o valor da variAvel na matriz de LEDs (bloco mostrar número).
• Eventos: botão A (somar), botão B (zerar).

📜 Habilidades BNCC e RCP-PR

• EF04MA01 (BNCC MatemAtica): Ler, escrever e ordenar números naturais até a ordem de dezenas de milhar os contadores como aplicação prAtica.
• BNCC Competência Geral 5: Pensamento computacional uso de variAveis para armazenar e manipular dados.
• RCP-PR: Programação com variAveis primeiro contato com memória programAvel.

🧰 Materiais

🔧 Explicação Detalhada da Montagem do Hardware

Passo 1 Conectar o micro:bit ao computador (2 min):

• Conectar o cabo USB.

Passo 2 Abrir o MakeCode (2 min):

• Criar um novo projeto.

Passo 3 Programar (10 min):

• Seguir a programação guiada abaixo.

Passo 4 Transferir (3 min):

• Baixar o arquivo .hex e arrastar para o micro:bit.

💻 Código a ser desenvolvido

// ============================================
    // PROGRAMA: CONTADOR DE CLIQUES
    // ============================================
    // O botão A aumenta o contador.
    // O botão B zera o contador.
    // O robô mostra o número atual na matriz de LEDs.
    // ============================================

    let contador = 0
    // "let contador = 0" cria uma "caixinha" chamada "contador"
    // e coloca o número 0 dentro.
    // É como se o robô tivesse um caderninho em branco.

    // ============================================
    // EVENTO: BOTÃO A PRESSIONADO
    // ============================================
    input.onButtonPressed(Button.A, function () {
        // "onButtonPressed" é um evento!
        // Quando o botão A for apertado,
        // o micro:bit faz o que estA dentro.
        // O robô estA sempre de olho no botão A.
        contador = contador + 1
        // "contador = contador + 1" pega o valor atual
        // (ex: 5), soma 1 (vira 6) e guarda de novo.
        // É como dar um "risquinho" no caderno a cada aperto.
        basic.showNumber(contador)
        // "showNumber" acende os LEDs mostrando o número atual.
        basic.pause(100)
        // "pause 100 ms" espera 0,1 segundo para a gente ver
        // o número antes de apagar.
        basic.clearScreen()
        // "clearScreen" apaga os LEDs para não ficar
        // o número grudado.
    })

    // ============================================
    // EVENTO: BOTÃO B PRESSIONADO
    // ============================================
    input.onButtonPressed(Button.B, function () {
        contador = 0
        // Zera o contador.
        // Recomeça a contagem! Rasga a pAgina e começa de novo!
        basic.showNumber(0)
    })

    // ============================================
    // ANALOGIA: É como se o robô tivesse um caderninho
    // onde ele anota quantas vezes você apertou o botão A.
    // Quando aperta B, ele rasga a pAgina e começa de novo!
    // ============================================

Desafio para os alunos: Fazer o botão A + B juntos (pressionados simultaneamente) mostrarem a mensagem "FIM" ou um ícone especial.

⏱️ Detalhamento Minuto a Minuto

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

• TEA: Usar cores para o botão A (vermelho) e B (azul). Oferecer cartões com os blocos para manipulação física. Trabalhar em duplas.
• TDAH: Desafios de 5 minutos com recompensa imediata (carimbo). Alternar entre programação e teste.
• Deficiência visual: Aumentar o contraste da tela; descrever os números mostrados; usar feedback sonoro (se disponível).
• Deficiência auditiva: Instruções escritas passo a passo. Usar a simulação visual.
• Altas habilidades: Desafiar a criar um contador que conta de 2 em 2, ou que mostra a tabuada do número atual, ou que faz uma "fogos de artifício" quando chega a 10.

📊 Critérios Operacionais de Avaliação

"Eventos: O Robô Reage como um Mestre de Cerimônias (ou um Gato que Atende pelo Nome Só Quando Quer)"

🎯 Objetivos Operacionais

• Cognitivos: Compreender o conceito de evento como uma ação que dispara uma resposta (estímulo → reação).
• Procedimentais: Programar respostas diferentes para os botões A, B e A+B (pressionados simultaneamente).
• Atitudinais: Perceber que o robô "espera" por eventos e reage a eles e que isso é a base da interatividade.

📖 Conteúdo ProgramAtico

• O que é um evento? (Exemplo: "Quando chove, eu abro o guarda-chuva" a chuva é o evento, abrir o guarda-chuva é a resposta).
• Eventos no micro:bit: quando botão A for pressionado, quando botão B for pressionado, quando botão A+B for pressionado, quando chacoalhar.
• Blocos de evento no MakeCode.
• Diferença entre evento e sequência (evento = "espera" indefinidamente; sequência = executa uma vez).

📜 Habilidades BNCC e RCP-PR

• EF04MA21 (BNCC MatemAtica): Compreender padrões e regularidades os algoritmos como sequências lógicas de causa e efeito.
• BNCC Competência Geral 4: Comunicação com linguagens digitais interação com a mAquina via botões.
• EF04LP11 (BNCC Língua Portuguesa): Planejar e produzir textos instrucionais criação de "manuais do robô" com os eventos mapeados.
• RCP-PR: Eventos e interatividade primeiro contato com programação orientada a eventos.

🧰 Materiais

🔧 Explicação Detalhada da Montagem do Hardware

Passo 1 Conectar o micro:bit ao computador (2 min).

Passo 2 Abrir o MakeCode e criar novo projeto (2 min).

Passo 3 Programar (10 min).

Passo 4 Transferir e testar (5 min).

💻 Código a ser desenvolvido

// ============================================
    // PROGRAMA: O MESTRE DE CERIMÔNIAS
    // ============================================
    // Cada botão faz o robô mostrar uma emoção diferente.
    // A = feliz, B = triste, A+B = surpreso.
    // ============================================

    // ============================================
    // EVENTO: BOTÃO A
    // ============================================
    input.onButtonPressed(Button.A, function () {
        // Cada "onButtonPressed" é um evento.
        // O micro:bit fica "escutando" o tempo todo,
        // como um porteiro esperando a campainha tocar.
        basic.showIcon(IconNames.Happy)
        // "showIcon Happy" exibe uma carinha sorridente 😊.
    })

    // ============================================
    // EVENTO: BOTÃO B
    // ============================================
    input.onButtonPressed(Button.B, function () {
        basic.showIcon(IconNames.Sad)
        // Carinha triste 🙁.
    })

    // ============================================
    // EVENTO: BOTÃO A + B (SIMULTÂNEOS)
    // ============================================
    input.onButtonPressed(Button.AB, function () {
        basic.showIcon(IconNames.Surprised)
        // Carinha de surpresa 😮.
    })

    // ============================================
    // JOGO UNPLUGGED (antes da programação - 10 min):
    // Distribuir cartões: "QUANDO APERTO A", "QUANDO APERTO B",
    // "FAÇA UMA DANÇA", "DÊ UM PULO", "MOSTRE UM SORRISO".
    // Um aluno é o "programador" e dA as ordens.
    // Os outros são os "robôs" e reagem aos eventos.
    // Isso ajuda a internalizar o conceito de evento-resposta.
    // ============================================

⏱️ Detalhamento Minuto a Minuto

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

• TEA: Usar cartões com cores e símbolos para cada evento. Criar um "mapa de eventos" com a sequência: evento → reação.
• TDAH: Alternar entre atividades computacionais e não computacionais (jogo unplugged → programação → teste).
• Deficiência visual: Descrever os ícones (feliz, triste, surpreso); usar botões tAteis; feedback sonoro se possível.
• Deficiência auditiva: Instruções escritas; usar a simulação visual do MakeCode.
• Altas habilidades: Criar um "menu" com mais de 5 eventos diferentes (incluindo gestos do acelerômetro) e documentar como um "manual do usuArio".

📊 Critérios Operacionais de Avaliação

"Acelerômetro: O Robô Sente o Chacoalhão e Não É Ressaca!"

🎯 Objetivos Operacionais

• Cognitivos: Compreender o funcionamento do acelerômetro (sensor de movimento) e sua aplicação em dispositivos do dia a dia (celulares, videogames).
• Procedimentais: Programar respostas a gestos como "chacoalhar", "inclinar para esquerda/direita" e "queda livre".
• Atitudinais: Explorar a relação entre movimento físico e resposta digital, percebendo que o robô "sente" o mundo ao seu redor.

📖 Conteúdo ProgramAtico

• O que é um acelerômetro? Sensor que detecta aceleração e inclinação em 3 eixos (X, Y, Z).
• Gestos reconhecidos pelo micro:bit: chacoalhar (shake), inclinar para esquerda, inclinar para direita, inclinar para frente, inclinar para trAs, queda livre (freefall).
• Blocos de gestos no MakeCode.
• Aplicações prAticas: controles de jogos, detecção de quedas, bússola digital.

📜 Habilidades BNCC e RCP-PR

• EF04CI01 (BNCC Ciências): Identificar a relação entre movimento e energia o acelerômetro convertendo movimento em sinal elétrico.
• EF04GE09 (BNCC Geografia): Utilizar direções cardeais na localização a bússola do micro:bit como ferramenta de orientação.
• BNCC Competência Geral 5: Pensamento computacional programação de respostas a estímulos físicos.
• RCP-PR: Uso de sensores e interfaces explorando o acelerômetro.

🧰 Materiais

🔧 Explicação Detalhada da Montagem do Hardware

Passo 1 Para testar o acelerômetro, o micro:bit precisa estar solto (não preso ao computador).

Passo 2 Conectar a bateria externa (suporte de pilhas) para mobilidade (2 min):

• Encaixar o conector do suporte de pilhas na parte inferior do micro:bit.
• "Agora o robô estA livre! Sem cabos!"

Passo 3 Programar e transferir o código (10 min):

• Programar no MakeCode (ver abaixo).
• Baixar o arquivo .hex e transferir para o micro:bit (via USB).
• Desconectar o USB e deixar apenas a bateria.

Passo 4 Testar os gestos (5 min):

• Chacoalhar, inclinar, etc. Ver as reações.

💻 Código a ser desenvolvido

// ============================================
    // PROGRAMA: DETETIVE DE MOVIMENTO
    // ============================================
    // O robô reage a diferentes gestos:
    // chacoalhar, inclinar para esquerda/direita,
    // inclinar para frente/trAs e queda livre.
    // ============================================

    // ============================================
    // EVENTO: CHACOALHAR
    // ============================================
    input.onGesture(Gesture.Shake, function () {
        // Detecta quando o micro:bit é sacudido.
        // É como se o robô dissesse "Ei, não me sacode!"
        basic.showIcon(IconNames.No)
        // Mostra um "X" (não gostou do chacoalhão).
        basic.pause(500)
        basic.clearScreen()
    })

    // ============================================
    // EVENTO: INCLINAR PARA ESQUERDA
    // ============================================
    input.onGesture(Gesture.TiltLeft, function () {
        // Detecta inclinação para o lado esquerdo.
        // O robô "olha" para a esquerda.
        basic.showArrow(ArrowNames.West)
        // Mostra uma seta para a esquerda.
    })

    // ============================================
    // EVENTO: INCLINAR PARA DIREITA
    // ============================================
    input.onGesture(Gesture.TiltRight, function () {
        basic.showArrow(ArrowNames.East)
        // Mostra uma seta para a direita.
    })

    // ============================================
    // EVENTO: INCLINAR PARA FRENTE
    // ============================================
    input.onGesture(Gesture.LogoUp, function () {
        basic.showArrow(ArrowNames.North)
        // Mostra uma seta para cima.
    })

    // ============================================
    // EVENTO: INCLINAR PARA TRAS
    // ============================================
    input.onGesture(Gesture.LogoDown, function () {
        basic.showArrow(ArrowNames.South)
        // Mostra uma seta para baixo.
    })

    // ============================================
    // EVENTO: QUEDA LIVRE (FREEFALL)
    // ============================================
    input.onGesture(Gesture.FreeFall, function () {
        // Detecta quando o micro:bit estA caindo.
        // CUIDADO: não deixe cair de verdade!
        // O robô sente o "free fall"!
        basic.showString("!")
    })

    // ============================================
    // ANALOGIA: É como se o robô tivesse um liquidificador
    // dentro de si ele sente quando você o balança!
    // E também tem um nível de bolha
    // ele sabe quando estA inclinado.
    // ============================================

Desafio para os alunos: Usar a bússola do micro:bit (bloco bússola no MakeCode) para mostrar a direção norte. "Quem consegue fazer o robô apontar para o norte?"

⏱️ Detalhamento Minuto a Minuto

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

• TEA: Oferecer um "mapa de gestos" com figuras e cores (ex: seta vermelha para esquerda, seta azul para direita).
• TDAH: Atividades curtas com movimento físico (chacoalhar, inclinar) ótimo para gastar energia!
• Deficiência visual: Descrever os movimentos e usar feedback sonoro (se possível, programar bips para cada gesto).
• Deficiência física (motora): Adaptar para usar botões em vez de movimento; ou usar uma rampa para inclinar o micro:bit. Permitir que colegas auxiliem nos movimentos.
• Altas habilidades: Desafiar a usar o acelerômetro para controlar um jogo (como um volante inclinar para esquerda/direita controla um carrinho na tela). Ou criar um "detector de terremoto" que pisca quando chacoalha forte.

📊 Critérios Operacionais de Avaliação

"Loop: O Robô DJ que Repete a Música até Você Cansar ou até a Bateria Acabar"

🎯 Objetivos Operacionais

• Cognitivos: Compreender o conceito de repetição (loop) e sua utilidade para evitar escrever o mesmo código vArias vezes.
• Procedimentais: Criar animações com loops (repetir comandos um número definido de vezes ou para sempre).
• Atitudinais: Perceber que a repetição economiza linhas de código e permite criar efeitos visuais interessantes.

📖 Conteúdo ProgramAtico

• O que é um loop? Repetir um bloco de comandos vArias vezes.
• Bloco repetir X vezes (loop contado) e enquanto verdadeiro (loop infinito).
• Animações com loops: coração batendo, estrela piscando, letras piscando.
• Diferença entre loop finito e infinito.

📜 Habilidades BNCC e RCP-PR

• EF04MA21 (BNCC MatemAtica): Compreender padrões e regularidades os loops como repetição de padrões.
• BNCC Competência Geral 5: Pensamento computacional estruturas de repetição.
• RCP-PR: Estruturas de repetição loops como ferramenta fundamental.

🧰 Materiais

🔧 Explicação Detalhada da Montagem do Hardware

Passo 1 Conectar o micro:bit ao computador (2 min).

Passo 2 Abrir o MakeCode (2 min).

Passo 3 Programar (10 min).

Passo 4 Transferir e ver a animação (3 min).

💻 Código 1 a ser desenvolvido

// ============================================
// PROGRAMA 1: CORAÇÃO BATENDO (LOOP FINITO)
// ============================================
// O coração bate 10 vezes e para.
// ============================================

// "onStart" é executado quando o micro:bit liga
basic.showLeds(`
    . # # # .
    # # # # #
    # # # # #
    . # # # .
    . . # . .
`)
// Mostra o coração uma vez antes do loop

for (let i = 0; i < 10; i++) {
    // "for" executa o bloco dentro 10 vezes e para.
    // É como bater palmas 10 vezes:
    // uma, duas, três... até dez.
    
    basic.clearScreen()
    // Limpa a tela (apaga o coração)
    
    basic.pause(200)
    // Espera 0,2 segundos com tela apagada
    
    basic.showLeds(`
        . # # # .
        # # # # #
        # # # # #
        . # # # .
        . . # . .
    `)
    // Mostra o coração de novo
    
    basic.pause(200)
    // Espera mais 0,2 segundos com coração aceso
}
// Fim do loop após 10 repetições, o programa termina.

💻 Código 2 a ser desenvolvido

// ============================================
// PROGRAMA 2: LOOP INFINITO
// ============================================
// O coração bate para sempre (até a bateria acabar).
// ============================================

basic.forever(function() {
    // "forever" repete para sempre.
    // O robô nunca para!
    // É igual um DJ que não quer sair do palco.
    
    basic.showLeds(`
        . # # # .
        # # # # #
        # # # # #
        . # # # .
        . . # . .
    `)
    // Mostra o coração
    
    basic.pause(200)
    // Espera 0,2 segundos
    
    basic.clearScreen()
    // Apaga os LEDs
    
    basic.pause(200)
    // Espera mais 0,2 segundos
})
// Este loop nunca termina!

Desafio para os alunos: Criar uma animação própria com loop por exemplo, um rostinho que pisca, uma estrela que gira, ou um "SOS" em código Morse.

⏱️ Detalhamento Minuto a Minuto

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

• TEA: Usar um cronômetro visual para mostrar as repetições. Oferecer um roteiro visual com os passos.
• TDAH: Dividir em micro-desafios: "Faça 5 repetições, depois 10, depois infinito." Recompensas a cada etapa.
• Deficiência visual: Descrever a animação; usar feedback sonoro (bips a cada repetição).
• Deficiência auditiva: Instruções escritas; usar a simulação visual.
• Altas habilidades: Desafiar a criar um loop que conta até 10 e mostra os números, ou um loop que faz um padrão geométrico na matriz.

📊 Critérios Operacionais de Avaliação

"Dr. Loop e seu Assistente SE-hA-caso: Aninhando Decisões (ou: Como Fazer o Robô Pensar Enquanto Repete)"

🎯 Objetivos Operacionais

• Cognitivos: Compreender o aninhamento de estruturas (colocar um SE dentro de um REPITA).
• Procedimentais: Criar um programa que repete uma ação e, dentro da repetição, toma uma decisão baseada em uma condição.
• Atitudinais: Desenvolver pensamento lógico e sistêmico, entendendo que estruturas podem ser combinadas.

📖 Conteúdo ProgramAtico

• O que é aninhamento? Colocar uma estrutura dentro de outra (como bonecas russas, mas com menos bugs).
• Exemplo: REPITA 10 vezes { SE botão A pressionado { faça algo } }.
• Blocos de aninhamento no MakeCode.
• Combinação de loop + condicional para criar comportamentos complexos.

📜 Habilidades BNCC e RCP-PR

• EF04MA21 (BNCC MatemAtica): Compreender padrões e regularidades combinação de estruturas.
• BNCC Competência Geral 5: Pensamento computacional avançado aninhamento de estruturas.
• RCP-PR: Condicionais aninhadas primeiro contato com estruturas combinadas.

🧰 Materiais

🔧 Explicação Detalhada da Montagem do Hardware

Passo 1 Conectar o micro:bit ao computador (2 min).

Passo 2 Abrir o MakeCode (2 min).

Passo 3 Programar (10 min).

Passo 4 Transferir e testar (5 min).

💻 Código a ser desenvolvido

// ============================================
// PROGRAMA: O ROBÔ QUE REPETE E DECIDE
// ============================================
// O robô conta de 0 a 20 e, a cada número,
// verifica se o botão A foi pressionado.
// Se foi, mostra feliz. Se não, mostra triste.
// ============================================

let contador = 0
// VariAvel para contar as repetições.

// ============================================
// PROGRAMA PRINCIPAL
// ============================================

// "onStart" é executado quando o micro:bit liga
basic.showLeds(`
    . . . . .
    . . . . .
    . . . . .
    . . . . .
    . . . . .
`)
// Pequena pausa para preparar o programa
basic.pause(100)

for (let i = 0; i < 20; i++) {
    // "for" faz um loop de 20 repetições.
    // O robô vai fazer isso 20 vezes seguidas.

    basic.showNumber(contador)
    // Mostra o número atual (0, 1, 2, ...).

    // ============================================
    // ESTRUTURA ANINHADA: SE dentro do REPITA
    // ============================================
    if (input.buttonIsPressed(Button.A)) {
        // "se botão A for pressionado então"
        // A cada repetição, o robô pergunta:
        // "O botão A foi apertado?"
        basic.showIcon(IconNames.Happy)
        // Se foi apertado → mostra feliz.
        basic.pause(500)
    } else {
        // Se não foi apertado → mostra triste.
        basic.showIcon(IconNames.Sad)
        basic.pause(500)
    }

    contador = contador + 1
    // Aumenta o contador a cada repetição.
}
// Fim do loop de 20 repetições.

// Mostra uma mensagem final quando o programa termina
basic.showString("FIM")

Jogo unplugged (antes da programação 10 min):

• Um aluno é o "loop" (repete a ação). Outro é o "SE" (toma a decisão).
• Exemplo: REPITA 5 vezes { SE a luz estiver acesa { dance } SENÃO { fique parado } }.
• Os alunos executam o algoritmo fisicamente.

⏱️ Detalhamento Minuto a Minuto

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

• TEA: Usar cores para cada nível de aninhamento (ex: loop = azul, SE = vermelho). Oferecer um "mapa de aninhamento" com cores.
• TDAH: Dividir em micro-desafios de 5 minutos. Recompensas a cada etapa.
• Deficiência visual: Descrever a estrutura; usar objetos tAteis para representar o aninhamento (caixas dentro de caixas).
• Deficiência auditiva: Instruções escritas passo a passo.
• Altas habilidades: Desafiar a criar um aninhamento com 3 níveis (loop dentro de loop com SE). Ou criar um programa que faz um "jogo de adivinhação" com loop e condicionais.

📊 Critérios Operacionais de Avaliação

"SemAforo Inteligente: O Robô que Controla o Trânsito da Sala (e Talvez Impeça o Caos no Recreio)"

🎯 Objetivos Operacionais

• Cognitivos: Integrar conceitos de eventos, loops e condicionais em um projeto único e funcional.
• Procedimentais: Construir um semAforo que alterna entre verde, amarelo e vermelho com temporizador, com um modo de emergência ativado por botão.
• Atitudinais: Trabalhar em equipe, planejar antes de programar e apresentar o projeto para a turma.

📖 Conteúdo ProgramAtico

• Integração de eventos, loops e condicionais.
• Temporização com pausas (diferentes durações para cada cor).
• Projeto colaborativo: planejamento, execução, teste e apresentação.
• VariAveis para controle de estado (cor atual).

📜 Habilidades BNCC e RCP-PR

• EF04MA21 (BNCC MatemAtica): Compreender padrões e regularidades a sequência do semAforo como padrão.
• EF04CI01 (BNCC Ciências): Relação entre movimento e energia LEDs como conversão de energia elétrica em luz.
• EF04LP11 (BNCC Língua Portuguesa): Planejar e produzir textos instrucionais criação de um "manual do semAforo".
• BNCC Competência Geral 5: Pensamento computacional projeto integrador.
• RCP-PR: Autoria de sistemas simples construção de um sistema funcional completo.

🧰 Materiais

🔧 Explicação Detalhada da Montagem do Hardware

Passo 1 Conectar o micro:bit ao computador (2 min).

Passo 2 Abrir o MakeCode (2 min).

Passo 3 Programar (15 min).

Passo 4 Transferir e testar (5 min).

Passo 5 (Opcional) Embelezamento: colocar o micro:bit dentro de uma caixa com papel colorido simulando um semAforo (5 min).

💻 Código a ser desenvolvido

// ============================================
// PROGRAMA: SEMAFORO INTELIGENTE
// ============================================
// Um semAforo que alterna entre verde, amarelo e vermelho.
// Botão A ativa o modo de emergência (pisca amarelo).
// Botão B ativa o modo pedestre (mostra "PARE" e "ANDEM").
// ============================================

let cor = 0
// "cor" guarda a cor atual (0=verde, 1=amarelo, 2=vermelho).
// É o "estado" do semAforo.

// ============================================
// LOOP PRINCIPAL (INFINITO)
// ============================================
basic.forever(function () {
    // Loop infinito o semAforo nunca para de funcionar.
    if (cor == 0) {
        // Se for verde (cor == 0):
        basic.showArrow(ArrowNames.North)
        // Mostra seta para cima (verde).
        basic.pause(3000)
        // Espera 3 segundos (verde).
        cor = 1
        // Muda para amarelo.
    } else if (cor == 1) {
        // Se for amarelo (cor == 1):
        basic.showIcon(IconNames.Square)
        // Mostra quadrado (amarelo) - ícone disponível no MakeCode.
        basic.pause(1000)
        // Espera 1 segundo (amarelo).
        cor = 2
        // Muda para vermelho.
    } else {
        // Se for vermelho (cor == 2):
        basic.showIcon(IconNames.No)
        // Mostra "X" (vermelho).
        basic.pause(3000)
        // Espera 3 segundos (vermelho).
        cor = 0
        // Volta para verde.
    }
})

// ============================================
// EVENTO: MODO DE EMERGÊNCIA (BOTÃO A)
// ============================================
input.onButtonPressed(Button.A, function () {
    // Modo de emergência: pisca quadrado (amarelo) 5 vezes.
    for (let i = 0; i < 5; i++) {
        basic.showIcon(IconNames.Square)
        // Mostra quadrado (amarelo).
        basic.pause(200)
        basic.clearScreen()
        basic.pause(200)
    }
    cor = 0
    // Volta ao normal (verde).
})

// ============================================
// EVENTO: MODO PEDESTRE (BOTÃO B) - DESAFIO
// ============================================
input.onButtonPressed(Button.B, function () {
    // Modo pedestre: mostra "PARE" para carros e "ANDEM" para pedestres
    basic.showString("PARE")  // Mostra PARE para os carros
    basic.pause(1000)
    basic.showString("ANDEM") // Mostra ANDEM para os pedestres
    basic.pause(1000)
    cor = 0  // Volta ao normal (verde) após o modo pedestre
})

// ============================================
// INICIALIZAÇÃO
// ============================================
basic.showString("TRAFEGO")  // Mensagem de inicialização
basic.pause(500)
cor = 0  // Começa com o semAforo verde

⏱️ Detalhamento Minuto a Minuto

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

• TEA: Usar cores fortes e contrastantes; oferecer um roteiro visual do projeto com as etapas.
• TDAH: Dividir em tarefas menores: "Primeiro, façam o verde. Depois, o amarelo. Depois, o vermelho." Recompensas a cada etapa.
• Deficiência visual: Descrever as cores; usar feedback sonoro (bips diferentes para cada cor).
• Deficiência auditiva: Instruções escritas; usar a simulação visual.
• Altas habilidades: Desafiar a adicionar um sensor de luminosidade para ajustar o brilho do semAforo, ou um modo "noturno" com pisca-pisca.

📊 Critérios Operacionais de Avaliação

"Caça ao Bug: O Robô Quase Explodiu de Tanta Repetição (e a Culpa é Sua mas a Gente Resolve Junto)"

🎯 Objetivos Operacionais

• Cognitivos: Compreender o conceito de bug (erro no programa) e depuração (processo de encontrar e corrigir erros).
• Procedimentais: Identificar e corrigir erros em programas prontos (com bugs propositais) e criar próprios bugs para os colegas resolverem.
• Atitudinais: Desenvolver colaboração, paciência e resiliência na resolução de problemas, entendendo que errar é parte do processo.

📖 Conteúdo ProgramAtico

• O que é um bug? (Erro no programa pode ser de sintaxe, lógica ou execução).
• O que é depuração? Encontrar e corrigir bugs.
• Estratégias de depuração: ler o código com calma, testar partes isoladamente, usar a simulação, pedir ajuda a um colega.
• A importância de testar e revisar o código.

📜 Habilidades BNCC e RCP-PR

• EF04MA01 (BNCC MatemAtica): Ler, escrever e ordenar números lógica e sequências.
• EF04LP11 (BNCC Língua Portuguesa): Planejar e produzir textos instrucionais criação de "relatórios de depuração".
• BNCC Competência Geral 5: Pensamento computacional depuração como habilidade fundamental.
• RCP-PR: Depuração colaborativa trabalho em equipe para encontrar e corrigir erros.

🧰 Materiais

🔧 Explicação Detalhada da Montagem do Hardware

Passo 1 Conectar o micro:bit ao computador (2 min).

Passo 2 Abrir o MakeCode (2 min).

Passo 3 Carregar o programa com bug (fornecido pelo professor) (2 min).

Passo 4 Identificar e corrigir o bug (5 min).

Passo 5 Testar a correção (3 min).

💻 Código 1 a ser desenvolvido (Bugs para correção)

// ============================================
    // BUG 1: CONTADOR QUEBRADO
    // ============================================
    // O contador diminui em vez de aumentar quando aperta A.
    // ============================================

    let contador = 0

    input.onButtonPressed(Button.A, function () {
        basic.showNumber(contador)
        contador = contador - 1 // BUG: deveria ser +1
        // ☠️ BUG IDENTIFICADO: O contador estA diminuindo!
        // ✅ CORREÇÃO: trocar -1 por +1
    })

    input.onButtonPressed(Button.B, function () {
        contador = 0
        basic.showNumber(0)
    })

    // ============================================
    // BUG: O contador diminui em vez de aumentar.
    // CORREÇÃO: Trocar "contador = contador - 1"
    // por "contador = contador + 1".
    // ============================================

💻 Código 2 a ser desenvolvido (Bugs para correção)

// ============================================
// LOOP INFINITO COM BUG DIDATICO
// ============================================
// Este projeto demonstra um erro onde o loop infinito
// executa tão rApido que o micro:bit parece travado.
// ============================================

// ============================================
// BUG 2: LOOP INFINITO INDESEJADO
// ============================================
// O robô fica travado mostrando o ícone.
// ============================================

basic.forever(function () {
    // MOSTRA ÍCONE FELIZ
    basic.showIcon(IconNames.Happy)
    
    basic.clearScreen()
    // "clearScreen" apaga todos os LEDs.
    // Tudo escuro de novo...

    // ☠️ BUG IDENTIFICADO: Faltou o "pausar"!
    // O loop executa tão rApido que parece travado.
    // ✅ CORREÇÃO: descomentar a linha abaixo
    // basic.pause(500)
})

// ============================================
// VERSÃO CORRIGIDA (COMENTADA PARA COMPARAÇÃO)
// ============================================
/*
basic.forever(function () {
    basic.showIcon(IconNames.Happy)
    basic.pause(500) // ← CORREÇÃO: adicionado pause
})
*/

// ============================================
// DOCUMENTAÇÃO DO BUG E CORREÇÃO
// ============================================
// BUG: O loop infinito executa sem pausa, fazendo o micro:bit
// parecer travado ou congelado.
//
// Comportamento esperado:
// O ícone feliz deve ser exibido por 500ms e depois atualizado.
//
// Comportamento atual com o bug:
// O micro:bit fica "travado" mostrando o ícone feliz,
// mas na verdade estA executando milhões de vezes por segundo.
// Como a tela não tem tempo de atualizar, parece congelado.
//
// CORREÇÃO: Adicionar "basic.pause(500)" dentro do loop
// para dar tempo suficiente para a exibição do ícone.
//
// ============================================
// POR QUE ISSO ACONTECE?
// ============================================
// O micro:bit executa o loop basic.forever() aproximadamente
// 60 vezes por segundo (60Hz). Sem um pause(), a função
// showIcon() é chamada repetidamente, e a tela não consegue
// atualizar corretamente entre as chamadas.
//
// Com o pause(500), o loop executa apenas 2 vezes por segundo
// (500ms = 0,5 segundos), dando tempo para a tela mostrar
// o ícone corretamente.
//
// ============================================
// INSTRUÇÕES PARA CORREÇÃO:
// 1. Localize a linha: basic.showIcon(IconNames.Happy)
// 2. Adicione abaixo: basic.pause(500)
// 3. Teste novamente no micro:bit
// 4. O ícone feliz agora deve piscar a cada 0,5 segundos
// ============================================

💻 Código 3 a ser desenvolvido (Bugs para correção)

// ============================================
// SEMÁFORO COM BUG DIDÁTICO
// ============================================
// Este projeto demonstra um erro de lógica onde o semáforo
// pula do verde direto para o vermelho, sem passar pelo amarelo.
// ============================================

let cor = 0

// ============================================
// BUG 3: SEMÁFORO PRESO NO VERMELHO
// ============================================
// O semáforo pula do verde direto para o vermelho.
// ============================================

basic.forever(function () {
    if (cor == 0) {
        // VERDE - Sinalize que pode passar
        // Se for verde (cor == 0):
        basic.showArrow(ArrowNames.North)
        // Mostra seta para cima (verde).
        basic.pause(3000)
        // Espera 3 segundos (verde).
        cor = 2 // BUG: deveria ser 1 (amarelo)
        // ☠️ BUG IDENTIFICADO: Pulou o amarelo!
        // ✅ CORREÇÃO: trocar "cor = 2" por "cor = 1"
    } else if (cor == 1) {
        // AMARELO - Atenção, prepare-se para parar
        // Se for amarelo (cor == 1):
        basic.showIcon(IconNames.Square)
        // Mostra quadrado (amarelo) - ícone disponível no MakeCode.
        basic.pause(2000)
        // Espera 2 segundo (amarelo).
        cor = 2
    } else if (cor == 2) {
        // VERMELHO - Pare!
        // Se for vermelho (cor == 2):
        basic.showIcon(IconNames.No)
        // Mostra "X" (vermelho).
        basic.pause(3000)
        // Espera 3 segundos (vermelho).
        cor = 0
    }
})

// ============================================
// DOCUMENTAÇÃO DO BUG E CORREÇÃO
// ============================================
// BUG: O semáforo pula do verde direto para o vermelho.
// 
// Comportamento esperado:
// Verde (3s) → Amarelo (2s) → Vermelho (3s) → Verde (3s) ...
//
// Comportamento atual com o bug:
// Verde (3s) → Vermelho (3s) → Verde (3s) → Vermelho (3s) ...
// (O amarelo nunca é exibido)
//
// CORREÇÃO: Trocar "cor = 2" por "cor = 1" na linha 22.
// Após a correção, o fluxo será:
// Verde → Amarelo → Vermelho → Verde ...
//
// ============================================
// INSTRUÇÕES PARA CORREÇÃO:
// 1. Localize a linha: cor = 2 // BUG: deveria ser 1 (amarelo)
// 2. Substitua por: cor = 1
// 3. Teste novamente no micro:bit
// ============================================

⏱️ Detalhamento Minuto a Minuto

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

• TEA: Usar um "mapa de depuração" com passos claros e visuais (1. Leia o código. 2. Teste. 3. Encontre o erro. 4. Corrija. 5. Teste de novo).
• TDAH: Dividir em micro-desafios de 5 minutos com recompensa (carimbo, adesivo).
• Deficiência visual: Descrever os bugs verbalmente; usar leitor de tela; aumentar o contraste.
• Deficiência auditiva: Instruções escritas passo a passo.
• Altas habilidades: Desafiar a encontrar bugs em programas mais complexos (com aninhamento) ou a criar um "manual de depuração" para a turma.

📊 Critérios Operacionais de Avaliação