
Pantalla de color micro:bit: Chisme 207 espectacular
Los alumnos de 2.º de ESO miraban la micro:bit del Lince con cara de sospecha. En sus 25 LEDs pasaba, despacísimo, un número: «2… 4… °C».
—¿Cuánto ha dicho? —preguntó Dani. Pantalla de color micro:bit.
—Veinti… no sé, se me ha ido —dijo Lucía.
El Lince, que es ingeniero y por tanto incapaz de aceptar un problema pequeño, ya estaba dibujando en la pizarra un cartel gigante con tres mil LEDs soldados a mano.
—Lince —dijo la Gata Montesa, sin levantar la vista—. ¿Y si en vez de 3.000 LEDs usas una pantalla de color que se pincha en la micro:bit?
—Eso tendría que programar cómo dibujar cada número, píxel a píxel. Son cientos de líneas.
—Ya las ha programado alguien. Tú arrastras dos bloques.
—¿Eso no es trampa?
—Es lo que hacéis los ingenieros todos los días —sonrió la Gata—. Usar lo que otros hicieron, sabiendo qué hace.
Introducción: pantalla de color micro:bit
En este chisme conseguimos que la micro:bit dibuje la temperatura en una pantalla de color, sin ordenador. La pantalla es una pantalla de color micro:bit de 1,8 pulgadas que se pincha sin cables.
El programa tiene cientos de líneas, pero tú solo vas a usar dos bloques. Por el camino aprendes tres cosas que usarás muchas veces:
- Copiar y pegar código en la pestaña JavaScript de MakeCode.
- Pasar de JavaScript a bloques y comprobar que es el mismo programa.
- Arrastrar funciones: bloques azules que alguien ya ha programado por ti.
Es un prototipo educativo. Dura unos 30 minutos.
Por qué este chisme
Los 25 LEDs de la micro:bit sirven para un número pequeño y rápido, pero no para leer un dato con calma. Una pantalla de color permite ver la temperatura grande, fija y de un vistazo.
Además, este chisme enseña algo muy de ingeniería: no hace falta escribir todo desde cero. Una función es un trozo de programa con nombre que se reutiliza. Aquí la usamos como una caja que ya funciona.
Cómo funciona
La pantalla tiene 160 × 128 píxeles y habla con la micro:bit por un sistema de comunicación llamado SPI. Si quieres saber más, mira qué es el bus SPI.
Cada número se dibuja como en una calculadora: con 7 rectángulos (segmentos) que se encienden o se apagan. El 8 los enciende todos; el 1 solo dos. El programa guarda esa información en una cadena de unos y ceros.
El color de cada píxel ocupa 16 bits: 5 para el rojo, 6 para el verde y 5 para el azul. Es la misma idea de mezcla RGB que vimos con los píxeles y los colores RGB.
El programa tiene dos partes:
- Parte 2 (no se toca): funciones que trabajan por dentro para que la pantalla funcione.
- Parte 1 (lo importante):
iniciarPantallaeimprimirTemperatura, las dos que vas a arrastrar.
Qué necesitamos
- micro:bit V2 (la del óvalo dorado y altavoz). La V1 no sirve: se queda sin memoria.
- Pantalla de color 1,8″ para micro:bit (se pincha sin cables).
- Cable USB.
- Ordenador con Chrome o Edge.

