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

Programa "O Robô Cardápio"

// ============================================================
// PROGRAMA: O ROBÔ CARDÁPIO
// ============================================================
// OBJETIVO: O robô mostra um ícone diferente para cada opção (1, 2, 3).
// AO APERTAR O BOTÃO A: avança para a próxima opção.
// ============================================================

// ============================================================
// COMENTÁRIO DIDÁTICO SOBRE O FLUXO GERAL DO PROGRAMA:
// ============================================================
// 1. Quando o Micro:bit liga, a variável "opcao" começa com o valor 0.
// 2. A tela fica limpa (pois nada foi programado para o início ainda).
// 3. Cada vez que o usuário aperta o botão A, o código soma +1 à "opcao".
// 4. O programa verifica o novo valor da "opcao" e desenha o ícone correspondente:
//    - Se for 1 -> desenha um rosto FELIZ.
//    - Se for 2 -> desenha um rosto TRISTE.
//    - Se for 3 -> desenha um rosto SURPRESO.
// 5. Se o valor for maior que 3 (ou seja, 4, 5, 6...), o programa "reseta" a
//    opção para 0, apaga a tela e mostra o número 0, avisando que o ciclo reiniciou.
// ============================================================

// DECLARAÇÃO DE VARIÁVEIS
// ------------------------------------------------------------
// "let opcao = 0" -> Cria um espaço na memória do Micro:bit chamado "opcao"
// (que significa "opção") e guarda o número 0 dentro dele.
// 
// POR QUE COMEÇAR EM 0? 
// Porque no nosso cardápio digital, o 0 representa o "estado inicial"
// (nenhuma opção selecionada ainda). Quando apertarmos o botão,
// somaremos 1 para chegar na primeira opção válida (opção 1).
// ------------------------------------------------------------
let opcao = 0

// ============================================================
// EVENTO: BOTÃO A PRESSIONADO
// ============================================================
// Aqui estamos dizendo ao Micro:bit: "Preste atenção! Se o usuário
// apertar o botão A (o da esquerda), execute todo o bloco de código
// que está dentro destas chaves { ... } imediatamente."
// 
// Esse tipo de estrutura é chamada de "função de retorno de chamada"
// (callback), pois o Micro:bit "chama de volta" esta função toda vez
// que o evento (apertar o botão) acontece.
// ============================================================
input.onButtonPressed(Button.A, function () {
    
    // ============================================================
    // PASSO 1: ATUALIZAR A VARIÁVEL "opcao"
    // ============================================================
    // "opcao = opcao + 1" é uma instrução matemática que faz o seguinte:
    // 1. Pega o valor ATUAL guardado em "opcao" (ex: 0).
    // 2. Soma 1 a esse valor (ex: 0 + 1 = 1).
    // 3. Guarda o NOVO resultado (1) de volta na variável "opcao".
    // 
    // NA PRÁTICA: Se já apertamos o botão algumas vezes, esse comando
    // faz a "opcao" andar para frente: 0 -> 1 -> 2 -> 3 -> 4 -> 5 ...
    // ============================================================
    opcao = opcao + 1

    // ============================================================
    // PASSO 2: ESTRUTURA CONDICIONAL MÚLTIPLA (SE / SENÃO SE / SENÃO)
    // ============================================================
    // Esta é uma "árvore de decisões". O Micro:bit vai testar as 
    // condições em ordem, de cima para baixo, e executará SOMENTE O 
    // PRIMEIRO bloco cuja condição for verdadeira.
    //
    // PENSE ASSIM: É como um fiscal de prova verificando sua resposta:
    // - "Sua opção é 1?" Se SIM, mostre feliz. Se NÃO, vá para a próxima pergunta.
    // - "Sua opção é 2?" Se SIM, mostre triste. Se NÃO, vá para a próxima.
    // - "Sua opção é 3?" Se SIM, mostre surpreso. Se NÃO, vá para a última saída.
    // - "Nenhuma das anteriores?" (opção 0, 4, 5, ...) Então: RESETE TUDO!
    // ============================================================

    // ------------------------------------
    // TESTE 1: Será que "opcao" é igual a 1?
    // ------------------------------------
    // Se o usuário apertou o botão A pela PRIMEIRA vez, "opcao" saiu de 0 para 1.
    // A condição "opcao == 1" é VERDADEIRA, então entramos neste bloco.
    // A função "basic.showIcon(IconNames.Happy)" desenha um rosto sorridente 
    // (😊) na matriz de LEDs 5x5 do Micro:bit.
    if (opcao == 1) {
        basic.showIcon(IconNames.Happy)      // Opção 1: FELIZ 😊
    } 
    // ------------------------------------
    // TESTE 2: Será que "opcao" é igual a 2?
    // ------------------------------------
    // Se o teste 1 foi FALSO (ou seja, "opcao" NÃO é 1), o código pula para este 
    // "else if". Se o usuário apertou o botão A pela SEGUNDA vez, "opcao" agora 
    // vale 2. A condição "opcao == 2" é VERDADEIRA, e desenhamos o rosto triste (😢).
    // 
    // OBS: O "else if" só é testado se o "if" anterior falhou.
    else if (opcao == 2) {
        basic.showIcon(IconNames.Sad)        // Opção 2: TRISTE 😢
    } 
    // ------------------------------------
    // TESTE 3: Será que "opcao" é igual a 3?
    // ------------------------------------
    // Se os dois testes anteriores falharam, chegamos aqui. Se o botão foi 
    // apertado pela TERCEIRA vez, "opcao" virou 3. A condição é VERDADEIRA,
    // e mostramos o rosto surpreso (😮) - a última opção válida do nosso cardápio.
    else if (opcao == 3) {
        basic.showIcon(IconNames.Surprised)  // Opção 3: SURPRESO 😮
    } 
    // ------------------------------------
    // BLOCO "SENÃO" (else) - O CORINGA
    // ------------------------------------
    // Se TODAS as condições acima forem FALSAS, o programa cai neste "else" 
    // final. Quando isso acontece? 
    // Resposta: Quando "opcao" NÃO é 1, NÃO é 2 e NÃO é 3.
    // 
    // Isso ocorrerá quando "opcao" valer 0 (estado inicial, se algo der errado)
    // ou quando valer 4, 5, 6, ... (ou seja, após apertarmos o botão pela 
    // QUARTA vez ou mais).
    // 
    // Ao invés de mostrar um ícone que não existe, este bloco é responsável
    // por "reiniciar o cardápio":
    // 1. "opcao = 0" -> Reseta a variável para o ponto de partida (zero).
    // 2. "basic.clearScreen()" -> Apaga todos os LEDs da tela (limpa o ícone).
    // 3. "basic.showNumber(0)" -> Mostra o número 0 na tela para avisar 
    //    visualmente que o ciclo foi reiniciado e estamos prontos para 
    //    começar de novo (da opção 1).
    // 
    // PRONTO! Agora, ao apertar o botão A novamente, o ciclo recomeça:
    // opcao 1 -> opcao 2 -> opcao 3 -> RESET (0) -> opcao 1 ... e assim por diante.
    else {
        opcao = 0                // Volta a variável para o início (zero).
        basic.clearScreen()      // Limpa os LEDs para evitar sobreposição de imagens.
        basic.showNumber(0)      // Mostra "0" para indicar que o sistema reiniciou.
    }
    // ============================================================
    // FIM DA ESTRUTURA CONDICIONAL
    // ============================================================

})
// ============================================================
// FIM DO PROGRAMA
// ============================================================
// PARA EXPERIMENTAR NA PRÁTICA:
// 1. Baixe este código para o seu Micro:bit.
// 2. Observe a tela (deve estar limpa ou mostrando o 0, se você reiniciou).
// 3. Aperte o botão A uma vez -> aparece o rosto feliz.
// 4. Aperte novamente -> rosto triste.
// 5. Aperte novamente -> rosto surpreso.
// 6. Aperte novamente -> a tela se apaga e mostra o número 0.
// 7. Repita a partir do passo 3! 
// 
// DESAFIO DIDÁTICO: E se quiséssemos 5 opções? Bastaria adicionar mais 
// "else if" (opcao == 4, opcao == 5) e ajustar o reset para acontecer 
// quando opcao > 5. Tente modificar isso depois de entender o fluxo!
// ============================================================

