¿Qué hace este programa?
Este programa ejecuta una prueba de conducción corta para medir qué tan rápido se mueve tu robot según dos estadísticas que eliges: SPEED y ENDURANCE. También simula cómo cambia la potencia del motor a medida que avanza un partido — para que puedas sentir cómo es conducir al inicio vs. al final de un juego.
Mientras conduce, vigila constantemente los sensores de la pista y reacciona si tu robot llega al borde. Piénsalo como un bucle de prueba más inteligente: no solo "ve rápido," sino "ve rápido como lo haría un robot en un partido real."
SPEED = 0 y ENDURANCE = 0 en el bloque on start y cónfiguralas con los valores reales de las estadísticas de tu personaje. Si las dejas en cero, el robot no se moverá.
Tres botones. Eso es todo.
Todo el programa se controla con los botones del micro:bit. Esto es lo que hace cada uno:
Ejecutar la Prueba
Calcula la potencia a partir de tus estadísticas, luego conduce recto durante la duración de la prueba. Observa la ralentización según la configuración de tiempo del partido.
Configurar Tiempo del Partido
Cicla entre 0 → 60 → 120 → 180 segundos. Configura esto antes de presionar A para simular cuán cansado está el robot en ese punto.
Parada de Emergencia
Corta todos los motores de inmediato. Úsalo si tu robot se dirige a un lugar donde no debería. Muestra una ✕ en la pantalla LED.
¿Cómo funciona cada sección?
let TEST_DURATION_MS = 5000
let BORDER_CHECK_MS = 60
let BORDER_PIVOT_MS = 400
let BORDER_PIVOT_POWER = 50
let BACKUP_MS = 600
let BORDER_THRESHOLD = 200
let SPEED = 0
let ENDURANCE = 0
Este bloque se ejecuta una vez en el momento en que el micro:bit se enciende. Llena todas las configuraciones que necesita tu programa antes de que se presione cualquier botón. Piénsalo como escribir valores en una hoja de configuración.
TEST_DURATION_MS = 5000 — Cada ejecución de prueba dura 5.000 milisegundos (5 segundos). Puedes cambiar este número para hacer las pruebas más largas o cortas.BORDER_CHECK_MS = 60 — Mientras conduce, el robot verifica sus sensores cada 60ms. Cuanto menor sea este número, más rápido reacciona al borde.SPEED = 0 y ENDURANCE = 0 — Estos son para que tú los llenes. Reemplaza los ceros con los valores de estadísticas de tu personaje antes de subir al micro:bit.
let running = false
let testStart = 0
let BORDER_CHECK_MS = 0
let borderSide = 0
function computeStats() {}
function checkBorder() { return 0 }
function handleBorder() {}
input.onButtonPressed(Button.A, function () {
computeStats()
running = true
testStart = input.runningTime()
basic.pause(BORDER_CHECK_MS)
while (running) {
borderSide = checkBorder()
if (borderSide > 0) {
handleBorder()
}
basic.pause(BORDER_CHECK_MS)
}
running = false
basic.showString("DONE")
basic.pause(500)
basic.clearScreen()
})
Presionar A ejecuta la secuencia completa de prueba. Los pasos ocurren en orden, de arriba hacia abajo:
running = true y registra el tiempo de inicio — esto "enciende" el bucle de abajo e inicia el reloj.currentPower — potencia igual izquierda y derecha significa que el robot conduce recto sin girar.
let simulatedMatchTime = 0
input.onButtonPressed(Button.B, function () {
if (simulatedMatchTime == 0) {
simulatedMatchTime = 60
basic.showLeds(`
# . . . .
# . . . .
# . . . .
# . . . .
# . . . .
`)
} else if (simulatedMatchTime == 60) {
simulatedMatchTime = 120
basic.showLeds(`
# # . . .
# # . . .
# # . . .
# # . . .
# # . . .
`)
} else if (simulatedMatchTime == 120) {
simulatedMatchTime = 180
basic.showLeds(`
# # # . .
# # # . .
# # # . .
# # # . .
# # # . .
`)
} else {
simulatedMatchTime = 0
basic.showLeds(`
. . . . .
. . . . .
. . # . .
. . . . .
. . . . .
`)
}
basic.pause(500)
basic.clearScreen()
})
Cada pulsación de B cicla simulatedMatchTime entre cuatro valores: 0 → 60 → 120 → 180 → 0. La pantalla LED te muestra exactamente dónde estás en el ciclo para que siempre sepas tu configuración.
let running = false
input.onButtonPressed(Button.AB, function () {
running = false
basic.showLeds(`
# . . . #
. # . # .
. . # . .
. # . # .
# . . . #
`)
basic.pause(500)
basic.clearScreen()
})
Mantén A y B al mismo tiempo. El programa corta la potencia y sale del bucle de inmediato — sin ralentización gradual. Suceden tres cosas:
running = false — esto sale del bucle while de conducción en la próxima verificación (dentro de 60ms).
let SPEED = 0
let ENDURANCE = 0
let simulatedMatchTime = 0
let basePower = 0
let DECAY_RATE = 0
let endurancePercent = 0
let enduranceFactor = 0
let currentPower = 0
function computeStats () {
basePower = SPEED * 100 / 20
DECAY_RATE = 20 - ENDURANCE
endurancePercent = 100 - DECAY_RATE * simulatedMatchTime / 40
endurancePercent = Math.max(endurancePercent, 20)
enduranceFactor = endurancePercent / 100
currentPower = Math.round(basePower * enduranceFactor)
currentPower = Math.max(currentPower, Math.max(Math.round(basePower * 0.2), 10))
}
Esta función se llama cada vez que presionas A. Ejecuta los cálculos para determinar qué potencia del motor usar ahora, según tus estadísticas y dónde estás en el partido.
DECAY_RATE = 20 − ENDURANCE ← menor endurance = decaimiento más rápido
endurancePercent = 100 − (DECAY_RATE × matchTime ÷ 40) ← disminuye con el tiempo
currentPower = basePower × enduranceFactor ← número final enviado a los motores
let sensor1State = 0
let sensor2State = 0
let sensor3State = 0
let sensor4State = 0
let BORDER_THRESHOLD = 0
function checkBorder () {
if (sensor1State > BORDER_THRESHOLD) {
return 1
} else if (sensor4State > BORDER_THRESHOLD) {
return 2
} else if (sensor2State > BORDER_THRESHOLD || sensor3State > BORDER_THRESHOLD) {
return 3
}
return 0
}
Tu Cutebot Pro tiene cuatro sensores de seguimiento de línea en su parte inferior. Esta función lee los cuatro y devuelve un número que le dice al bucle principal de qué dirección viene el problema. El borde blanco refleja más luz — eso es lo que el sensor "ve".
let BACKUP_MS = 0
let BORDER_PIVOT_MS = 0
let borderSide = 0
let recheck = 0
function checkBorder() { return 0 }
function handleBorder () {
basic.pause(50)
basic.pause(BACKUP_MS)
basic.pause(100)
if (borderSide == 1) {
basic.pause(BORDER_PIVOT_MS + Math.randomRange(-80, 80))
} else if (borderSide == 2) {
basic.pause(BORDER_PIVOT_MS + Math.randomRange(-80, 80))
} else {
basic.pause(BACKUP_MS + 300)
basic.pause(100)
basic.pause(BORDER_PIVOT_MS * 2)
}
basic.pause(100)
recheck = checkBorder()
if (recheck > 0) {
basic.pause(BACKUP_MS)
basic.pause(100)
basic.pause(BORDER_PIVOT_MS)
basic.pause(100)
}
}
Cuando un sensor detecta el borde, esta función toma el control para dirigir el robot de regreso al ring. El movimiento exacto depende de cuál sensor se activó.
BACKUP_MS (600ms) para crear espacio para un giro.1 (peligro izquierda) → girar a la derecha — una rueda adelante, una atrás2 (peligro derecha) → girar a la izquierda3 (directo) → retroceder extra, luego hacer un giro más amplio
checkBorder de nuevo. Si aún está en blanco, hace un retroceso y giro más antes de retomar la conducción normal.Math.randomRange(-80, 80) agrega una pequeña variación aleatoria a cada tiempo de giro. Esto evita que el robot quede atrapado en el mismo bucle exacto si toca el mismo lugar dos veces.
¿Qué significa cada variable?
Dorado = tú lo configuras antes de subir. Cian = el programa lo calcula automáticamente. Púrpura = una constante fija que controla el comportamiento.
Viendo el decaimiento de velocidad en acción
Así se ve currentPower para un robot con SPEED = 10, ENDURANCE = 5 en diferentes momentos del partido. ENDURANCE bajo = caída pronunciada. ENDURANCE alto = línea plana.
Potencia del motor en cada punto del partido · SPEED 10 · ENDURANCE 5
Este robot llega al piso del 20% de potencia antes de que termine el partido. Invierte más en ENDURANCE para aplanar esta curva.
Consejos para usar este programa
Configura tus estadísticas primero
Encuentra las líneas SPEED = 0 y ENDURANCE = 0 en on start. Escribe los valores reales de tu personaje antes de subir al micro:bit.
Prueba los 4 momentos de tiempo
Ejecuta a 0s, 60s, 120s y 180s. Observa si el robot se siente diferente. Si no, tu ENDURANCE es fuerte. Si arrastra a 180s, es bajo.
Ajusta TEST_DURATION_MS
5 segundos es rápido. Prueba 10000 (10s) para ver más reacciones al borde — especialmente útil si quieres observar la lógica de recuperación trabajar varias veces.
Ten A+B a mano
Si el robot empieza a dirigirse a un lugar malo, presiona A+B de inmediato. Siempre es seguro hacer una parada de emergencia y volver a empezar desde el inicio.
Compara diferentes configuraciones
Prueba SPEED alto / ENDURANCE bajo vs. SPEED bajo / ENDURANCE alto. Ejecuta ambos a 180s. Los resultados podrían sorprenderte.
Lee la pantalla LED
Una columna de LEDs = 60s. Dos columnas = 120s. Tres = 180s. Úsalo como una verificación visual rápida antes de presionar A para siempre saber tu configuración actual.