Imagen de producto de Waveshare, que muestra cómo queda la micro:bit pinchada.
Cómo está organizado el paso a paso
Cada paso usa tres cartelitos:
- 🟢 Haz esto: una sola acción.
- 👀 Debes ver: así sabes que ese paso salió bien.
- 🔴 Si no sale: qué mirar antes de pedir ayuda.
Paso 1. Pincha la pantalla
🟢 Haz esto
- Coge la pantalla y mira el conector dentado de la parte de abajo.
- Pincha la micro:bit hasta el fondo. La matriz de LEDs debe quedar del mismo lado que la pantalla.
- Conecta el cable USB a la micro:bit y al ordenador.
👀 Debes ver: la micro:bit se enciende. La pantalla puede estar blanca o negra: es normal, todavía no tiene programa.
🔴 Si no sale: empuja un poco más. Un conector a medias es el fallo más común.
Paso 2. Crea un proyecto nuevo, sin extensiones
🟢 Haz esto
- Abre MakeCode para micro:bit en Chrome o Edge.
- Pulsa Nuevo proyecto y ponle de nombre
chisme207. - No añadas ninguna extensión.
👀 Debes ver: los bloques al iniciar y para siempre, vacíos.
Paso 3. Cambia a JavaScript
🟢 Haz esto
- Arriba, en el centro, pulsa JavaScript.
- Selecciona todo el texto y bórralo:
Ctrl + Ay luegoSupr.
👀 Debes ver: una página vacía, lista para pegar.
Paso 4. Copia y pega el código
🟢 Haz esto
- Copia todo el código del apartado «El código» (más abajo).
- Pégalo en la pestaña JavaScript con
Ctrl + V.
👀 Debes ver: un texto muy largo, con colores. No hace falta entenderlo todo.
🔴 Si no sale: si faltan líneas, borra todo y copia otra vez desde el principio hasta el final.
Paso 5. Vuelve a Bloques
🟢 Haz esto
- Pulsa Bloques, arriba en el centro.
- En la lista de la izquierda abre Avanzado y luego Funciones.
👀 Debes ver: bloques azules que empiezan por llamada. Los dos que vas a usar son llamada iniciarPantalla y llamada imprimirTemperatura. Los demás (rectangulo, dibujarCaracter…) no se tocan.
💡 Lee y predice: el código de JavaScript era larguísimo, pero solo necesitas dos bloques. ¿Para qué crees que sirve una función?
🔴 Si no sale: si MakeCode da un error, haz una captura y enséñasela al profe. No borres nada.
Paso 6. Monta el programa arrastrando
🟢 Haz esto
- Arrastra
llamada iniciarPantalladentro de al iniciar. - Arrastra
llamada imprimirTemperaturadentro de para siempre. - En Entrada, coge temperatura (°C) y suéltalo en el hueco de
imprimirTemperatura. - En Básico, coge pausa (ms) y ponlo debajo, en 1000.
👀 Debes ver: algo idéntico a esta imagen.