Programa "Grade de LEDs — A Diagonal Mágica"

// ============================================================
// PROGRAMA: GRADE DE LEDS — A DIAGONAL MÁGICA
// ============================================================
// OBJETIVO: Usar dois loops aninhados para acender a diagonal
// principal da matriz 5×5 de LEDs.
// ============================================================

// ============================================================
// FUNDAMENTAÇÃO TEÓRICA (COORDENADAS DA MATRIZ):
// ============================================================
// O micro:bit possui uma grade de 5 colunas (eixo Y) por 5 linhas (eixo X).
// As coordenadas vão de (0, 0) até (4, 4), onde:
//   - O PRIMEIRO número (x) representa a LINHA (vertical, de cima para baixo).
//   - O SEGUNDO número (y) representa a COLUNA (horizontal, da esquerda para a direita).
//
// A "diagonal principal" acontece quando o número da linha é exatamente
// igual ao número da coluna, ou seja: (0,0), (1,1), (2,2), (3,3) e (4,4).
// Visualizando a matriz, esses pontos formam uma reta inclinada que sai
// do canto superior esquerdo e vai até o canto inferior direito.
// ============================================================

// ============================================================
// LOOP EXTERNO: PERCORRE AS LINHAS (eixo X / vertical)
// ============================================================
// A variável 'x' começa em 0 (linha do topo) e vai até 4 (linha de baixo).
// A cada iteração deste loop, nós "descemos" uma linha na tela.
for (let x = 0; x <= 4; x++) {

    // ============================================================
    // LOOP INTERNO: PERCORRE AS COLUNAS (eixo Y / horizontal)
    // ============================================================
    // A variável 'y' começa em 0 (coluna da esquerda) e vai até 4 (coluna da direita).
    // Atenção: Para CADA linha (x), este loop interno percorre TODAS as 5 colunas (y).
    // Ou seja, para x=0, vamos testar y=0, 1, 2, 3 e 4.
    // Depois, para x=1, vamos testar y=0, 1, 2, 3 e 4... e assim por diante.
    // No total, esta dupla estrutura vai "visitar" todos os 25 LEDs (5x5).
    for (let y = 0; y <= 4; y++) {

        // ============================================================
        // DECISÃO: ESTE LED PERTENCE À DIAGONAL?
        // ============================================================
        // Aqui está o "coração" da lógica! Verificamos se a linha (x) é
        // exatamente igual à coluna (y).
        //
        // Se forem IGUAIS (ex: x=2 e y=2), significa que este LED está
        // perfeitamente alinhado na diagonal principal, então acendemos ele.
        //
        // Se forem DIFERENTES (ex: x=2 e y=4), significa que o LED está
        // fora da diagonal. Para garantir que a tela mostre APENAS a diagonal
        // (sem "fantasmas" de execuções anteriores), nós OBRIGATORIAMENTE
        // apagamos este LED.
        //
        // Obs: Poderíamos simplesmente limpar a tela no início, mas esta
        // técnica de "apagar tudo que não é a diagonal" é excelente para
        // aprendizado, pois mostra claramente a tomada de decisão para cada
        // pixel da matriz!
        if (x == y) {
            led.plot(x, y)      // Acende o LED na posição (x, y) - ENTRANDO NA DIAGONAL
        } else {
            led.unplot(x, y)    // Apaga o LED na posição (x, y) - FORA DA DIAGONAL
        }

        // ============================================================
        // PAUSA DIDÁTICA (EFEITO DE "VARREDURA")
        // ============================================================
        // Este comando insere um pequeno atraso de 50 milissegundos
        // (equivalente a 0,05 segundos) a CADA LED processado.
        // Isso desacelera a execução do programa, permitindo que nossos olhos
        // humanos acompanhem o caminho percorrido pelos loops.
        // Você verá um "traço" ou "varredura" percorrendo linha por linha,
        // da esquerda para a direita, de cima para baixo, e a diagonal
        // permanecerá acesa enquanto o restante pisca e apaga.
        // Dica: Mude este valor para 500 (meio segundo) para ver o efeito
        // ficar bem mais lento, ou para 0 para ver o resultado instantâneo!
        basic.pause(50)
    }
}

// ============================================================
// RESUMO DA EXECUÇÃO (PASSO A PASSO):
// ============================================================
// 1º linha (x=0): y=0 (acende), y=1 (apaga), y=2 (apaga), y=3 (apaga), y=4 (apaga).
// 2º linha (x=1): y=0 (apaga), y=1 (acende), y=2 (apaga), y=3 (apaga), y=4 (apaga).
// 3º linha (x=2): y=0 (apaga), y=1 (apaga), y=2 (acende), y=3 (apaga), y=4 (apaga).
// 4º linha (x=3): y=0 (apaga), y=1 (apaga), y=2 (apaga), y=3 (acende), y=4 (apaga).
// 5º linha (x=4): y=0 (apaga), y=1 (apaga), y=2 (apaga), y=3 (apaga), y=4 (acende).
//
// Ao final destas 25 iterações (5 linhas x 5 colunas), apenas os 5 LEDs
// da diagonal principal permanecerão acesos, formando uma linda reta
// inclinada na tela do micro:bit!
// ============================================================

Programa "Soma de Passos — O Cofrinho Inteligente"

// ================================================================
// PROGRAMA: SOMA DE PASSOS — O COFRINHO INTELIGENTE (MICRO:BIT)
// ================================================================
// FUNCIONAMENTO GERAL:
// Este programa simula um cofrinho digital. Cada vez que você aperta
// o botão A, é como se colocasse uma moeda de valor 1 no cofre.
// O robô mostra na tela o total acumulado. Se o total ultrapassar 20,
// ele comemora (ícone feliz) e zera tudo, como se você tivesse
// "quebrado" o cofre para gastar o dinheiro.
// O botão B serve para resetar manualmente a qualquer momento.
// 
// CONCEITOS ENSINADOS:
// - Variáveis (guardam números)
// - Eventos (o que fazer quando um botão é pressionado)
// - Operações aritméticas (incremento, soma, comparação)
// - Estrutura condicional (if/else)
// - Interface com o usuário (display, ícones, pausas)
// ================================================================

// ================================================================
// 1. DECLARAÇÃO DAS VARIÁVEIS GLOBAIS (ESTADO DO PROGRAMA)
// ================================================================

let contador = 0    // "Quantas vezes o botão A foi apertado?"
                    // Isso é útil para estatísticas, mas não é usado
                    // na lógica principal de soma (apenas para zerar junto).

let acumulador = 0  // "Quanto dinheiro eu tenho no total?"
                    // Esta é a variável mais importante: ela guarda a
                    // soma acumulada das moedas (cada aperto = +1).

// ================================================================
// 2. EVENTO: BOTÃO A PRESSIONADO (COLOCAR MOEDA)
// ================================================================
// Quando o usuário aperta o botão A, o micro:bit executa esta função.
// É o coração do programa.