💡 Lee y predice: ¿por qué hay una pausa de 1000 ms (1 segundo)? ¿Qué pasaría si la quitas?
Paso 7. Descarga el programa a la micro:bit
🟢 Haz esto
- Pulsa Descargar (abajo a la izquierda).
- Si sale Emparejar ahora, púlsalo y elige BBC micro:bit CMSIS-DAP. Después, Conectar.
- Si no sale, arrastra el archivo
.hexdescargado a la unidad MICROBIT.
👀 Debes ver: la micro:bit parpadea mientras se graba, la pantalla se pone negra 2 o 3 segundos y aparece en verde la temperatura, por ejemplo 24 °C.
🔴 Si no sale
| Qué ves | Qué hacer |
|---|---|
| La pantalla sigue blanca | Pulsa el botón de reset (el de la parte trasera de la micro:bit). |
| Pantalla negra y sin luz | Empuja la micro:bit hasta el fondo. |
| Cara triste con un número | Error de memoria: comprueba que es una micro:bit V2. |
| Salen cifras sin color | Revisa que no hayas cambiado nada del código por error. |
Paso 8. Prueba que mide de verdad
🟢 Haz esto: coge la micro:bit con la mano unos segundos (sin tapar el chip de la parte trasera) y espera un par de lecturas.
👀 Debes ver: la temperatura sube un poco.
El código
Copia todo esto en la pestaña JavaScript.
// ===== Chisme 207: pantalla 1.8" GC9106 para micro:bit V2 =====
// PARTE 2 · NO LA TOQUES: trabaja por dentro para que la pantalla funcione
// Pines: DC=P12, CS=P16, RST=P8, SRAM=P2, luz=P1, SPI: SCK=P13 MOSI=P15 MISO=P14
function enviarComando(comando: number) {
pins.digitalWritePin(DigitalPin.P12, 0)
pins.digitalWritePin(DigitalPin.P16, 0)
pins.spiWrite(comando)
pins.digitalWritePin(DigitalPin.P16, 1)
}
function enviarDato(dato: number) {
pins.digitalWritePin(DigitalPin.P12, 1)
pins.digitalWritePin(DigitalPin.P16, 0)
pins.spiWrite(dato)
pins.digitalWritePin(DigitalPin.P16, 1)
}
// Dibuja un rectángulo de color (x, y = esquina; ancho y alto en píxeles)
function rectangulo(x: number, y: number, ancho: number, alto: number, rojo: number, verde: number, azul: number) {
let color = Math.idiv(rojo, 8) * 2048 + Math.idiv(verde, 4) * 32 + Math.idiv(azul, 8)
let colorAlto = Math.idiv(color, 256)
let colorBajo = color % 256
enviarComando(0x2A)
enviarDato(0)
enviarDato(x)
enviarDato(0)
enviarDato(x + ancho - 1)
enviarComando(0x2B)
enviarDato(0)
enviarDato(y)
enviarDato(0)
enviarDato(y + alto - 1)
enviarComando(0x2C)
pins.digitalWritePin(DigitalPin.P12, 1)
pins.digitalWritePin(DigitalPin.P16, 0)
for (let index = 0; index < ancho * alto; index++) {
pins.spiWrite(colorAlto)
pins.spiWrite(colorBajo)
}
pins.digitalWritePin(DigitalPin.P16, 1)
}
// Dibuja un segmento del dígito (0=arriba, 1=arriba der., 2=abajo der., 3=abajo, 4=abajo izq., 5=arriba izq., 6=medio)
function dibujarSegmento(segmento: number, x0: number, y0: number, encendido: number) {
let r = 25
let g = 25
let b = 25
if (encendido == 1) {
r = 0
g = 255
b = 0
}
if (segmento == 0) {
rectangulo(x0 + 8, y0, 18, 8, r, g, b)
} else if (segmento == 1) {
rectangulo(x0 + 26, y0 + 8, 8, 28, r, g, b)
} else if (segmento == 2) {
rectangulo(x0 + 26, y0 + 44, 8, 28, r, g, b)
} else if (segmento == 3) {
rectangulo(x0 + 8, y0 + 72, 18, 8, r, g, b)
} else if (segmento == 4) {
rectangulo(x0, y0 + 44, 8, 28, r, g, b)
} else if (segmento == 5) {
rectangulo(x0, y0 + 8, 8, 28, r, g, b)
} else {
rectangulo(x0 + 8, y0 + 36, 18, 8, r, g, b)
}
}
// Dibuja un carácter: 0 a 9 = cifras, 10 = la letra C
function dibujarCaracter(codigo: number, x0: number, y0: number) {
let mascaras = "11111100110000110110111110010110011101101110111111110000111111111110111001110"
for (let index = 0; index < 7; index++) {
if (mascaras.charAt(codigo * 7 + index) == "1") {
dibujarSegmento(index, x0, y0, 1)
} else {
dibujarSegmento(index, x0, y0, 0)
}
}
}
// ===== PARTE 1 · LO IMPORTANTE: LAS DOS FUNCIONES QUE VAS A ARRASTRAR =====
// 1) Prepara la pantalla (ponerla en "al iniciar")
function iniciarPantalla() {
pins.digitalWritePin(DigitalPin.P2, 1)
pins.digitalWritePin(DigitalPin.P1, 1)
pins.spiPins(DigitalPin.P15, DigitalPin.P14, DigitalPin.P13)
pins.spiFormat(8, 0)
pins.spiFrequency(8000000)
pins.digitalWritePin(DigitalPin.P8, 1)
basic.pause(10)
pins.digitalWritePin(DigitalPin.P8, 0)
basic.pause(10)
pins.digitalWritePin(DigitalPin.P8, 1)
basic.pause(150)
enviarComando(0xFE)
enviarComando(0xFE)
enviarComando(0xFE)
enviarComando(0xEF)
enviarComando(0xB3)
enviarDato(0x03)
enviarComando(0x36)
enviarDato(0xD8)
enviarComando(0x3A)
enviarDato(0x05)
enviarComando(0xB6)
enviarDato(0x11)
enviarComando(0xAC)
enviarDato(0x0B)
enviarComando(0xB4)
enviarDato(0x21)
enviarComando(0xB0)
enviarDato(0x00)
enviarComando(0xB2)
enviarDato(0x00)
enviarComando(0xB1)
enviarDato(0xC0)
enviarComando(0xE6)
enviarDato(0x50)
enviarDato(0x43)
enviarComando(0xFE)
enviarComando(0xFF)
enviarComando(0x35)
enviarDato(0x00)
enviarComando(0x44)
enviarDato(0x00)
enviarComando(0x11)
basic.pause(150)
enviarComando(0x29)
rectangulo(0, 0, 128, 160, 0, 0, 0)
rectangulo(80, 40, 8, 8, 0, 255, 0)
dibujarCaracter(10, 90, 40)
}
// 2) Muestra una temperatura de 0 a 99 (ponerla en "para siempre")
function imprimirTemperatura(temperatura: number) {
let t = temperatura
if (t < 0) {
t = 0
}
if (t > 99) {
t = 99
}
dibujarCaracter(Math.idiv(t, 10), 4, 40)
dibujarCaracter(t % 10, 42, 40)
}
El programa final en JavaScript, por si quieres compararlo con los bloques:
iniciarPantalla()
basic.forever(function () {
imprimirTemperatura(input.temperature())
basic.pause(1000)
})
Cómo probarlo
- Pincha la pantalla y conecta el USB.
- Graba el programa y espera a que aparezca la temperatura en verde.
- Coge la micro:bit con la mano unos segundos: ¿cuánto sube?
- Cambia la pausa a 2000: ¿qué cambia en la pantalla?
Qué estamos midiendo realmente
La micro:bit no tiene un termómetro «de aire». Mide la temperatura de su propio chip, que suele ser unos grados más alta que la del aula. Es un dato, pero no siempre una buena medida.
Además, temperatura (°C) devuelve números enteros, así que no verás decimales. Y la pantalla de este programa solo sabe escribir de 0 a 99: es una limitación del programa, no del sensor.
Para el aula
- ¿Qué variable medimos y en qué unidad?
- ¿Qué diferencia hay entre la temperatura de la pantalla y la de un termómetro de la clase? Anótala.
- ¿Cuántos rectángulos hay que dibujar para el 8? ¿Y para el 1? Mira la cadena de unos y ceros.
- ¿Por qué hay que dibujar también los segmentos apagados (en gris oscuro)?
- Si quieres guardar los datos solos, mira el datalogger con micro:bit.
Retos
2.º ESO
- Reto 1. Pon la pausa en 2000. ¿Qué cambia?
- Reto 2. Compara la pantalla con un termómetro de clase y anota la diferencia.
3.º-4.º ESO
- Reto 3 (experto). En JavaScript busca
dibujarSegmentoy cambiar = 0,g = 255,b = 0porr = 255,g = 0,b = 0. ¿De qué color salen ahora los números? (Pista: rojo, verde, azul.) - Reto 4. Haz que el color cambie según la temperatura: azul si hace frío y rojo si hace calor.
Versión monitor (para el alumnado de 1.º de Bachillerato)
Si enseñas este chisme a los pequeños, haz que antes de pegar el código comprueben que la micro:bit es V2. Pregúntales: «¿por qué el código es larguísimo pero solo usamos dos bloques?».
Qué hemos aprendido
- Hemos copiado un programa en JavaScript y MakeCode lo ha convertido en bloques.
- Una función es un trozo de programa con nombre que se arrastra como cualquier otro bloque.
- Una pantalla de color permite ver un dato real, pero medir no significa medir bien.
Para seguir investigando
- Chismes anteriores: el termómetro con micro:bit (chisme 147), el datalogger con micro:bit (chisme 150) y la pizarra de LEDs con micro:bit (chisme 24).
- Documentación oficial de micro:bit y de MakeCode.
Etiqueta:AIDARAC, funciones, ies monterroso, JavaScript, makecode, micro:bit, montesteam, pantalla de color, temperatura