input.onButtonPressed(Button.A, function () {

    // --- PASSO 1: Contar o aperto (apenas para registro) ---
    // Incrementa o contador de apertos em 1.
    // O operador '=' atribui o novo valor à variável.
    contador = contador + 1

    // --- PASSO 2: Acumular o valor da moeda (A LÓGICA PRINCIPAL) ---
    // CORREÇÃO IMPORTANTE (veja o comentário abaixo):
    // Antes, o código errado era: acumulador = acumulador + contador
    // Isso criava uma "soma triangular" (1, 3, 6, 10, 15...), porque
    // a cada aperto ele somava o número total de apertos já feitos.
    // Exemplo: 1º aperto soma 1, 2º soma 2 (total 3), 3º soma 3 (total 6)...
    // Agora, com "acumulador = acumulador + 1", cada aperto adiciona
    // exatamente 1, formando uma progressão linear (1, 2, 3, 4, 5...).
    // Isso é o correto para um cofrinho onde cada moeda vale 1.
    acumulador = acumulador + 1

    // --- PASSO 3: Mostrar o total na tela ---
    // A função basic.showNumber() exibe o valor no display de LEDs.
    // Aqui mostramos o total atualizado imediatamente após somar.
    basic.showNumber(acumulador)

    // --- PASSO 4: Verificar se o total ultrapassou o limite de 20 ---
    // Esta é a condição de "estourar o cofre".
    if (acumulador > 20) {   // Se o total for maior que 20...

        // --- AÇÃO: COMEMORAR E RESETAR ---
        // Exibe um ícone feliz (rosto sorridente) para celebrar.
        basic.showIcon(IconNames.Happy)

        // Dá uma pequena pausa de 500 milissegundos (0,5 segundos)
        // para que o usuário veja a comemoração antes do reset.
        basic.pause(500)

        // Mostra o número 0 na tela, indicando que o cofre foi zerado.
        basic.showNumber(0)

        // Zera o total de dinheiro (acumulador) e também a contagem
        // de apertos, para começar uma nova rodada do zero.
        acumulador = 0
        contador = 0
    }

    // OBSERVAÇÃO: Se o total NÃO ultrapassar 20, o programa simplesmente
    // termina a função e o display continua mostrando o último valor.
    // O robô fica aguardando o próximo aperto.
})

// ================================================================
// 3. EVENTO: BOTÃO B PRESSIONADO (RESET MANUAL FORÇADO)
// ================================================================
// Este botão dá ao usuário o poder de limpar o cofre quando quiser,
// sem precisar esperar chegar a 20. É útil para reiniciar o jogo
// ou corrigir um erro.

input.onButtonPressed(Button.B, function () {

    // Zera as duas variáveis imediatamente.
    acumulador = 0
    contador = 0

    // Mostra o número 0 no display para confirmar o reset.
    basic.showNumber(0)

    // Pausa curta para dar tempo de ler o zero.
    basic.pause(500)

    // Exibe a palavra "ZERADO!" na tela (rolagem de caracteres).
    // Isso dá um feedback claro ao usuário de que o reset ocorreu.
    basic.showString("ZERADO!")

    // Após mostrar a mensagem, o programa fica em espera até o
    // próximo evento (aperto de botão A ou B).
})

// ================================================================
// 4. COMO O PROGRAMA COMEÇA?
// ================================================================
// Quando o micro:bit é ligado, ele executa as variáveis (iniciando
// com 0) e fica em "modo de espera" (idle). Nada é mostrado na tela
// até que um botão seja pressionado. Isso acontece porque não há
// um bloco "on start" com uma mensagem inicial.
// 
// DICA DE MELHORIA: Poderíamos adicionar um bloco "on start" para
// mostrar "0" ou um ícone de início, mas o funcionamento básico
// já está completo.
// ================================================================

Programa "Dança do Chacoalhão — O DJ Robótico"

// ============================================================
// PROGRAMA: DANÇA DO CHACOALHÃO — O DJ ROBÓTICO
// ============================================================
// OBJETIVO: Quando o robô for chacoalhado, ele entra em um loop
// que verifica a inclinação 10 vezes e mostra setas.
// ============================================================

/*
 * COMENTÁRIOS DIDÁTICOS GERAIS:
 * ---------------------------------
 * Este programa é escrito em JavaScript para o micro:bit, utilizando a plataforma MakeCode.
 * O micro:bit possui um acelerômetro que mede a aceleração em três eixos (X, Y, Z) e também
 * permite detectar gestos como "chacoalhar" (shake). Além disso, podemos medir a rotação
 * (inclinação) em torno dos eixos Pitch (inclinação para frente/trás) e Roll (inclinação lateral).
 *
 * O programa reage ao gesto de chacoalhar (shake) e, a partir daí, executa uma sequência de
 * verificações da inclinação (Pitch) para exibir setas ou um ícone feliz, formando uma
 * "dança" interativa. Ao final, mostra a palavra "FIM!".
 *
 * Estrutura do código:
 * 1. Função de callback associada ao evento de chacoalhar (input.onGesture).
 * 2. Dentro da função, um loop for que repete 10 vezes:
 *    a. Lê a rotação no eixo Pitch.
 *    b. Se a inclinação for menor que -10 graus, mostra seta para esquerda.
 *    c. Se a inclinação for maior que 10 graus, mostra seta para direita.
 *    d. Caso contrário (inclinação entre -10 e 10), mostra ícone feliz.
 *    e. Aguarda 200 milissegundos (pausa) entre cada iteração.
 * 3. Após o loop, exibe a string "FIM!" na matriz de LEDs.
 */

// ============================================================
// Bloco de código que é executado quando o micro:bit detecta
// o gesto de "chacoalhar" (shake). Esse gesto é reconhecido
// pelo acelerômetro quando o dispositivo é agitado rapidamente.
// ============================================================
input.onGesture(Gesture.Shake, function () {
    // ============================================================
    // Loop que se repete 10 vezes. A variável 'i' é o contador,
    // mas não é usada dentro do loop, servindo apenas para controlar
    // o número de repetições (10 ciclos de verificação e exibição).
    // ============================================================
    for (let i = 0; i < 10; i++) {
        // ============================================================
        // Lê a rotação atual no eixo Pitch (inclinação para frente/trás).
        // O método input.rotation() retorna o ângulo em graus.
        // Rotation.Pitch: eixo que vai de -180° a 180°, onde:
        //   - Valores negativos indicam que a parte frontal do micro:bit
        //     está inclinada para baixo (ponta para frente).
        //   - Valores positivos indicam que a parte traseira está inclinada
        //     para baixo (ponta para cima).
        //   - Próximo de 0° significa horizontal.
        // Usamos os limites de -10° e +10° para criar uma zona morta
        // (dead zone) que evita mudanças muito sensíveis com pequenas
        // inclinações.
        // ============================================================
        if (input.rotation(Rotation.Pitch) < -10) {
            // Se a inclinação for menor que -10° (frente para baixo),
            // exibe uma seta apontando para a esquerda (West).
            // ArrowNames.West corresponde à seta ◄ na matriz de LEDs.
            basic.showArrow(ArrowNames.West)  // Seta para esquerda ◄
        } else if (input.rotation(Rotation.Pitch) > 10) {
            // Se a inclinação for maior que +10° (traseira para baixo),
            // exibe uma seta apontando para a direita (East).
            // ArrowNames.East corresponde à seta ► na matriz de LEDs.
            basic.showArrow(ArrowNames.East)  // Seta para direita ►
        } else {
            // Se a inclinação estiver entre -10° e +10° (ou seja,
            // aproximadamente horizontal), exibe um ícone feliz (smiley).
            // IconNames.Happy é um rosto sorridente.
            basic.showIcon(IconNames.Happy)   // Mostra feliz 😊
        }
        // ============================================================
        // Pausa de 200 milissegundos (0,2 segundos) entre cada iteração
        // do loop. Isso dá tempo para o usuário ver o símbolo exibido
        // e também permite que o micro:bit faça novas leituras do
        // acelerômetro sem pressa, tornando a "dança" mais suave.
        // ============================================================
        basic.pause(200)
    }
    // ============================================================
    // Após as 10 repetições, exibe a mensagem "FIM!" na matriz de LEDs,
    // indicando que a sequência terminou. A função showString() rola
    // os caracteres na tela.
    // ============================================================
    basic.showString("FIM!")
})

// ============================================================
// FIM DO PROGRAMA
// ============================================================

Bug 1 — Loop Infinito por Falta de Incremento

let i = 0
while (i < 10) {
    basic.showNumber(i)
    // FALTA ALGO AQUI! O que será?
}
// CORREÇÃO: Adicionar "i = i + 1" dentro do loop.

Bug 2 — Condição Invertida

let contador = 3
if (contador > 5) {
    basic.showIcon(IconNames.Happy)
} else {
    basic.showIcon(IconNames.Sad)
}
// CORREÇÃO: Trocar ">" por "<".

Bug 3 — IF fora do Loop

for (let contador = 0; contador < 5; contador++) {
    basic.showNumber(contador)
}
// O IF deveria estar DENTRO do loop!
if (contador == 5) {
    basic.showIcon(IconNames.Happy)
}
// CORREÇÃO: Mover o IF para DENTRO do loop.

Programa "Pedômetro Inteligente — O Personal Trainer Robótico"

// ============================================================
// PEDÔMETRO INTELIGENTE (para placa micro:bit)
// ============================================================
// OBJETIVO: Contar chacoalhadas (simulando passos) e disparar 
// um alerta (visual + sonoro) quando o usuário bater a meta.
// ============================================================

// ------------------------------------------------------------
// 1. DECLARAÇÃO DAS VARIÁVEIS GLOBAIS (ESTADO DO PROGRAMA)
// ------------------------------------------------------------

// 'passos' armazena a contagem atual. Começa em zero.
// IMPORTANTE: Esta variável é global, pois será acessada e 
// modificada por diferentes blocos de eventos (chacoalhada e botões).
let passos = 0

// 'meta' define o número de passos necessários para vencer.
// Começa em 10, mas o usuário pode aumentar com o botão A.
let meta = 10

// ------------------------------------------------------------
// 2. EVENTO PRINCIPAL: DETECÇÃO DE CHACOALHADA (ACELERÔMETRO)
// ------------------------------------------------------------

// 'onGesture(Gesture.Shake, ...)' é uma função de callback.
// Ela é executada AUTOMATICAMENTE sempre que o micro:bit detectar
// um movimento brusco (como uma pisada ou chacoalhada).
// A lógica interna é baseada nos dados do acelerômetro.
input.onGesture(Gesture.Shake, function () {

    // Passo 1: INCREMENTAR O CONTADOR
    // Cada chacoalhada soma +1 à variável 'passos'.
    // Isso é equivalente a: passos = passos + 1
    passos = passos + 1

    // Passo 2: FEEDBACK VISUAL IMEDIATO
    // Exibe o número atualizado na matriz de LEDs (5x5) para o usuário
    // ver o progresso em tempo real.
    basic.showNumber(passos)

    // Passo 3: VERIFICAR SE A META FOI ATINGIDA OU ULTRAPASSADA
    // Estrutura condicional que compara o valor atual com a meta.
    if (passos >= meta) {

        // ---- SUB-ROTINA DE COMEMORAÇÃO (VITÓRIA) ----

        // Feedback Visual: Mostra um ícone de rosto feliz na tela.
        // O ícone é pré-definido pela biblioteca 'IconNames'.
        basic.showIcon(IconNames.Happy)

        // Feedback Sonoro: Toca uma nota musical.
        // 'playTone(frequência, duração)' - 523 Hz é a nota Dó central (C5).
        // A duração de 200 milissegundos gera um "bip" curto e alegre.
        music.playTone(523, 200)

        // Pausa de 1 segundo (1000 ms) para dar tempo do usuário
        // processar a comemoração (ver o ícone e ouvir o som).
        basic.pause(1000)

        // Limpa a tela de LEDs para deixar o display pronto para
        // a próxima contagem, evitando poluição visual.
        basic.clearScreen()

        // Passo 4: REINICIAR A CONTAGEM (NOVO CICLO)
        // Após a comemoração, zeramos a variável 'passos' para que
        // o usuário possa começar a contar novamente do zero.
        // A 'meta' permanece a mesma (a não ser que o usuário a altere).
        passos = 0
    }
})

// ------------------------------------------------------------
// 3. EVENTO DO BOTÃO A: AJUSTAR A META PARA CIMA
// ------------------------------------------------------------

// Quando o botão A for pressionado, esta função é executada.
// Permite ao usuário aumentar a dificuldade sem precisar
// reiniciar o programa ou conectar no computador.
input.onButtonPressed(Button.A, function () {

    // Aumenta a meta em 5 passos.
    // Exemplo: se era 10, vira 15; se era 15, vira 20.
    meta = meta + 5

    // Mostra a NOVA meta na tela para o usuário confirmar o valor.
    basic.showNumber(meta)

    // Pequena pausa de 500 ms (meio segundo) para o usuário
    // conseguir ler o valor da nova meta.
    basic.pause(500)

    // Após mostrar a meta, a tela volta a mostrar a contagem ATUAL
    // de passos ('passos'). Isso evita que o usuário perca o
    // número de passos que já deu enquanto ajustava a meta.
    basic.showNumber(passos)
})

// ------------------------------------------------------------
// 4. EVENTO DO BOTÃO B: REINICIAR A CONTAGEM FORÇADAMENTE
// ------------------------------------------------------------

// Quando o botão B for pressionado, esta função é executada.
// Útil se o usuário quiser começar uma nova série de passos
// sem precisar chacoalhar até zerar (já que zerar só ocorre
// ao bater a meta).
input.onButtonPressed(Button.B, function () {

    // Zera a variável de passos manualmente.
    passos = 0

    // Mostra o número 0 na matriz de LEDs para confirmar
    // visualmente que o reset foi realizado com sucesso.
    basic.showNumber(0)
})

Programa "Genius — O Jogo da Memória" (Versão Simplificada para o 4º ano)

// ============================================================
// PROGRAMA: GENIUS — O JOGO DA MEMÓRIA
// ============================================================
// OBJETIVO: O robô mostra uma sequência de números (0 a 3).
// O jogador deve repetir a sequência usando os botões.
// ============================================================

// ------------------- VARIÁVEIS GLOBAIS ------------------------
// `sequencia` armazena a lista de números que o jogador deve memorizar
let sequencia: number[] = []

// `nivel` controla o comprimento da sequência (começa em 1 e aumenta a cada acerto)
let nivel = 1

// `tentativa` indica quantos números da sequência o jogador já acertou na rodada atual
let tentativa = 0

// -------------------------------------------------------------
// FUNÇÃO: gerarSequencia()
// -------------------------------------------------------------
// Cria uma nova sequência aleatória com tamanho igual ao `nivel`.
// Cada número é sorteado entre 0 e 3 (inclusive) usando Math.randomRange.
// A sequência é armazenada no vetor global `sequencia`.
function gerarSequencia() {
    sequencia = []                        // Limpa a sequência anterior
    for (let i = 0; i < nivel; i++) {     // Repete `nivel` vezes
        let numero = Math.randomRange(0, 3)  // Sorteia 0, 1, 2 ou 3
        sequencia.push(numero)            // Adiciona ao final do vetor
    }
}

// -------------------------------------------------------------
// FUNÇÃO: mostrarSequencia()
// -------------------------------------------------------------
// Exibe a sequência atual no display do Micro:bit, um número por vez,
// usando ícones diferentes para cada número (facilita a memorização).
// Depois de mostrar toda a sequência, exibe "SUA VEZ!" para o jogador.
function mostrarSequencia() {
    // Percorre todos os elementos da sequência
    for (let i = 0; i < sequencia.length; i++) {
        let numero = sequencia[i]          // Pega o número atual

        // Mostra o número em formato digital (0, 1, 2 ou 3)
        basic.showNumber(numero)
        basic.pause(500)                   // Pausa 500 ms para o jogador ver

        // Mostra um ícone correspondente ao número (reforço visual)
        if (numero == 0) {
            basic.showIcon(IconNames.Square)      // Quadrado
        } else if (numero == 1) {
            basic.showIcon(IconNames.Heart)       // Coração
        } else if (numero == 2) {
            basic.showIcon(IconNames.Diamond)     // Losango
        } else {
            basic.showIcon(IconNames.Chessboard)  // Tabuleiro (para o 3)
        }
        basic.pause(500)                   // Pausa para visualizar o ícone
    }

    // Limpa a tela e avisa que é a vez do jogador
    basic.clearScreen()
    basic.showString("SUA VEZ!")
}

// -------------------------------------------------------------
// FUNÇÃO: verificarTentativa(valor: number)
// -------------------------------------------------------------
// Esta função é chamada quando o jogador faz uma jogada (botão ou gesto).
// Recebe o valor escolhido (0 a 3) e compara com o próximo número da sequência.
// - Se acertar: avança o índice `tentativa`.
//   - Se completou a sequência inteira: mostra feliz, aumenta o nível,
//     reinicia o índice e gera/mostra uma nova sequência.
// - Se errar: mostra ícone de "não", pausa, reinicia a tentativa e
//   mostra a sequência novamente (para o jogador tentar de novo).
function verificarTentativa(valor: number) {
    // Compara o valor escolhido com o próximo número esperado
    if (valor == sequencia[tentativa]) {
        // Acertou! Avança para o próximo número
        tentativa = tentativa + 1

        // Verifica se já acertou todos os números da sequência
        if (tentativa == sequencia.length) {
            // Sequência completa com sucesso!
            basic.showIcon(IconNames.Happy)   // Mostra carinha feliz
            basic.pause(500)

            // Prepara a próxima rodada: aumenta nível, reinicia tentativa,
            // gera nova sequência e a mostra.
            nivel = nivel + 1
            tentativa = 0
            gerarSequencia()
            mostrarSequencia()
        }
        // Se não completou a sequência, apenas aguarda a próxima jogada
    } else {
        // Errou! Mostra sinal de erro e reinicia a tentativa atual.
        basic.showIcon(IconNames.No)          // Ícone de "não" (X)
        basic.pause(1000)                     // Pausa para o jogador perceber

        // Reinicia o índice de tentativa para 0 (recomeça a sequência)
        tentativa = 0

        // Mostra a sequência novamente para o jogador tentar mais uma vez
        mostrarSequencia()
    }
}

// -------------------------------------------------------------
// CONFIGURAÇÃO DOS EVENTOS (entradas do jogador)
// -------------------------------------------------------------
// Associamos cada botão/gesto a um valor numérico:
// - Botão A -> 0
// - Botão B -> 1
// - Botão A+B -> 2
// - Agitar (shake) -> 3
// Isso permite que o jogador "digite" os números usando o Micro:bit.

input.onButtonPressed(Button.A, function () {
    verificarTentativa(0)
})

input.onButtonPressed(Button.B, function () {
    verificarTentativa(1)
})

input.onButtonPressed(Button.AB, function () {
    verificarTentativa(2)
})

input.onGesture(Gesture.Shake, function () {
    verificarTentativa(3)
})

// -------------------------------------------------------------
// INICIALIZAÇÃO DO JOGO
// -------------------------------------------------------------
// Quando o programa inicia, gera a primeira sequência (nível 1)
// e a mostra para o jogador começar a jogar.
gerarSequencia()
mostrarSequencia()

// ============================================================
// FIM DO PROGRAMA
// ============================================================

Programa "Semáforo com Detector de Carros"

// ============================================================
// PROGRAMA: SEMÁFORO COM DETECTOR DE CARROS
// ============================================================
// OBJETIVO: Simular um semáforo que detecta "carros" esperando
// e acelera a mudança para verde.
// ============================================================
// 
// EXPLICAÇÃO RESUMIDA DE FUNCIONAMENTO:
// O programa é uma Máquina de Estados (Verde -> Amarelo -> Vermelho -> Verde).
// Um cronômetro (basic.pause) define o tempo de cada estado.
// O botão A simula a chegada de um carro. Se um carro estiver esperando
// quando o semáforo estiver Vermelho, o programa ABORTA o tempo do vermelho
// e volta imediatamente para o Verde por 2 segundos, reiniciando o ciclo.
// ============================================================

// --- VARIÁVEIS GLOBAIS ---
// cor: 0 = Verde, 1 = Amarelo, 2 = Vermelho.
// Começamos no Verde para o trânsito fluir imediatamente.
let cor = 0

// carroEsperando: flag (bandeira) que indica se um motorista apertou o botão.
// Inicia como falso (nenhum carro aguardando).
let carroEsperando = false

// --- EVENTO DO BOTÃO A (INTERRUPÇÃO) ---
// Quando o botão A for pressionado, este código é executado IMEDIATAMENTE,
// mesmo enquanto o semáforo estiver em pausa (basic.pause).
input.onButtonPressed(Button.A, function () {
    // Marca que há um carro aguardando passagem.
    carroEsperando = true
    
    // Mostra um símbolo de "Sim" (check) para dar feedback visual ao usuário
    // de que o botão foi pressionado com sucesso.
    basic.showIcon(IconNames.Yes)
    
    // Pequena pausa de 300ms para o usuário conseguir ver o ícone "Yes"
    // antes do ícone do semáforo ser restaurado pelo loop principal.
    basic.pause(300)
})

// --- LOOP PRINCIPAL (FOREVER) ---
// Este bloco executa repetidamente enquanto o Micro:bit estiver ligado.
// Ele controla a lógica de mudança de cores do semáforo.
basic.forever(function () {
    
    // ---------------------------------------------
    // 1ª CONDIÇÃO: PRIORIDADE PARA O CARRO ESPERANDO
    // ---------------------------------------------
    // Se existe um carro esperando (flag == true) E a cor atual é Vermelho (2):
    if (carroEsperando == true && cor == 2) {
        // O semáforo muda IMEDIATAMENTE para Verde, sem esperar os 3 segundos
        // do vermelho. Isso simula o detector de carros ativando a troca rápida.
        cor = 0
        
        // Reseta a flag, pois o carro já foi "atendido" (vai passar agora).
        carroEsperando = false
        
        // Atualiza a matriz de LEDs para mostrar a cor Verde.
        mostrarVerde()
        
        // Permanece verde por apenas 2 segundos (tempo reduzido, pois o carro
        // já estava esperando, mas precisamos dar tempo dele atravessar).
        basic.pause(2000)
        
    // ---------------------------------------------
    // 2ª CONDIÇÃO: SEMÁFORO VERDE (ESTADO NORMAL)
    // ---------------------------------------------
    // Se a cor atual é Verde (e não há carro prioritário no vermelho):
    } else if (cor == 0) {
        // Mostra a seta para cima (representando o verde "siga").
        mostrarVerde()
        
        // Fica verde por 3 segundos (tempo padrão de fluxo livre).
        basic.pause(3000)
        
        // Após o tempo, transiciona para a próxima cor do ciclo: Amarelo (1).
        cor = 1
        
    // ---------------------------------------------
    // 3ª CONDIÇÃO: SEMÁFORO AMARELO (ATENÇÃO)
    // ---------------------------------------------
    } else if (cor == 1) {
        // Mostra um quadrado pequeno (representando o amarelo "atenção").
        mostrarAmarelo()
        
        // Fica amarelo por 1 segundo (tempo curto de aviso).
        basic.pause(1000)
        
        // Transiciona para a próxima cor: Vermelho (2).
        cor = 2
        
    // ---------------------------------------------
    // 4ª CONDIÇÃO: SEMÁFORO VERMELHO (PARE)
    // ---------------------------------------------
    } else {
        // Mostra o símbolo "Não" (X) representando o vermelho "pare".
        mostrarVermelho()
        
        // Fica vermelho por 3 segundos.
        // ATENÇÃO: Se alguém apertar o botão A durante esta pausa de 3s,
        // a variável 'carroEsperando' será alterada, mas o código SÓ vai
        // verificar isso quando esta pausa terminar e o loop recomeçar.
        basic.pause(3000)
        
        // Após esperar os 3 segundos (ou ser interrompido pela lógica
        // de prioridade no próximo ciclo), volta para o Verde (0).
        cor = 0
    }
    // Fim do loop: ele volta automaticamente para o início do 'forever'.
})

// --- FUNÇÕES AUXILIARES DE EXIBIÇÃO ---
// (Separamos em funções para deixar o código mais organizado e legível)

// Representa o Verde com uma seta apontando para o Norte (para cima),
// simbolizando que o motorista pode "seguir em frente".
function mostrarVerde() {
    basic.showArrow(ArrowNames.North)
}

// Representa o Amarelo com um quadrado pequeno no centro da tela,
// simbolizando o "atenção, pare se for seguro".
function mostrarAmarelo() {
    basic.showIcon(IconNames.SmallSquare)
}

// Representa o Vermelho com um grande "X" (símbolo de proibido),
// simbolizando que o motorista deve "parar obrigatoriamente".
function mostrarVermelho() {
    basic.showIcon(IconNames.No)
}