Traducido del inglés al español - www.onlinedoctranslator.

com

BBC micro:bit MicroPython

Documentación
Versión 1.0.1

Múltiples autores

13 de diciembre de 2018
 Tutoriales

1 Introducción 3
1.1 ¡Hola mundo!. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Imágenes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3 Botones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.4 Entrada/Salida. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.5 Música. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . dieciséis

1.6 Aleatorio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
1.7 Movimiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.8 Gestos ................................................. 23
1.9 Dirección. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
1.10 Almacenamiento. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
1.11 Discurso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
1.12 Red ................................................. 36
1.13 Radio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
1.14 Próximos pasos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

2 micro: bit API de Micropython 47

2.1 El módulo de microbits. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

3 Módulo de microbits 53
3.1 Funciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.2 Atributos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.3 Clases. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
3.4 Módulos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

4 Audio 75
4.1 Funciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4.2 Clases. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4.3 Uso de audio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
4.4 Detalles técnicos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
4.5 Ejemplo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

5 Bluetooth 79

6 Sistema de archivos persistente local 81

7 Máquina 83

i
 7.1 Funciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
7.2 Lectura de la memoria. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

8 MicroPython 85
8.1 Funciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

9 Música 87
9.1 Notación musical. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
9.2 Funciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

10 neopíxeles 93
10.1 Clases. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Operaciones 94
10.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Usando neopíxeles 95
10.3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ejemplo 95
10.4 ................................................. 95

11 Elsistema operativoMódulo 97
11.1 Funciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

12 Radio 99
12.1 Constantes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
12.2 Funciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

13 Generación de números aleatorios 103

13.1 Funciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

14 Discurso 105
14.1 Funciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
14.2 Puntuación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
14.3 Timbre. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
14.4 Fonemas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
14.5 Canto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
14.6 ¿Cómo funciona?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
14.7 Ejemplo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

15 veces 115
15.1 Funciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115

16 Instalación 117
16.1 Dependencias. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
16.2 Entorno de desarrollo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
16.3 Escenarios de instalación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
16.4 Próximos pasos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118

17 firmware intermitente 119

17.1 Creación de firmware............................................ 119
17.2 Preparación del firmware y un programa Python. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
17.3 Flasheo al micro:bit. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

18 Accediendo al REPL 121

18.1 Usando un programa de comunicación serial ................................. 121
18.2 Determinar el puerto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
18.3 Comunicación con el micro:bit. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

19 Archivo hexadecimal de firmware 123

19.1 Formato de script adjunto ......................................... 123

ii
 19.2 Formato UICR. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
19.3 Pasos para crear el archivo firmware.hex. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

20 preguntas frecuentes para desarrolladores 125

21 Contribuyendo 127
21.1 Lista de verificación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127

Índice del módulo Python 129

III
IV
 BBC micro:bit Documentación de MicroPython, versión 1.0.1

¡Bienvenido!

El BBC micro:bit es un pequeño dispositivo informático para niños. Uno de los lenguajes que comprende es el popular lenguaje de
programación Python. La versión de Python que se ejecuta en BBC micro:bit se llama MicroPython.

Esta documentación incluye lecciones para profesores y documentación API para desarrolladores (consulte el índice a la izquierda).
Esperamos que disfrute desarrollando para BBC micro:bit utilizando MicroPython.

Si eres un programador nuevo, profesor o no estás seguro de por dónde empezar, comienza con los tutoriales.

Para involucrarse con la comunidad suscríbase [email protected] lista de correo (https://mail.python.org/

mailman/listinfo/microbit).

Nota:Este proyecto está en desarrollo activo. Ayude a otros desarrolladores agregando sugerencias, procedimientos y preguntas y respuestas a este
documento. ¡Gracias!

Los proyectos relacionados con MicroPython en BBC micro:bit incluyen:

• mu- un editor de código sencillo para niños, profesores y programadores principiantes. Probablemente la forma más fácil para que la gente
programe MicroPython en el micro:bit de la BBC.

• flash- una herramienta de línea de comandos para flashear scripts de Python sin procesar en un micro:bit de BBC.

Tutoriales 1
BBC micro:bit Documentación de MicroPython, versión 1.0.1

2 Tutoriales
 CAPÍTULO 1

Introducción

Le sugerimos descargar y utilizar eleditor mual trabajar en estos tutoriales. Las instrucciones para descargar e instalar Mu se encuentran en su
sitio web. Es posible que necesites instalar un controlador, dependiendo de tu plataforma (las instrucciones se encuentran en el sitio web).

Mu funciona con Windows, OSX y Linux.

Una vez que Mu esté instalado, conecta tu micro:bit a tu computadora mediante un cable USB.

Escribe tu script en la ventana del editor y haz clic en el botón "Flash" para transferirlo al micro:bit. Si no funciona, asegúrese de que su
micro:bit aparezca como un dispositivo de almacenamiento USB en el explorador de su sistema de archivos.

1.1 ¡Hola mundo!

La forma tradicional de empezar a programar en un nuevo lenguaje es hacer que su computadora diga "¡Hola, mundo!".

Esto es fácil con MicroPython:

demicrobitimportar* mostrar.
Desplazarse("¡Hola Mundo!")

Cada línea hace algo especial. La primera línea:

demicrobitimportar*

. . . le dice a MicroPython que obtenga todo lo que necesita para funcionar con BBC micro:bit. Todo esto está en un módulo llamado
microbit (un módulo es una biblioteca de código preexistente). Cuando ustedimportaralgo le estás diciendo a MicroPython que
quieres usarlo, y * es la forma en que Python lo dicetodo. Entonces,de importación de microbits *significa, en inglés, “Quiero poder
usar todo lo que hay en la biblioteca de códigos de microbits”.

La segunda línea:

3
BBC micro:bit Documentación de MicroPython, versión 1.0.1

mostrar.Desplazarse("¡Hola Mundo!")

. . . le dice a MicroPython que use la pantalla para desplazar la cadena de caracteres "¡Hola, mundo!". Elmostrarparte de esa
línea es unobjetodesde elmicrobitmódulo que representa la pantalla física del dispositivo (decimos "objeto" en lugar de
"cosa", "qué" o "doodah"). Podemos decirle a la pantalla que haga cosas con un punto. seguido de lo que parece un
comando (de hecho, es algo que llamamosmétodo). En este caso estamos usando elDesplazarsemétodo. DesdeDesplazarse
necesita saber qué caracteres desplazar por la pantalla física, los especificamos entre comillas dobles (") entre paréntesis
(( y )). Estos se denominan caracteresargumentos. Entonces,display.scroll("¡Hola mundo!")significa, en inglés, “Quiero que
uses la pantalla para desplazar el texto '¡Hola, mundo!'”. Si un método no necesita ningún argumento, lo dejamos claro
usando paréntesis vacíos como este: ().

Copie el mensaje "¡Hola, mundo!" código en su editor y actualícelo en el dispositivo. ¿Puedes averiguar cómo cambiar el mensaje?
¿Puedes hacer que te salude? Por ejemplo, podría hacer que diga "¡Hola, Nicholas!". Aquí tienes una pista: necesitas cambiar el
argumento del método de desplazamiento.

Advertencia:Puede que no funcione. :-)

Aquí es donde las cosas se ponen divertidas y MicroPython intenta ser útil. Si encuentra un error, mostrará un mensaje
útil en la pantalla del micro:bit. Si puede, le indicará el número de línea donde se puede encontrar el error.

Python espera que escribasEXACTAMENTELo correcto. Así, por ejemplo,microbit, microbitymicroBit son cosas
diferentes a Python. Si MicroPython se queja de unNombreErrorProbablemente se deba a que has escrito algo de
forma incorrecta. Es como la diferencia entre referirse a “Nicholas” y “Nicolas”. Son dos personas diferentes pero
sus nombres se parecen mucho.

Si MicroPython se queja de unError de sintaxissimplemente ha escrito código de una manera que MicroPython no puede
entender. Comprueba que no te falta ningún carácter especial como " o :. Es como poner. un punto en medio de una
frase. Es difícil entender exactamente lo que quieres decir.

Es posible que su microbit deje de responder: no puede mostrarle un código nuevo ni ingresar comandos en el REPL. Si esto
sucede, intente reiniciarlo. Es decir, desconecte el cable USB (y el cable de la batería si está conectado) y luego vuelva a enchufar
el cable. Es posible que también deba cerrar y reiniciar su aplicación de edición de código.

1.2 Imágenes

MicroPython es tan bueno en el arte como usted puede ser si lo único que tiene es una cuadrícula de 5x5 de LED rojos (diodos
emisores de luz, las cosas que se iluminan en la parte frontal del dispositivo). MicroPython te brinda bastante control sobre la
pantalla para que puedas crear todo tipo de efectos interesantes.

MicroPython viene con muchas imágenes integradas para mostrar en la pantalla. Por ejemplo, para que el dispositivo parezca feliz,
escribe:

demicrobitimportar* mostrar.
mostrar imagen.FELIZ)

Sospecho que puedes recordar lo que hace la primera línea. La segunda línea utiliza elmostraroponerse aespectáculouna imagen
incorporada. La imagen feliz que queremos mostrar es parte delImagenobjeto y llamadoFELIZ.Nosotros decimosespectáculopara
usarlo poniéndolo entre paréntesis (( y )).

4 Capítulo 1 Introducción
 BBC micro:bit Documentación de MicroPython, versión 1.0.1

Aquí hay una lista de las imágenes integradas:

• Imagen.CORAZÓN

• Imagen.HEART_SMALL
• Imagen.FELIZ
• Imagen.SONRISA

• Imagen.SAD
• Imagen.CONFUNDIDA

• Imagen.ENOJADO

• Imagen.ASLEEP
• Imagen.SORPRENDIDO

• Imagen.TONTA
• Imagen.FABULOSA
• Imagen.MEH
• Imagen.SÍ
• Imagen.NO
• Imagen.CLOCK12, Imagen.CLOCK11, Imagen.CLOCK10, Imagen.CLOCK9, Imagen.CLOCK8, Imagen.
RELOJ7, Imagen.RELOJ6, Imagen.RELOJ5, Imagen.RELOJ4, Imagen.RELOJ3, Imagen.RELOJ2,

1.2. Imágenes 5
BBC micro:bit Documentación de MicroPython, versión 1.0.1

Imagen.CLOCK1
• Imagen.ARROW_N, Imagen.ARROW_NE, Imagen.ARROW_E, Imagen.ARROW_SE, Imagen.ARROW_S,
Imagen.ARROW_SW, Imagen.ARROW_W, Imagen.ARROW_NW
• Imagen.TRIÁNGULO
• Imagen.TRIANGLE_LEFT
• Imagen.TABLERO DE AJEDREZ

• Imagen.DIAMOND
• Imagen.DIAMOND_SMALL
• Imagen.CUADRADO

• Imagen.SQUARE_SMALL
• Imagen.CONEJO
• Imagen.COW

• Imagen.MUSIC_CROTCHET
• Imagen.MUSIC_QUAVER
• Imagen.MUSIC_QUAVERS
• Imagen.PITCHFORK
• Imagen.XMAS
• Imagen.PACMAN
• Imagen.OBJETIVO

• Imagen.CAMISETA

• Imagen.ROLLERSKATE
• Imagen.PATO
• Imagen.CASA
• Imagen.TORTUGA
• Imagen.MARIPOSA
• Imagen.STICKFIGURE
• Imagen. FANTASMA

• Imagen.ESPADA

• Imagen.JIRAFA
• Imagen.CRÁNEO

• Imagen.PARAGUAS
• Imagen.SERPIENTE

¡Hay bastantes! ¿Por qué no modificar el código que hace que el micro:bit parezca feliz al ver cómo lucen algunas de las otras imágenes
integradas? (Simplemente reemplaceImagen.FELIZcon una de las imágenes integradas enumeradas arriba.)

6 Capítulo 1 Introducción
 BBC micro:bit Documentación de MicroPython, versión 1.0.1

1.2.1 Imágenes de bricolaje

Por supuesto, quieres crear tu propia imagen para mostrarla en el micro:bit, ¿verdad?

Eso es fácil.

Cada píxel LED de la pantalla física se puede configurar en uno de diez valores. Si un píxel está configurado en0 (cero) entonces está apagado.
Literalmente tiene cero brillo. Sin embargo, si se establece en9entonces está en su nivel más brillante. Los valores1a8representan los niveles
de brillo entre apagado (0)y de lleno (9).

Armado con esta información, es posible crear una nueva imagen como esta:

demicrobitimportar*

bote=Imagen("05050:"
"05050:"
"05050:"
"99999:"
"09990")

mostrar.barco con teatro a bordo)

(Cuando se ejecuta, el dispositivo debería mostrar un antiguo velero “Blue Peter” con los mástiles más tenues que el casco del barco).

¿Has descubierto cómo hacer un dibujo? ¿Ha notado que cada línea de la pantalla física está representada por una línea de
números que termina en : y entre comillas dobles "? Cada número especifica un brillo. Hay cinco líneas de cinco números,
por lo que es posible especificar el brillo individual para cada de los cinco píxeles en cada una de las cinco líneas de la
pantalla física. Así es como se crea una nueva imagen.

¡Simple!

De hecho, no es necesario que escriba esto en varias líneas. Si crees que puedes realizar un seguimiento de cada línea, puedes reescribirla así:

bote=Imagen("05050:05050:05050:99999:09990")

1.2.2 Animación

Las imágenes estáticas son divertidas, pero lo es aún más hacer que se muevan. Esto también es increíblemente sencillo de hacer con MicroPython: ¡solo
usa una lista de imágenes!

Aquí hay una lista de compras:

Huevos
Tocino
Tomates

Así es como representarías esta lista en Python:

compras=["Huevos","Tocino","Tomates"]

Simplemente he creado una lista llamadacomprasy contiene tres elementos. Python sabe que es una lista porque
está entre corchetes ([ y ]). Los elementos de la lista están separados por una coma (,) y en este caso los elementos
son tres cadenas de caracteres: "Huevos", "Tocino"y "Tomates".Sabemos que son cadenas de caracteres porque están
entre comillas ".

Puedes almacenar cualquier cosa en una lista con Python. Aquí hay una lista de números:

1.2. Imágenes 7
BBC micro:bit Documentación de MicroPython, versión 1.0.1

primos=[2,3,5,7,11,13,17,19]

Nota:No es necesario citar los números ya que representan un valor (en lugar de una cadena de caracteres). Es la diferencia
entre2 (el valor numérico 2) y "2" (el carácter/dígito que representa el número 2). No te preocupes si esto no tiene sentido en
este momento. Pronto te acostumbrarás.

Incluso es posible almacenar diferentes tipos de cosas en la misma lista:

lista_mixta=["¡Hola!",1.234, Imagen.FELIZ]

¿Notas ese último elemento? ¡Era una imagen!

Podemos decirle a MicroPython que anime una lista de imágenes. Afortunadamente, ya tenemos un par de listas de
imágenes integradas. Se llamanImagen.ALL_CLOCKSyImagen.ALL_ARROWS:

demicrobitimportar*

mostrar.mostrar imagen.ALL_CLOCKS, bucle=Verdadero, demora=100)

Al igual que con una sola imagen, utilizamosmostrar.mostrarpara mostrarlo en la pantalla del dispositivo. Sin embargo, le decimos a
MicroPython que useImagen.ALL_CLOCKSy entiende que necesita mostrar cada imagen de la lista, una tras otra. También le decimos
a MicroPython que siga recorriendo la lista de imágenes (para que la animación dure para siempre) diciendobucle = Verdadero.
Además le decimos que queremos que el retraso entre cada imagen sea de sólo 100 milisegundos (una décima de segundo) con el
argumentoretraso = 100.

¿Puedes descubrir cómo animar sobre elImagen.ALL_ARROWS¿lista? ¿Cómo se puede evitar un bucle indefinido (pista: lo
contrario deVerdaderoesFALSOaunque el valor predeterminado parabucleesFALSO)?¿Puedes cambiar la velocidad de la
animación?

Finalmente, aquí te explicamos cómo crear tu propia animación. En mi ejemplo, voy a hacer que mi barco se hunda en la parte inferior de la
pantalla:

demicrobitimportar*

barco1=Imagen("05050:"
"05050:"
"05050:"
"99999:"
"09990")

barco2=Imagen("00000:"
"05050:"
"05050:"
"05050:"
"99999")

barco3=Imagen("00000:"
"00000:"
"05050:"
"05050:"
"05050")

barco4=Imagen("00000:"
"00000:"
"00000:"
"05050:"
(continúa en la página siguiente)

8 Capítulo 1 Introducción
 BBC micro:bit Documentación de MicroPython, versión 1.0.1

(Continuación de la página anterior)

"05050")

barco5=Imagen("00000:"
"00000:"
"00000:"
"00000:"
"05050")

barco6=Imagen("00000:"
"00000:"
"00000:"
"00000:"
"00000")

todos_barcos=[barco1, barco2, barco3, barco4, barco5, barco6]

visualización.mostrar(todos_barcos, retraso=200)

Así es como funciona el código:

• Creo seisboteimágenes exactamente de la misma manera que describí anteriormente.

• Luego, los pongo a todos en una lista a la que llamotodos_barcos.

• Finalmente, preguntomostrar.mostrarpara animar la lista con un retraso de 200 milisegundos.

• Como no lo he configuradobucle = Verdaderoel barco sólo se hundirá una vez (haciendo así que mi animación sea científicamente precisa). :-)

¿Qué animarías? ¿Puedes animar efectos especiales? ¿Cómo harías para que una imagen se desvanezca y luego vuelva a aparecer?

1.3 Botones

Hasta ahora hemos creado un código que hace que el dispositivo haga algo. Se llamaproducción. Sin embargo, también necesitamos que el dispositivo
reaccione a las cosas. A esas cosas se les llamaentradas.

Es fácil de recordar: la salida es lo que el dispositivo envía al mundo, mientras que la entrada es lo que ingresa al dispositivo para que lo
procese.

El medio de entrada más obvio en el micro:bit son sus dos botones, etiquetadosAyB.De alguna manera, necesitamos que MicroPython
reaccione al presionar botones.

Esto es notablemente simple:

demicrobitimportar*

dormir(10000)
mostrar.Desplazarse(cadena(botón_a.get_presses()))

Todo lo que hace este script es dormir durante diez mil milisegundos (es decir, 10 segundos) y luego desplazarse por el número de veces que presionó el
botón.A.¡Eso es todo!

Si bien es un script bastante inútil, introduce un par de ideas nuevas e interesantes:

1. Eldormirfunciónhará que el micro:bit duerma durante una cierta cantidad de milisegundos. Si desea una pausa en su
programa, así es como se hace. Afunciónes como unmétodo, pero no está unido por un punto a unobjeto.

1.3. Botones 9
BBC micro:bit Documentación de MicroPython, versión 1.0.1

2. Hay un objeto llamadobotón_ay permite obtener el número de veces que se ha pulsado con el
get_pressesmétodo.
Desdeget_pressesda un valor numérico ypantalla.desplazamientosolo muestra caracteres, necesitamos convertir el valor
numérico en una cadena de caracteres. Hacemos esto con elcadenafunción (abreviatura de “cadena” ~ convierte cosas en
cadenas de caracteres).

La tercera línea se parece un poco a una cebolla. Si el paréntesis son las pieles de cebolla entonces notarás que
pantalla.desplazamiento contienecadenaque en si mismo contienebutton_a.get_presses.Python intenta resolver primero la respuesta
más interna antes de comenzar con la siguiente capa. Se llamaanidando-el equivalente codificado de una muñeca rusa Matrioshka.

Supongamos que has presionado el botón 10 veces. Así es como Python resuelve lo que sucede en la tercera línea:

Python ve la línea completa y obtiene el valor deget_presses:

mostrar.Desplazarse(cadena(botón_a.get_presses()))

Ahora que Python sabe cuántas pulsaciones de botones se han producido, convierte el valor numérico en una cadena de
caracteres:

mostrar.Desplazarse(cadena(10))

Finalmente, Python sabe qué desplazarse por la pantalla:

mostrar.Desplazarse("10")

Si bien esto puede parecer mucho trabajo, MicroPython hace que esto suceda extraordinariamente rápido.

1.3.1 Bucles de eventos

A menudo necesita que su programa permanezca esperando a que suceda algo. Para hacer esto, haga que recorra un fragmento de
código que define cómo reaccionar ante ciertos eventos esperados, como presionar un botón.

Para hacer bucles en Python se utiliza elmientraspalabra clave. Comprueba si algo estáVerdadero.Si es así, ejecuta unbloque
de código llamó alcuerpodel bucle. Si no es así, se sale del bucle (ignorando el cuerpo) y el resto del programa puede
continuar.

10 Capítulo 1 Introducción
 BBC micro:bit Documentación de MicroPython, versión 1.0.1

Python facilita la definición de bloques de código. Digamos que tengo una lista de tareas pendientes escrita en una hoja de papel.
Probablemente se vea así:

Compras
Reparar canalón roto
Cortar el césped

Si quisiera desglosar un poco más mi lista de tareas pendientes, podría escribir algo como esto:

Compras:
Huevos
Tocino
Tomates
Reparar canalón roto:
escalera de préstamodepróximopuerta
encontrar martilloyclavos escalera de
retorno
Cortar el césped:
Revisar el césped alrededor del estanquepararanas Compruebe el
nivel de combustible del cortacésped

Es obvio que las tareas principales se dividen en subtareas que sonsangradodebajo de la tarea principal con la que están
relacionados. Entonceshuevos, tocinoyTomatesobviamente están relacionados conCompras.Al sangrar las cosas, facilitamos
ver, de un vistazo, cómo se relacionan las tareas entre sí.

Se llamaanidando. Usamos anidamiento para definir bloques de código como este:

demicrobitimportar*

mientrastiempo de ejecución()<10000:
mostrar.mostrar imagen.DORMIDO)

mostrar.mostrar imagen.SORPRENDIDO)

Eltiempo de ejecuciónLa función devuelve el número de milisegundos desde que se inició el dispositivo.

Elmientras se ejecuta_time() <10000:La línea comprueba si el tiempo de ejecución es inferior a 10000 milisegundos (es decir, 10 segundos). Si
esto es,y aquí es donde podemos ver el alcance en acción, entonces se mostraráImagen.DORMIENDO.Observe cómo esto está sangrado
debajo delmientrasdeclaracióncomo en nuestra lista de tareas pendientes.

Obviamente, si el tiempo de funcionamiento es igual o superior a 10000 milisegundos, la pantalla mostraráImagen. SORPRENDIDO.
¿Por qué? Porque elmientrasla condición será Falsa (tiempo de ejecuciónya no es <10000).En ese caso, el ciclo finaliza y el programa
continuará después delmientrasbloque de código del bucle. Parecerá que su dispositivo está dormido durante 10 segundos antes de
despertarse con una expresión de sorpresa en su rostro.

¡Intentalo!

1.3.2 Manejo de un evento

Si queremos que MicroPython reaccione a los eventos de pulsación de botones, debemos ponerlo en un bucle infinito y comprobar si el botón
se presiona.

Un bucle infinito es fácil:

mientras que verdadero:

# Hacer cosas

1.3. Botones 11
BBC micro:bit Documentación de MicroPython, versión 1.0.1

(Recordar,mientrascomprueba si algo estáVerdaderopara determinar si debe ejecutar su bloque de código. DesdeVerdaderoes obviamente
Verdaderopara siempre, ¡obtienes un bucle infinito!)

Hagamos una cibermascota muy sencilla. Siempre es triste a menos que presiones el botónA.Si presionas el botónBse muere. (Me doy cuenta
de que este no es un juego muy agradable, así que tal vez puedas descubrir cómo mejorarlo):

demicrobitimportar*

mientras que verdadero:

sibotón_a.se presiona():
mostrar.mostrar imagen.FELIZ)
elifbotón_b.se presiona():
romper
demás:
mostrar.mostrar imagen.TRISTE)

mostrar.claro()

¿Puedes ver cómo comprobamos qué botones están presionados? Nosotros usamossi, elif (abreviatura de "si no") ydemás.estos se
llamancondicionalesy funciona así:

sialgoes verdad:
# Haz una cosa
elifalguna otra cosaes verdad:
# hacer otra cosa
demás:
# haz otra cosa más.

¡Esto es notablemente similar al inglés!

Else presionaEl método solo produce dos resultados:VerdaderooFALSO.Si estás presionando el botón, regresa.Verdadero, de lo
contrario regresaFALSO.El código anterior dice, en inglés, "para siempre jamás, si se presiona el botón A, muestra una cara feliz; de
lo contrario, si se presiona el botón B, sal del bucle; de lo contrario, muestra una cara triste". Salimos del bucle (detenemos el
programa ejecutándose para siempre) con elromperdeclaración.

Al final, cuando la cibermascota esté muerta,clarola pantalla.

¿Se te ocurre alguna forma de hacer que este juego sea menos trágico? ¿Cómo comprobarías siambos¿Se presionan los botones? (Pista:
Python tieney, oynooperadores lógicos para ayudar a verificar múltiples declaraciones de verdad (cosas que producenVerdaderoo FALSO
resultados).

1.4 Entrada/Salida

Hay tiras de metal a lo largo del borde inferior del BBC micro:bit que hacen que parezca que el dispositivo tiene dientes. Estos son los pines de
entrada/salida (o pines de E/S para abreviar).

12 Capítulo 1 Introducción
 BBC micro:bit Documentación de MicroPython, versión 1.0.1

Algunos de los pines son más grandes que otros, por lo que es posible colocarles pinzas de cocodrilo. Estos son los que están etiquetados
como 0, 1, 2, 3V y GND (las computadoras siempre comienzan a contar desde cero). Si conecta una placa de conector de borde al dispositivo,
es posible enchufar cables conectados a las otras clavijas (más pequeñas).

Cada pin del micro:bit de la BBC está representado por unobjetollamadopinNdóndenortees el número de pin. Entonces, por ejemplo,
para hacer cosas con el pin etiquetado con un 0 (cero), use el objeto llamadopin0.

¡Simple!

Estos objetos tienen variosmétodosasociados con ellos dependiendo de lo que el pin específico sea capaz de hacer.

1.4.1 Python cosquilloso

El ejemplo más simple de entrada a través de los pines es verificar si se tocan. Entonces, puedes hacerle cosquillas a tu dispositivo para
hacerlo reír así:

demicrobitimportar*

mientras que verdadero:

sipin0.está_tocado():
mostrar.mostrar imagen.FELIZ)
demás:
mostrar.mostrar imagen.TRISTE)

Con una mano, sostenga su dispositivo por el pin GND. Luego, con la otra mano, toque (o haga cosquillas) el pin 0 (cero). ¡Deberías
ver cómo la pantalla cambia de mal humor a feliz!

1.4. De entrada y salida 13

BBC micro:bit Documentación de MicroPython, versión 1.0.1

Esta es una forma de medición de entrada muy básica. Sin embargo, la diversión realmente comienza cuando conectas circuitos y otros dispositivos a
través de los pines.

1.4.2 Pitidos y bloops

Lo más sencillo que podemos conectar al dispositivo es un zumbador piezoeléctrico. Lo usaremos para la salida.

Estos pequeños dispositivos emiten un pitido agudo cuando se conectan a un circuito. Para conectar uno a su BBC micro:bit, debe conectar
pinzas de cocodrilo al pin 0 y GND (como se muestra a continuación).

14 Capítulo 1 Introducción
 BBC micro:bit Documentación de MicroPython, versión 1.0.1

El cable del pin 0 debe conectarse al conector positivo del timbre y el cable de GND al conector negativo.

El siguiente programa hará que el timbre emita un sonido:

demicrobitimportar*

pin0.escribir_digital(1)

Esto es divertido durante unos 5 segundos y luego querrás detener el horrible chirrido. Mejoremos nuestro ejemplo y hagamos que el
dispositivo emita un pitido:

demicrobitimportar*

mientras que verdadero:

(continúa en la página siguiente)

1.4. De entrada y salida 15

BBC micro:bit Documentación de MicroPython, versión 1.0.1

(Continuación de la página anterior)

pin0.escribir_digital(1)
dormir(20)
pin0.escribir_digital(0)
dormir(480)

¿Puedes averiguar cómo funciona este script? Recuerda eso1está “encendido” y0está “apagado” en el mundo digital.

El dispositivo se coloca en un bucle infinito e inmediatamente activa el pin 0. Esto hace que el timbre emita un pitido. Mientras suena
el timbre, el dispositivo duerme durante veinte milisegundos y luego apaga el pin 0. Esto produce el efecto de un pitido corto.
Finalmente, el dispositivo duerme durante 480 milisegundos antes de retroceder y comenzar de nuevo. Esto significa que escucharás
dos pitidos por segundo (uno cada 500 milisegundos).

¡Hemos hecho un metrónomo muy simple!

1.5 Música

MicroPython en BBC micro:bit viene con un potente módulo de música y sonido. Es muy fácil generar pitidos y bloops
desde el dispositivo.si adjuntas un altavoz. Utilice pinzas de cocodrilo para conectar el pin 0 y GND a las entradas
positiva y negativa del altavoz; no importa en qué dirección estén conectadas al altavoz.

dieciséis Capítulo 1 Introducción

 BBC micro:bit Documentación de MicroPython, versión 1.0.1

Nota:No intente esto con un zumbador piezoeléctrico; dichos zumbadores solo pueden reproducir un tono.

Pongamos algo de música:

importarmúsica

música.reproducir música.NYAN)

Observe que importamos elmúsicamódulo. Contiene métodos utilizados para producir y controlar el sonido.

MicroPython tiene muchas melodías integradas. Aquí hay una lista completa:

• musica.DADADADUM
• musica.ENTRETENEDOR

1.5. Música 17
BBC micro:bit Documentación de MicroPython, versión 1.0.1

• musica.PRELUDE
• musica.ODE
• musica.NYAN
• música.TONO
• musica.FUNK
• musica.BLUES
• musica.cumpleaños
• musica.BODAS
• musica.FUNERAL
• música.PUNCHLINE
• musica.PYTHON
• musica.BADDY
• musica.CHASE
• música.BA_DING
• música.WAWAWAWAA

• música.JUMP_UP
• música.JUMP_DOWN
• música.POWER_UP
• música.POWER_DOWN
Tome el código de ejemplo y cambie la melodía. ¿Cual es tu favorito? ¿Cómo usarías esas melodías como señales o
pistas?

1.5.1 Microbit de Wolfgang Amadeus

¡Crear tus propias melodías es fácil!

Cada nota tiene un nombre (comoC#oF),una octava (que le indica a MicroPython qué tan alta o baja debe tocarse la nota) y una
duración (cuánto dura en el tiempo). Las octavas se indican con un número: 0 es la octava más baja, 4 contiene el do medio y 8 es el
nivel más alto que necesitarás a menos que estés haciendo música para perros. Las duraciones también se expresan en números.
Cuanto mayor sea el valor de la duración, más durará. Estos valores están relacionados entre sí; por ejemplo, una duración de4
durará el doble que una duración2 (etcétera). Si usa el nombre de la notaRluego MicroPython reproducirá un descanso (es decir,
silencio) durante el tiempo especificado.

Cada nota se expresa como una cadena de caracteres como esta:

NOTA[octava][:duración]

Por ejemplo, "A1:4"se refiere a la nota nombradaAen número de octava1que se jugará durante un período de4.

Haz una lista de notas para crear una melodía (equivale a crear una animación con una lista de imágenes). Por ejemplo, aquí se explica cómo
hacer que MicroPython reproduzca la apertura de “Frere Jaques”:

18 Capítulo 1 Introducción
 BBC micro:bit Documentación de MicroPython, versión 1.0.1

importarmúsica

melodía=["C4:4","D4:4","E4:4","C4:4","C4:4","D4:4","E4:4","C4:4",
"E4:4","F4:4","G4:8","E4:4","F4:4","G4:8"] música.reproducir
(melodía)

Nota:MicroPython te ayuda a simplificar este tipo de melodías. Recordará los valores de octava y duración hasta que los cambies la próxima
vez. Como resultado, el ejemplo anterior se puede reescribir como:

importarmúsica

melodía=["C4:4","D","MI","C","C","D","MI","C","MI","F","G:8",
"E:4","F","G:8"] música.
reproducir (melodía)

Observe cómo los valores de octava y duración solo cambian cuando es necesario. Se escribe mucho menos y es más sencillo de leer.

1.5.2 Efectos de sonido

MicroPython te permite crear tonos que no son notas musicales. Por ejemplo, aquí se explica cómo crear un efecto de sirena de policía:

importarmúsica

mientras que verdadero:

parafrecuenciaenrango(880,1760,dieciséis):
música.tono (frecuencia,6)
parafrecuenciaenrango(1760,880,-dieciséis):
música.tono (frecuencia,6)

Observe cómo eltono.musicalmétodose utiliza en este caso. Espera una frecuencia. Por ejemplo, la frecuencia de440es lo
mismo que un conciertoASe utiliza para afinar una orquesta sinfónica.

En el ejemplo anterior elrangoLa función se utiliza para generar rangos de valores numéricos. Estos números se utilizan para
definir el tono del tono. Los tres argumentos a favor de larangoLa función son el valor inicial, el valor final y el tamaño del
paso. Por lo tanto, el primer uso derangodice, en inglés, “crea un rango de números entre 880 y 1760 en pasos de 16”. El
segundo uso derangoestá diciendo, "cree un rango de valores entre 1760 y 880 en pasos de -16". Así es como obtenemos un
rango de frecuencias que suben y bajan de tono como una sirena.

Porque la sirena debería durar para siempre, está envuelta en un infinitomientrasbucle.

Es importante destacar que hemos introducido un nuevo tipo de bucle dentro delmientrasbucle: elparabucle. En inglés es como decir “para
cada elemento de alguna colección, haz alguna actividad con él”. Específicamente en el ejemplo anterior, dice: "para cada frecuencia en el
rango de frecuencias especificado, reproduzca el tono de esa frecuencia durante 6 milisegundos". Observe cómo se sangra lo que se debe
hacer para cada elemento en un bucle for (como se analizó anteriormente) para que Python sepa exactamente qué código ejecutar para
manejar los elementos individuales.

1.6 Aleatorio

A veces quieres dejar las cosas al azar o mezclarlas un poco: quieres que el dispositivo actúe de forma aleatoria.

MicroPython viene con unaleatoriomódulo para facilitar la introducción de azar y un poco de caos en su código. Por ejemplo, aquí se
explica cómo desplazar un nombre aleatorio por la pantalla:

1.6. Aleatorio 19
BBC micro:bit Documentación de MicroPython, versión 1.0.1

demicrobitimportar*
importaraleatorio

nombres=["María","Yolanda","Damián","Alía","kushal","Mei Xiu","Zoltán"]

mostrar.desplazamiento (aleatorio.elección (nombres))

La lista (nombres)Contiene siete nombres definidos como cadenas de caracteres. La línea final esanidado(el efecto “cebolla”
introducido anteriormente): elelección.aleatoriaEl método toma elnombreslist como argumento y devuelve un elemento elegido al
azar. Este elemento (el nombre elegido al azar) es el argumento a favormostrar.desplazamiento.

¿Puedes modificar la lista para incluir tu propio conjunto de nombres?

1.6.1 Números aleatorios

Los números aleatorios son muy útiles. Son comunes en los juegos. ¿Por qué más tenemos dados?

MicroPython viene con varios métodos útiles de números aleatorios. Aquí se explica cómo hacer un dado simple:

demicrobitimportar*
importaraleatorio

mostrar.espectáculo(cadena(aleatorio.randint(1,6)))

Cada vez que se reinicia el dispositivo muestra un número entre 1 y 6. Estás empezando a familiarizarte conanidando, por lo que es
importante tener en cuenta quealeatorio.randintdevuelve un número entero entre los dos argumentos, inclusive (un número entero
también se llama entero, de ahí el nombre del método). Note que porquemostrar.mostrarespera un carácter entonces usamos el
cadenafunción para convertir el valor numérico en un carácter (convertimos, por ejemplo,6en "6").

Si sabes que siempre querrás un número entre0ynorteluego usa elaleatorio.randrangemétodo. Si le da un solo argumento,
devolverá números enteros aleatorios hasta el valor del argumento, pero sin incluirlo.norte (Esto es diferente al
comportamiento dealeatorio.randint).

A veces necesitas números con un punto decimal. estos se llamanFloridapunto flotantenúmeros y es posible generar
dicho número con elaleatorio.aleatoriométodo. Esto sólo devuelve valores entre0.0y1.0 inclusivo. Si necesita números
de punto flotante aleatorios más grandes, agregue los resultados dealeatorio.randrangeyaleatorio. aleatoriocomo
esto:

demicrobitimportar*
importaraleatorio

respuesta=aleatorio.rango rand(100)+aleatorio.visualización
aleatoria ().Desplazarse(cadena(respuesta))

1.6.2 Semillas del Caos

Los generadores de números aleatorios que utilizan las computadoras no son verdaderamente aleatorios. Simplemente dan resultados
aleatorios dado un punto inicial.semillavalor. La semilla a menudo se genera a partir de valores aleatorios, como la hora actual y/o lecturas de
sensores como los termómetros integrados en chips.

A veces desea tener un comportamiento aleatorio repetible: una fuente de aleatoriedad que sea reproducible. Es como decir que
necesitas los mismos cinco valores aleatorios cada vez que lanzas un dado.

Esto es fácil de lograr configurando elsemillavalor. Dada una semilla conocida, el generador de números aleatorios creará el mismo
conjunto de números aleatorios. La semilla se fija conSemilla aleatoriay cualquier número entero (entero). Esta versión del programa
de dados siempre produce los mismos resultados:

20 Capítulo 1 Introducción
 BBC micro:bit Documentación de MicroPython, versión 1.0.1

demicrobitimportar*
importaraleatorio

aleatorio.semilla(1337) mientras
que verdadero:
sibotón_a.estaba_presionado():
mostrar.espectáculo(cadena(aleatorio.randint(1,6)))

¿Puedes entender por qué este programa necesita que presionemos el botón A en lugar de reiniciar el dispositivo como en el primer ejemplo de dados?

1.7 Movimiento

Tu BBC micro:bit viene con un acelerómetro. Mide el movimiento a lo largo de tres ejes:

• X: inclinación de izquierda a derecha.

• Y - inclinación hacia adelante y hacia atrás.

• Z - moviéndose hacia arriba y hacia abajo.

Existe un método para cada eje que devuelve un número positivo o negativo que indica una medida en miligramos. Cuando la
lectura es 0, estás "nivelado" a lo largo de ese eje en particular.

Por ejemplo, aquí hay un nivel de burbuja muy simple que usaobtener_xpara medir qué nivel está el dispositivo a lo largo del eje X:

demicrobitimportar*

mientras que verdadero:

lectura=acelerómetro.obtener_x() si
lectura>20:
mostrar.espectáculo(
"R") eliflectura< -20:
mostrar.espectáculo("L")
demás:
mostrar.espectáculo("-")

Si sostiene el dispositivo en posición horizontal, debería mostrar -; sin embargo, gírelo hacia la izquierda o hacia la derecha y se mostrarályRrespectivamente.

Queremos que el dispositivo reaccione constantemente al cambio, por eso utilizamos un infinitomientrasbucle. Lo primero
que sucededentro del cuerpo del buclees una medida a lo largo del eje X que se llamalectura.Porque el acelerómetro es
entoncessensible He hecho el nivel +/-20 en el rango. Es por eso que elsiyelifcomprobar condicionales para >20y <-20. El
demásdeclaración significa que si ellecturaestá entre -20 y 20 entonces lo consideramos nivelado. Para cada una de estas
condiciones utilizamos la pantalla para mostrar el carácter apropiado.

También hay unaobtener_ymétodo para el eje Y y unobtener_zMétodo para el eje Z.

Si alguna vez te has preguntado cómo sabe un teléfono móvil dónde mostrar las imágenes en su pantalla es porque utiliza un acelerómetro
exactamente de la misma forma que el programa anterior. Los controladores de juegos también contienen acelerómetros para ayudarte a
conducir y moverte en los juegos.

1.7.1 Caos musical

Uno de los aspectos más maravillosos de MicroPython en BBC micro:bit es cómo te permite vincular fácilmente diferentes
capacidades del dispositivo. Por ejemplo, convirtámoslo en una especie de instrumento musical.

Conecte un altavoz como lo hizo en el tutorial de música. Utilice pinzas de cocodrilo para conectar el pin 0 y GND a las
entradas positiva y negativa del altavoz; no importa en qué dirección estén conectadas al altavoz.

1.7. Movimiento 21
BBC micro:bit Documentación de MicroPython, versión 1.0.1

¿Qué pasa si tomamos las lecturas del acelerómetro y las reproducimos como lanzamientos? Vamos a averiguar:

demicrobitimportar*
importarmúsica

mientras que verdadero:

música.tono (acelerómetro.get_y(),10)

La línea clave está al final y es notablemente simple. Nosotrosnidola lectura del eje Y como la frecuencia para alimentar el
tono.musicalmétodo. Sólo lo dejamos sonar durante 10 milisegundos porque queremos que el tono cambie rápidamente cuando se
inclina el dispositivo. Porque el dispositivo está en un infinito.mientrasEl bucle reacciona constantemente a los cambios en la
medición del eje Y.

¡Eso es todo!

Incline el dispositivo hacia adelante y hacia atrás. Si la lectura a lo largo del eje Y es positiva, cambiará el tono del tono.

22 Capítulo 1 Introducción
 BBC micro:bit Documentación de MicroPython, versión 1.0.1

jugado por el micro:bit.

Imagínese toda una orquesta sinfónica de estos dispositivos. ¿Puedes tocar una melodía? ¿Cómo mejorarías el programa
para que el micro:bit suene más musical?

1.8 Gestos

El efecto secundario realmente interesante de tener un acelerómetro es la detección de gestos. Si mueve su BBC micro:bit de
cierta manera (como un gesto), MicroPython podrá detectarlo.

MicroPython es capaz de reconocer los siguientes gestos:arriba, abajo, izquierda, derecha, boca arriba, boca abajo, caída libre, 3g,
6g, 8g, agitar.Los gestos siempre se representan como cadenas. Si bien la mayoría de los nombres deberían ser obvios, el3g, 6gy8g
Los gestos se aplican cuando el dispositivo encuentra estos niveles de fuerza G (como cuando un astronauta es lanzado al espacio).

Para obtener el gesto actual utilice elacelerómetro.gesto_actualmétodo. Su resultado será uno de los gestos
mencionados anteriormente. Por ejemplo, este programa sólo hará feliz a tu dispositivo si está boca arriba:

demicrobitimportar*

mientras que verdadero:

gesto=acelerómetro.gesto_actual() sigesto=="frente":

mostrar.mostrar imagen.FELIZ)
demás:
mostrar.mostrar imagen.ENOJADO)

Una vez más, porque queremos que el dispositivo reaccione a circunstancias cambiantes, utilizamos unmientras
bucle. Dentro dealcancedel bucle, el gesto actual se lee y se coloca engesto.Elsicontroles condicionales sigestoes igual
a "frente" (Python usa == para probar la igualdad, un solo signo igual = se usa para la asignación, tal como asignamos
la lectura del gesto algestoobjeto). Si el gesto es igual a "frente"luego use la pantalla para mostrar una cara feliz. De
lo contrario, ¡el dispositivo parece enojado!

1.8.1 Magia-8

Una pelota Magic-8 es un juguete inventado por primera vez en la década de 1950. La idea es hacerle una pregunta de sí o no, sacudirlo y esperar a que
revele la verdad. Es bastante fácil convertirlo en un programa:

demicrobitimportar*
importaraleatorio

respuestas=[
"Es cierto", "Es
decididamente así", "Sin
duda", "Sí definitivamente",

"Puedes confiar en ello",

"Como yo lo veo, sí", "Más
probable",
"Perspectivas buena",
"Sí",
"Las señales apuntan a que sí",
"Respuesta confusa, intenta otra vez",
"Pregunta de nuevo más tarde", "Mejor
no decirte ahora",
(continúa en la página siguiente)

1.8. gestos 23
BBC micro:bit Documentación de MicroPython, versión 1.0.1

(Continuación de la página anterior)

"No se puede predecir ahora",

"Concéntrate y pregunta otra vez", "No
cuentes con ello" "Mi respuesta es no",
"Mis fuentes dicen que no", "Las
perspectivas no son tan buenas", "Muy
dudoso",

mientras que verdadero:

mostrar.espectáculo("8")
siacelerómetro.era_gesto("agitar"):
mostrar.claro()
dormir(1000)
mostrar.desplazamiento (aleatorio.elección (respuestas))

La mayor parte del programa es una lista llamadarespuestas.El juego real está en elmientrasbucle al final.

El estado predeterminado del juego es mostrar el personaje "8".Sin embargo, el programa necesita detectar si ha sido sacudido. El
era_gestoEl método utiliza su argumento (en este caso, la cadena "agitar"porque queremos detectar una sacudida) para devolver un
Verdadero Falsorespuesta. Si el dispositivo fue sacudido elsicondicional cae en su bloque de código donde limpia la pantalla, espera
un segundo (para que el dispositivo parezca estar pensando en su pregunta) y muestra una respuesta elegida al azar.

¿Por qué no preguntar si éste es el mejor programa jamás escrito? ¿Qué podrías hacer para “hacer trampa” y que la respuesta sea siempre
positiva o negativa? (Pista: utilice los botones).

1.9 Dirección

Hay una brújula en el micro:bit de la BBC. Si alguna vez construyes una estación meteorológica, utiliza el dispositivo para calcular la dirección del viento.

1.9.1 Brújula

También puede indicarte la dirección del Norte así:

demicrobitimportar*

Brújula.calibrar()

mientras que verdadero:

aguja=((15-Brújula.título())//30)%12 mostrar.mostrar imagen.

ALL_CLOCKS[aguja])

Nota: Debes calibrar la brújula antes de tomar lecturas.De lo contrario, se producirán resultados basura. ElcalibraciónEl método
ejecuta un pequeño juego divertido para ayudar al dispositivo a determinar dónde se encuentra en relación con el campo magnético
de la Tierra.

Para calibrar la brújula, incline el micro:bit hasta que se dibuje un círculo de píxeles en los bordes exteriores de la pantalla.

El programa toma larumbo.de.la.brújulay, usando algunas matemáticas simples pero astutas,división de piso// ymódulo %, calcula el número
de la manecilla del reloj que se usará para mostrar en la pantalla de modo que apunte aproximadamente al norte.

24 Capítulo 1 Introducción
 BBC micro:bit Documentación de MicroPython, versión 1.0.1

1.10 Almacenamiento

A veces es necesario almacenar información útil. Dicha información se almacena como datos: representación de información (en forma digital
cuando se almacena en computadoras). Si almacena datos en una computadora, estos deberían persistir, incluso si apaga y enciende el
dispositivo.

Afortunadamente, MicroPython en micro:bit te permite hacer esto con un sistema de archivos muy simple. Debido a limitaciones de memoria
hay aproximadamente 30k de almacenamiento disponibleen el sistema de archivos.

Nota:El sistema de archivos micropython no debe confundirse con el modo de almacenamiento masivo micro:bit que presenta el dispositivo como una
unidad USB. El modo de almacenamiento masivo solo está diseñado para copiar en un archivo HEX, por lo que no verá los archivos que cree utilizando el
sistema de archivos que aparecen en la unidad MICROBIT.

¿Qué es un sistema de archivos?

Es un medio para almacenar y organizar datos de manera persistente: cualquier dato almacenado en un sistema de archivos debería sobrevivir a los reinicios del
dispositivo. Como sugiere el nombre, los datos almacenados en un sistema de archivos se organizan en archivos.

Un archivo de computadora es un recurso digital con nombre que se almacena en un sistema de archivos. Dichos recursos contienen información útil en forma de
datos. Así es exactamente como funciona un archivo en papel. Es una especie de contenedor con nombre que contiene información útil. Por lo general, tanto los
archivos en papel como los digitales reciben nombres para indicar lo que contienen. En las computadoras es común terminar un archivo con un
. algosufijo. Por lo general, el "algo" indica qué tipo de datos se utilizan para representar la información. Por ejemplo, .TXT
indica un archivo de texto, .jpguna imagen JPEG y .mp3datos de sonido codificados como MP3.

1.10. Almacenamiento 25
BBC micro:bit Documentación de MicroPython, versión 1.0.1

Algunos sistemas de archivos (como el que se encuentra en su computadora portátil o PC) le permiten organizar sus archivos en directorios:
contenedores con nombre que agrupan archivos y subdirectorios relacionados. Sin embargo,el sistema de archivos proporcionado por MicroPython es
un sistema de archivos plano. Un sistema de archivos planos no tiene directorios: todos los archivos simplemente se almacenan en el mismo lugar.

El lenguaje de programación Python contiene formas potentes y fáciles de usar para trabajar con el sistema de archivos de una computadora.
MicroPython en micro:bit implementa un subconjunto útil de estas características para facilitar la lectura y escritura de archivos en el
dispositivo, al tiempo que proporciona coherencia con otras versiones de Python.

Advertencia:Flashear su micro:bit DESTRUIRA TODOS SUS DATOS ya que reescribe toda la memoria flash utilizada por el
dispositivo y el sistema de archivos se almacena en la memoria flash.

Sin embargo, si apaga su dispositivo, los datos permanecerán intactos hasta que los elimine o vuelva a actualizar el dispositivo.

1.10.1 Ábrete Sésamo

La lectura y escritura de un archivo en el sistema de archivos se logra mediante elabiertofunción. Una vez que se abre un archivo, puede hacer
cosas con él hasta que lo cierre (análogo a la forma en que usamos archivos en papel). Es esencial que cierre un archivo para que MicroPython
sepa que ha terminado con él.

La mejor manera de asegurarse de esto es utilizar elcondeclaración como esta:

conabierto('historia.txt')comomi archivo:
contenido=mi archivo.leer()
imprimir(contenido)

Elcondeclaración utiliza elabiertofunción para abrir un archivo y asignarlo a un objeto. En el ejemplo anterior, elabierto La función
abre el archivo llamado.historia.txt (obviamente un archivo de texto que contiene una historia de algún tipo). El objeto que se utiliza
para representar el archivo en el código Python se llamami archivo.Posteriormente, en el bloque de código sangrado debajo delcon
declaración, lami archivoobjeto se utiliza paraleer()el contenido del archivo y asignarlo alcontenido objeto.

Aquí está el punto importante,la siguiente línea que contiene elimprimirla declaración no tiene sangría. El bloque de código asociado
con elconLa declaración es solo la línea que lee el archivo. Una vez que el bloque de código asociado con elcon Cuando la declaración
se cierra, Python (y MicroPython) cerrarán automáticamente el archivo. Esto se llama manejo de contexto y elabiertoLa función crea
objetos que son controladores de contexto para archivos.

En pocas palabras, el alcance de su interacción con un archivo está definido por el bloque de código asociado con elcondeclaración que abre el
archivo.

¿Confundido?

No lo seas. Simplemente digo que tu código debería verse así:

conabierto('algún_archivo')comoalgún_objeto:
# Hacer cosas con algún_objeto en este bloque de código
# asociado con la declaración with.

# Cuando el bloque haya terminado, MicroPython

# cierra automáticamente el archivo.

Al igual que un archivo en papel, un archivo digital se abre por dos motivos: para leer su contenido (como se demostró anteriormente) o para
escribir algo en el archivo. El modo predeterminado es leer el archivo. Si desea escribir en un archivo, debe indicarle alabierto funcionar de la
siguiente manera:

conabierto('hola.txt','w')comomi archivo:
mi archivo.escribir("¡Hola Mundo!")

26 Capítulo 1 Introducción
 BBC micro:bit Documentación de MicroPython, versión 1.0.1

Observe la 'w'El argumento se utiliza para establecer elmi archivoobjeto en modo de escritura. También podrías pasar un 'r'argumento para configurar el objeto de
archivo en modo de lectura, pero como este es el valor predeterminado, a menudo se omite.

La escritura de datos en el archivo se realiza con (lo adivinaste)escribirmétodo que toma la cadena que desea escribir en el archivo
como argumento. En el ejemplo anterior, escribo el texto "¡Hola, mundo!" a un archivo llamado “hola.txt”.

¡Simple!

Nota:Cuando abre un archivo y escribe (quizás varias veces mientras el archivo está abierto), escribirá SOBRE el
contenido del archivo si ya existe.
Si desea agregar datos a un archivo, primero debe leerlo, almacenar el contenido en algún lugar, cerrarlo, agregar sus datos al contenido y
luego abrirlo para escribir nuevamente con el contenido revisado.

Si bien este es el caso en MicroPython, Python "normal" puede abrir archivos para escribir en modo "añadir". El hecho de que no podamos
hacer esto en el micro:bit es el resultado de la simple implementación del sistema de archivos.

1.10.2 SO SOS

Además de leer y escribir archivos, Python puede manipularlos. Ciertamente necesita saber qué archivos hay en el sistema
de archivos y, a veces, también necesita eliminarlos.

En una computadora normal, la función del sistema operativo (como Windows, OSX o Linux) es administrar esto en nombre de Python. Esta
funcionalidad está disponible en Python a través de un módulo llamadoos.Desde MicroPythonesel sistema operativo hemos decidido
mantener las funciones apropiadas en elsistema operativomódulo para mayor coherencia, de modo que sepa dónde encontrarlos cuando use
Python "normal" en un dispositivo como una computadora portátil o Raspberry Pi.

Básicamente, puede realizar tres operaciones relacionadas con el sistema de archivos: enumerar los archivos, eliminar un archivo y solicitar el tamaño de un archivo.

Para enumerar los archivos en su sistema de archivos utilice ellistadirfunción. Devuelve una lista de cadenas que indican los nombres de los archivos en
el sistema de archivos:

importarsistema operativo

mis archivos=sistema operativo.listadir()

Para eliminar un archivo utilice eleliminarfunción. Toma una cadena que representa el nombre del archivo que desea eliminar como
argumento, como este:

importarsistema operativo

sistema operativo.eliminar('nombre de archivo.txt')

Finalmente, a veces es útil saber qué tamaño tiene un archivo antes de leerlo. Para lograr esto utilice eltamañofunción.
Como eleliminarfunción, toma una cadena que representa el nombre del archivo cuyo tamaño desea saber. Devuelve un
número entero (número entero) que le indica la cantidad de bytes que ocupa el archivo:

importarsistema operativo

tamaño del archivo=sistema operativo.tamaño('un_archivo_grande.txt')

Está muy bien tener un sistema de archivos, pero ¿qué pasa si queremos poner o sacar archivos dentro o fuera del dispositivo?

Sólo usa elmicrofs¡utilidad!

1.10. Almacenamiento 27
BBC micro:bit Documentación de MicroPython, versión 1.0.1

1.10.3 Transferencia de archivos

Si tienes Python instalado en la computadora que usas para programar tu BBC micro:bit, entonces puedes usar una utilidad especial
llamadamicrofs (acortado aufsal usarlo en la línea de comando). Se pueden encontrar instrucciones completas para instalar y utilizar
todas las funciones de microfs.en su documentación.

Sin embargo, es posible hacer la mayoría de las cosas que necesitas con sólo cuatro comandos simples:

$ufs ls
historia.txt

ElesEl subcomando enumera los archivos en el sistema de archivos (lleva el nombre del comando común de Unix,yo,que cumple la
misma función).

$ ufs obtiene historia.txt

ElconseguirEl subcomando obtiene un archivo del micro:bit conectado y lo guarda en su ubicación actual en su computadora (lleva el
nombre delconseguircomando que es parte del protocolo común de transferencia de archivos [FTP] que cumple la misma función).

$ ufs rm historia.txt

ElhabitaciónEl subcomando elimina el archivo nombrado del sistema de archivos en el micro:bit conectado (lleva el nombre del
comando común de Unix,habitación,que cumple la misma función).

$ ufs pone historia2.txt

Finalmente, elponerEl subcomando coloca un archivo de su computadora en el dispositivo conectado (lleva el nombre delponer
comando que es parte de FTP y que cumple la misma función).

1.10.4 Principalmente main.py

El sistema de archivos también tiene una propiedad interesante: si acaba de instalar el tiempo de ejecución de MicroPython en el dispositivo,
cuando se inicie simplemente estará esperando a que haga algo. Sin embargo, si copia un archivo especial llamadoprincipal.pyen el sistema de
archivos, al reiniciar el dispositivo, MicroPython ejecutará el contenido delprincipal.py file.

Además, si copia otros archivos Python en el sistema de archivos, podráimportarellos como lo haría con cualquier otro
módulo de Python. Por ejemplo, si tuvieras unhola.py fiarchivo que contenía el siguiente código simple:

definicióndi hola(nombre="Mundo"):
devolver"Hola,{}!".formato (nombre)

. . . puedes importar y usar eldi holafuncionar así:

demicrobitimportarmostrar deHola
importardi hola

mostrar.desplazarse(decir_hola())

Por supuesto, el resultado es el texto "¡Hola, mundo!" desplazándose por la pantalla. El punto importante es que dicho ejemplo se
divide entre dos módulos de Python y elimportarLa declaración se utiliza para compartir código.

Nota:Si ha instalado un script en el dispositivo además del tiempo de ejecución de MicroPython, MicroPython ignorará
principal.pyy ejecute su script incrustado en su lugar.

28 Capítulo 1 Introducción
 BBC micro:bit Documentación de MicroPython, versión 1.0.1

Para actualizar solo el tiempo de ejecución de MicroPython, simplemente asegúrese de que el script que haya escrito en su editor no
tenga caracteres. Una vez flasheado podrás copiar sobre unprincipal.py file.

1.11 Discurso

Advertencia:¡ADVERTENCIA! ESTE ES EL CÓDIGO ALFA.

Nos reservamos el derecho de cambiar esta API a medida que continúa el desarrollo.

La calidad del discurso no es excelente, simplemente “suficientemente buena”. Dadas las limitaciones del dispositivo, es posible
encontrar errores de memoria y/o sonidos adicionales inesperados durante la reproducción. Es pronto y estamos mejorando el código del
sintetizador de voz todo el tiempo. Los informes de errores y las solicitudes de extracción son bienvenidos.

Las computadoras y los robots que hablan se sienten más "humanos".

Muy a menudo aprendemos qué hace una computadora a través de una interfaz gráfica de usuario (GUI). En el caso de un BBC
micro:bit, la GUI es una matriz de LED de 5x5, lo que deja mucho que desear.

Hacer que micro:bit te hable es una forma de expresar información de una manera divertida, eficiente y útil. Con este fin, hemos
integrado un sintetizador de voz simple basado en una versión de ingeniería inversa de un sintetizador de principios de los años
1980. Suena muy lindo, en una especie de “todos los humanos deben morir”.

Con esto en mente, usaremos el sintetizador de voz para crear. . .

1.11. Discurso 29
BBC micro:bit Documentación de MicroPython, versión 1.0.1

30 Capítulo 1 Introducción
 BBC micro:bit Documentación de MicroPython, versión 1.0.1

1.11.1 Poesía DALEK

1.11. Discurso 31
BBC micro:bit Documentación de MicroPython, versión 1.0.1

Es un hecho poco conocido que a los DALEK les gusta la poesía, especialmente las quintillas. Se vuelven locos por el medidor anapéstico con una estricta
forma AABBA. ¿Quién lo hubiera pensado?

(En realidad, como aprenderemos más adelante, es culpa del Doctor que a los DALEK les gusten las quintillas, para disgusto de Davros). En

cualquier caso, vamos a crear un recital de poesía de DALEK a pedido.

1.11.2 Di algo

Antes de que el dispositivo pueda hablar, debes conectar un altavoz como este:

La forma más sencilla de hacer que el dispositivo hable es importar eldiscursomódulo y utilice eldecirfuncionar así:

importardiscurso

discurso.decir("Hola Mundo")

32 Capítulo 1 Introducción
 BBC micro:bit Documentación de MicroPython, versión 1.0.1

Si bien esto es lindo, ciertamente no es suficiente DALEK para nuestro gusto, por lo que necesitamos cambiar algunos de los parámetros que
usa el sintetizador de voz para producir la voz. Nuestro sintetizador de voz es bastante potente en este sentido porque podemos cambiar
cuatro parámetros:

• paso -qué tan alto o bajo suena la voz (0 = alto, 255 = Barry White)
• velocidad -qué tan rápido habla el dispositivo (0 = imposible, 255 = cuento antes de dormir)

• boca -qué tan cerrada o abiertamente suena la voz (0 = muñeco de ventrílocuo, 255 = Foghorn
Leghorn)
• garganta -qué tan relajado o tenso es el tono de voz (0 = desmoronándose, 255 = totalmente tranquilo)

En conjunto, estos parámetros controlan la calidad del sonido, también conocido como timbre. Para ser honesto, la mejor manera de
conseguir el tono de voz que desea es experimentar, usar su criterio y adaptarse.

Para ajustar la configuración, páselos como argumentos aldecirfunción. Más detalles se pueden encontrar en eldiscurso
documentación API del módulo.

Después de un poco de experimentación, hemos descubierto que esto suena bastante parecido a DALEK:

discurso.decir("Soy un DALEK - EXTERMINAR", velocidad=120, paso=100, garganta=100, boca=200)

1.11.3 Poesía a la carta

Al ser Cyborgs, los DALEK utilizan sus capacidades robóticas para componer poesía y resulta que el algoritmo que utilizan
está escrito en Python así:

# Generador de poesía DALEK, de The Doctor

importardiscurso
importaraleatorio
demicrobitimportardormir

# Seleccione fragmentos aleatoriamente para interpolarlos en la plantilla. ubicación=

aleatorio.elección(["brent","trent","kent","taskent"])
acción=aleatorio.elección(["envuelto","cubierto","cantaba","jugué juegos con"]) objeto=aleatorio.elección([
"cabeza","mano","perro","pie"])
apuntalar=aleatorio.elección(["en una tienda de campaña","con cemento","con algún aroma",
"eso estaba doblado"])
resultado=aleatorio.elección(["se escapó","brillaba","explotó",
"se puso azul"])
actitud=aleatorio.elección(["en el parque","como un tiburón","para una alondra",
"con ladrido"])
conclusión=aleatorio.elección(["a donde fue","su intención","por qué fue",
"lo que significaba"])

# Una plantilla del poema. Los {} se reemplazan por los fragmentos nombrados. poema=[

"Había un joven de{}".formato (ubicación), "OMS{}su{} {}".formato

(acción, obj, prop), "una noche después del anochecer",

"{} {}".formato (resultado, actitud),

"y nunca funcionó{}".formato (conclusión), "EXTERMINAR",

# Recorra cada línea del poema y use el módulo de voz para recitarlo. paralíneaenpoema:

(continúa en la página siguiente)

1.11. Discurso 33
BBC micro:bit Documentación de MicroPython, versión 1.0.1

(Continuación de la página anterior)

discurso.decir (línea, velocidad=120, paso=100, garganta=100, boca=200) dormir(

500)

Como demuestran los comentarios, es un diseño muy simple:

• Fragmentos con nombre (ubicación, utilería, actitudetc) se generan aleatoriamente a partir de listas predefinidas de valores posibles.
Tenga en cuenta el uso deelección.aleatoriapara seleccionar un solo elemento de una lista.

• Una plantilla de un poema se define como una lista de estrofas con “huecos” (indicados por {}) en las que se colocarán los
fragmentos nombrados usando elformatométodo.

• Finalmente, Python recorre cada elemento de la lista de estrofas y usos de poesía completados.discurso.decircon los ajustes
para que la voz de DALEK recite el poema. Se inserta una pausa de 500 milisegundos entre cada línea porque incluso los
DALEK necesitan tomar un respiro.

Curiosamente, las rutinas originales relacionadas con la poesía fueron escritas por Davros enFORTRAN(un lenguaje apropiado para DALEKS ya
que lo escribes TODO EN LETRAS MAYÚSCULAS). Sin embargo, El Doctor retrocedió en el tiempo precisamente hasta el punto entre la
aparición de Davros.pruebas unitariaspasando y elcanalización de implementaciónEn este instante pudo insertar un intérprete MicroPython
en el sistema operativo DALEK y el código que ve arriba en los bancos de memoria de DALEK como una especie de Señor del Tiempo oculto
durante mucho tiempo.el huevo de PascuaoRollo de Rick.

1.11.4 Fonemas

Notarás que a veces, eldecirLa función no traduce con precisión las palabras en inglés al sonido correcto. Para tener
un control detallado de la salida, utilice fonemas: los sonidos básicos del lenguaje.

¡La ventaja de usar fonemas es que no es necesario saber deletrear! Más bien, sólo hay que saber decir la palabra
para poder deletrearla fonéticamente.

Puede encontrar una lista completa de los fonemas que comprende el sintetizador de voz en la documentación API para voz.
Alternativamente, ahórrese mucho tiempo pasando palabras en inglés altraducirfunción. Devolverá una primera
aproximación de los fonemas que usaría para generar el audio. Este resultado se puede editar a mano para mejorar la
precisión, la inflexión y el énfasis (para que suene más natural).

ElpronunciarLa función se utiliza para la salida de fonemas como esta:

discurso.pronunciar("/HEH5EH4EH3EH2EH2EH3EH4EH5EHLP.”)

¿Cómo podrías mejorar el código de The Doctor para que utilice fonemas?

1.11.5 Cantar una canción de Micro:bit

Al cambiar elpasoconfigurar y llamar alcantarfunción es posible hacer que el dispositivo cante (aunque no
ganará Eurovisión en el corto plazo).
La asignación de números de tono a notas musicales se muestra a continuación:

34 Capítulo 1 Introducción
 BBC micro:bit Documentación de MicroPython, versión 1.0.1

ElcantarLa función debe tomar fonemas y tono como entrada de esta manera:

discurso.cantar("#115DOWWWW")

Observe cómo el tono que se va a cantar se antepone al fonema con una almohadilla (#). El tono seguirá siendo el mismo para los
fonemas posteriores hasta que se anote un nuevo tono.

El siguiente ejemplo demuestra cómo las tres funciones generativas (decir, pronunciarycantar)se puede utilizar para
producir salida similar a voz:

importardiscurso
demicrobitimportardormir

# El método say intenta convertir el inglés en fonemas. discurso.decir("¡Puedo

cantar!") dormir(1000)

discurso.decir("¡Escúchame!")
dormir(1000)

# Aclararse la garganta requiere el uso de fonemas. Cambiando

# el tono y la velocidad también ayudan a crear el efecto correcto. discurso.
pronunciar("AEAE/HAEMM", paso=200, velocidad=100)#Ejem dormir(1000)

# Cantar requiere un fonema con un tono anotado para cada sílaba. solfa=[

"#115DOWWWWWW", #doh
"#103REYYYYYY", # Re
"#94MIAAAAAA", #mi
"#88FAOAOAOAOR", #Fa
"#78SOHWWWWW", #soy
(continúa en la página siguiente)

1.11. Discurso 35
BBC micro:bit Documentación de MicroPython, versión 1.0.1

(Continuación de la página anterior)

"#70LAOAOAOAOR", #la
"#62TIAAAAAA", #ti
"#58DOWWWWWW", #doh
]

# Cante la escala ascendente en tono. canción=''.

unirse (solfa) discurso.cantar(canción, velocidad=
100)
# Invertir la lista de sílabas. solfa.
contrarrestar()
canción=''.unirse(solfa)
# Cante la escala de tono descendente. discurso.
cantar(canción, velocidad=100)

1.12 Red

Es posible conectar dispositivos entre sí para enviar y recibir mensajes entre sí. Esto se llama red. Una red de
redes interconectadas se llama Internet. Internet es una Internet de todas las Internets.
Hacer networking es difícil y esto se refleja en el programa que se describe a continuación. Sin embargo, lo bueno de este proyecto es que
contiene todos los aspectos comunes de la programación de redes que necesita conocer. También es notablemente simple y divertido.

Pero primero, preparemos el escenario. . .

1.12.1 Conexión

Imagine una red como una serie de capas. En el fondo está el aspecto más fundamental de la comunicación: debe haber
algún tipo de forma para que una señal llegue de un dispositivo a otro. A veces esto se hace mediante una conexión de
radio, pero en este ejemplo simplemente usaremos dos cables.

36 Capítulo 1 Introducción
 BBC micro:bit Documentación de MicroPython, versión 1.0.1

Es sobre esta base que podemos construir todas las demás capas delpila de red.

Como muestra el diagrama, los micro:bits azules y rojos están conectados mediante cables de cocodrilo. Ambos usan el pin 1 para salida y el
pin 2 para entrada. La salida de un dispositivo está conectada a la entrada del otro. Es un poco como saber en qué dirección sostener el
auricular del teléfono: un extremo tiene un micrófono (la entrada) y el otro un altavoz (la salida). La grabación de su voz a través de su
micrófono se reproduce a través del altavoz de la otra persona. ¡Si sostienes el teléfono en la posición incorrecta, obtendrás resultados
extraños!

En este caso es exactamente lo mismo: ¡debes conectar los cables correctamente!

1.12.2 Señal

La siguiente capa en elpila de redes la señal. A menudo esto dependerá de las características de la conexión. En nuestro ejemplo, se trata simplemente de
señales digitales de encendido y apagado enviadas a través de los cables a través de los pines IO.

Si recuerdas, es posible usar los pines IO de esta manera:

pin1.escribir_digital(1) pin1. # encender la señal

escribir_digital(0) aporte=pin2. # apaga la señal
lectura_digital() # leer el valor de la señal (ya sea 1 o 0)

El siguiente paso consiste en describir cómo utilizar y manejar una señal. Para eso necesitamos un. . .

1.12.3 Protocolo

Si alguna vez conoces a la Reina, existen expectativas sobre cómo debes comportarte. Por ejemplo, cuando ella llegue, puede hacer una
reverencia o una reverencia, si ella le ofrece la mano, estrechársela cortésmente, referirse a ella como "su majestad" y luego como "señora",
etc. Este conjunto de reglas se llama protocolo real. Un protocolo explica cómo comportarse ante una situación específica (como conocer a la
Reina). Un protocolo está predefinido para garantizar que todos comprendan lo que sucede antes de que surja una situación determinada.

1.12. Red 37
BBC micro:bit Documentación de MicroPython, versión 1.0.1

Es por esta razón que definimos y utilizamos protocolos para comunicar mensajes a través de una red informática. Las
computadoras deben acordar de antemano cómo enviar y recibir mensajes. Quizás el protocolo más conocido sea el protocolo de
transferencia de hipertexto (HTTP) utilizado por la red mundial.

Otro protocolo famoso para enviar mensajes (que es anterior a las computadoras) es el código Morse. Define cómo enviar mensajes basados
en caracteres mediante señales de encendido/apagado de larga o corta duración. A menudo, estas señales se reproducen como pitidos. Las
duraciones largas se denominan guiones (-), mientras que las duraciones cortas son puntos (.). Al combinar guiones y puntos, Morse define
una forma de enviar caracteres. Por ejemplo, así es como se define el alfabeto Morse estándar:

.- A .--- j ... S .---- 1 ----. 9

-... B -.- k - t ..--- 2 ----- 0
-.-. C .-.. l ..- Ud. ...-- 3
-.. D -- METRO ...- V ....- 4
. mi -. norte .-- W. ..... 5
..-. F --- oh -..- X -.... 6
--. GRAMO .--. PAG -.-- Y --... 7
.... h --.- q --.. z ---.. 8
.. I .-. R

Teniendo en cuenta el cuadro anterior, para enviar el carácter “H”, la señal se enciende cuatro veces durante un breve período,
indicando cuatro puntos (...). Para la letra “L” la señal también se activa cuatro veces, pero la segunda señal tiene una duración más
larga (.-..).

Obviamente, el momento de la señal es importante: debemos distinguir un punto de un guión. Ese es otro punto de un protocolo, acordar
tales cosas para que la implementación del protocolo por parte de todos funcione con todos los demás. En este caso simplemente diremos
que:

• Una señal con una duración inferior a 250 milisegundos es un punto.

• Una señal con una duración de 250 milisegundos a menos de 500 milisegundos es un guión.

• Se ignora cualquier otra duración de la señal.

• Una pausa/intervalo en la señal de más de 500 milisegundos indica el final de un carácter.

De esta forma, el envío de una letra “H” se define como cuatro señales de “encendido” que no duran más de 250 milisegundos cada
una, seguidas de una pausa superior a 500 milisegundos (que indica el final del carácter).

38 Capítulo 1 Introducción
 BBC micro:bit Documentación de MicroPython, versión 1.0.1

1.12.4 Mensaje

Finalmente estamos en una etapa en la que podemos construir un mensaje, un mensaje que realmente signifique algo para nosotros, los humanos. Esta
es la capa más superior de nuestrapila de red.

Usando el protocolo definido anteriormente, puedo enviar la siguiente secuencia de señales por el cable físico al otro
micro:bit:

. . . . /./.-../.-../---/.--/---/.-./.-../-..

¿Puedes averiguar lo que dice?

1.12.5 Aplicación

Está muy bien tener una pila de red, pero también necesitas una forma de interactuar con ella: algún tipo de aplicación para enviar y
recibir mensajes. Si bien HTTP es interesantemayoríala gente no lo sabe y deja que su navegador web lo maneje
- el subyacentepila de redde la red mundial está oculta (como debería estar).

Entonces, ¿qué tipo de aplicación deberíamos escribir para BBC micro:bit? ¿Cómo debería funcionar, desde el punto de vista del
usuario?

Obviamente, para enviar un mensaje deberías poder ingresar puntos y guiones (podemos usar el botón A para eso). Si queremos ver el
mensaje que enviamos o acabamos de recibir, deberíamos poder activarlo para que se desplace por la pantalla (podemos usar el botón B para
eso). Finalmente, al tratarse de código Morse, si hay un altavoz conectado, deberíamos poder reproducir los pitidos como una forma de
respuesta auditiva mientras el usuario ingresa su mensaje.

1.12.6 El resultado final

Aquí está el programa, en todo su esplendor y anotado con muchos comentarios para que puedas ver lo que está pasando:

demicrobitimportar*
importarmúsica

# Una tabla de búsqueda de códigos morse y caracteres asociados.

MORSE_CODE_LOOKUP={
".-":"A",
"-...":"B",
"-.-.":"C",
"-...":"D",
".":"MI",
"..-.":"F",
"--.":"GRAMO",
"...":"H",
"...":"I",
".---":"J",
"-.-":"k",
".-...":"L",
"--":"METRO",
"-.":"NORTE",
"---":"Oh",
".--.":"PAG",
"--.-":"Q",
".-.":"R",
"...":"S",
(continúa en la página siguiente)

1.12. Red 39
BBC micro:bit Documentación de MicroPython, versión 1.0.1

(Continuación de la página anterior)

"-":"t",
"..-":"U",
"...-":"V",
".--":"W",
"-..-":"X",
"-.--":"Y",
"--...":"Z",
".----":"1",
"..---":"2",
"...--":"3",
"....-":"4",
"...":"5",
"-...":"6",
"--...":"7",
"---...":"8",
"----.":"9",
"-----":"0"
}

definicióndescodificar(buffer):
# Intenta obtener el búfer de datos en código Morse de la tabla de búsqueda. Si
# no está allí, solo devuelve un punto. devolver
MORSE_CODE_LOOKUP.obtener (búfer,'.')

# Cómo mostrar un solo punto. PUNTO=

Imagen("00000:"
"00000:"
"00900:"
"00000:"
"00000:")

# Cómo mostrar un solo guión.

ESTRELLARSE=Imagen("00000:"
"00000:"
"09990:"
"00000:"
"00000:")

# Para crear un DOT, debes mantener presionado el botón durante menos de 250 ms.
PUNTO_UMBRAL=250
# Para crear un DASH, debes mantener presionado el botón durante menos de 500 ms.
DASH_THRESHOLD=500

# Mantiene las señales Morse entrantes. buffer

=''
# Mantiene el Morse traducido como caracteres. mensaje
=''
# El tiempo desde el cual el dispositivo ha estado esperando la siguiente pulsación de tecla.
iniciado_para_esperar=tiempo de ejecución()

# Coloque el dispositivo en un bucle para esperar y reaccionar ante las pulsaciones de teclas.
(continúa en la página siguiente)

40 Capítulo 1 Introducción
 BBC micro:bit Documentación de MicroPython, versión 1.0.1

(Continuación de la página anterior)

mientras que verdadero:

# Calcule cuánto tiempo ha estado esperando el dispositivo a que se presione una tecla.
espera=tiempo de ejecución()-iniciado_para_esperar
# Restablecer la marca de tiempo para key_down_time.
key_down_time=Ninguno
# Si se mantiene presionado el botón_a,
entonces... mientrasbotón_a.se presiona():
# Reproduce un pitido: este es el código Morse, ¿sabes? ;-)
música.paso(880,10)
# Establecer pin1 (salida) en
"activado" pin1.escribir_digital(1)
# . . . y si no hay un key_down_time, ¡configúrelo ahora! si nokey_down_time:

key_down_time=tiempo de ejecución()
# Alternativamente, si el pin2 (entrada) recibe una señal, pretenda que es un
# botón_una pulsación de tecla...
mientraspin2.lectura_digital():
si nokey_down_time:
key_down_time=tiempo de ejecución()
# Obtenga la hora actual y llámela key_up_time. key_up_time=
tiempo de ejecución()
# Establecer pin1 (salida) en
"apagado" pin1.escribir_digital(0)
# Si hay un key_down_time (creado cuando se presionó por primera vez el botón_a)
# abajo).
sikey_down_time:
# . . . luego calcula durante cuánto tiempo estuvo presionado.
duración=key_up_time-key_down_time
# Si la duración es menor que la duración máxima para una pulsación de "punto"... si
duración<PUNTO_UMBRAL:
# . . . luego agregue un punto al búfer que contiene los códigos Morse entrantes
# y muestra un punto en la pantalla. buffer+='.'

mostrar.mostrar (PUNTO)
# De lo contrario, si la duración es menor que la longitud máxima para un "guión"
# presione... (pero más que eso para un DOT ~ manejado anteriormente) elif
duración<DASH_THRESHOLD:
# . . . luego agregue un guión al búfer y muestre un guión. buffer+='-'

mostrar.mostrar (DASH)
# De lo contrario, se ignora cualquier otro tipo de duración de pulsación de tecla (esto no es
# necesario, pero agregado para "comprensibilidad").
demás:
aprobar

# La pulsación del botón ha sido manejada, así que restablezca el tiempo desde el cual
# dispositivo está empezando a esperar a que se presione un botón.
iniciado_para_esperar=tiempo de ejecución()
# De lo contrario, no se ha presionado ningún botón durante este ciclo del
# bucle, así que verifique que no haya habido una pausa para indicar el final del
# carácter de código Morse entrante. La pausa debe ser más larga que un DASH.
# duración del código.
eliflen(buffer)>0yespera>DASH_THRESHOLD:
# Hay un buffer y ha llegado al final de un código así que...
# Decodificar el búfer entrante.
personaje=decodificar (búfer)
# Restablece el búfer para vaciarlo.
buffer=''
(continúa en la página siguiente)

1.12. Red 41
BBC micro:bit Documentación de MicroPython, versión 1.0.1

(Continuación de la página anterior)

# Muestra el carácter decodificado.

mostrar.mostrar (personaje)
# Agrega el carácter al mensaje. mensaje+=
personaje
# Finalmente, si se presionó el botón_b mientras sucedía todo lo anterior... sibotón_b.
estaba_presionado():
# . . . mostrar el mensaje, mostrar.
desplazarse (mensaje)
# luego reinícielo para que esté vacío (listo para recibir un nuevo
mensaje). mensaje=''

¿Cómo lo mejorarías? ¿Puedes cambiar la definición de punto y guión para que los usuarios rápidos de código Morse puedan usarlo?
¿Qué pasa si ambos dispositivos envían al mismo tiempo? ¿Qué podrías hacer para manejar esta situación?

1.13 Radio

La interacción a distancia parece mágica.

La magia puede ser útil si eres un elfo, un mago o un unicornio, pero esas cosas sólo existen en las historias.

Sin embargo, hay algo mucho mejor que la magia: ¡la física!

La interacción inalámbrica tiene que ver con la física: las ondas de radio (un tipo de radiación electromagnética, similar a la luz
visible) tienen algún tipo de propiedad (como su amplitud, fase o ancho de pulso) modulada por un transmisor de tal manera que la
información puede codificarse. y, por tanto, difundir. Cuando las ondas de radio encuentran un conductor eléctrico (es decir, una
antena), provocan una corriente alterna de la cual se puede extraer la información de las ondas y transformarla nuevamente a su
forma original.

1.13.1 Capas sobre capas

Si recuerdas, las redes se construyen en capas.

El requisito más fundamental para una red es algún tipo de conexión que permita que una señal pase de un dispositivo a
otro. En nuestro tutorial de redes utilizamos cables conectados a los pines de E/S. Gracias al módulo de radio podemos
prescindir de los cables y utilizar la física resumida anteriormente como conexión invisible entre dispositivos.

La siguiente capa en la pila de red también es diferente del ejemplo del tutorial de redes. En el ejemplo cableado utilizamos
el encendido y apagado digital para enviar y leer una señal de los pines. Con la radio incorporada en el micro:bit, la parte útil
más pequeña de la señal es un byte.

1.13.2 Bytes

Un byte es una unidad de información que (normalmente) consta de ocho bits. Un bit es la unidad de información más pequeña posible ya que sólo
puede estar en dos estados: encendido o apagado.

Los bytes funcionan como una especie de ábaco: cada posición en el byte es como una columna en un ábaco: representan un
número asociado. En un ábaco suelen ser miles, centenas, decenas y unidades (en el lenguaje británico). En un byte son 128, 64, 32,
16, 8, 4, 2 y 1. A medida que los bits (señales de encendido/apagado) se envían por aire, el destinatario los recombina en bytes.

¿Has visto el patrón? (Pista: base 2.)

Sumando los números asociados con las posiciones en un byte que están activadas podemos representar números entre 0 y
255. La siguiente imagen muestra cómo funciona esto con cinco bits y contando de cero a 32:

42 Capítulo 1 Introducción
 BBC micro:bit Documentación de MicroPython, versión 1.0.1

Si podemos acordar qué representa cada uno de los 255 números (codificados por un byte) ~ como un carácter ~ entonces podemos comenzar
a enviar texto un carácter por byte a la vez.

Curiosamente, la gente yaPensé en esto~ el uso de bytes para codificar y decodificar información es algo común. Esto
corresponde aproximadamente a la capa de “protocolo” de código Morse en el ejemplo de red cableada.

Puede encontrar una serie realmente excelente de explicaciones amigables para niños (y maestros) sobre "todo lo relacionado con bytes" en elCS desconectado sitio
web.

1.13.3 Direccionamiento

El problema de la radio es que no se puede transmitir directamente a una sola persona. Cualquier persona con una antena adecuada puede
recibir los mensajes que transmites. Como resultado, es importante poder diferenciar quién debería recibir las transmisiones.

La forma en que la radio integrada en el micro:bit resuelve este problema es bastante simple:

• Es posible sintonizar la radio en diferentes canales (numerados del 0 al 83). Esto funciona exactamente de la misma manera
que los walkie-talkie para niños: todos sintonizan el mismo canal y todos escuchan lo que los demás transmiten a través de
ese canal. Al igual que con los walkie-talkies, si utiliza canales adyacentes existe una pequeña posibilidad de interferencias.

• El módulo de radio le permite especificar dos datos: una dirección y un grupo. La dirección es como una dirección
postal, mientras que un grupo es como un destinatario específico en la dirección. Lo importante es que la radio filtrará
los mensajes que reciba que no coincidan.sudirección y grupo. Como resultado, es importante organizar previamente
la dirección y el grupo que utilizará su aplicación.

Por supuesto, el micro:bit sigue recibiendo mensajes de difusión para otras combinaciones de dirección/grupo. Lo importante es que
no necesita preocuparse por filtrarlos. Sin embargo, si alguien fuera lo suficientemente inteligente, podría simplemente leertodo el
tráfico de la red inalámbricasin importar cuál se suponía que fuera la dirección/grupo objetivo. En este caso, es básicoutilizar medios
de comunicación cifrados para que solo el destinatario deseado pueda leer el mensaje que se transmitió. La criptografía es un tema
fascinante pero, desafortunadamente, está más allá del alcance de este tutorial.

1.13.4 Luciérnagas

Esta es una luciérnaga:

Es una especie de insecto que utiliza la bioluminiscencia para enviar señales (sin cables) a sus amigos. Así es como se ven cuando se
hacen señales entre sí:

La BBC tieneun video bastante hermosode luciérnagas disponibles en línea.

Usaremos el módulo de radio para crear algo parecido a un enjambre de luciérnagas que se envían señales entre sí.

Primeroimportar radiopara que las funciones estén disponibles para su programa Python. Entonces llama alradio.on()función para
encender la radio. Dado que la radio consume energía y memoria, lo hemos hecho así.túdecidir cuándo está habilitado (hay, por
supuesto, unradio.apagado()función).

En este punto, el módulo de radio está configurado con valores predeterminados razonables que lo hacen compatible con otras plataformas
que puedan apuntar al BBC micro:bit. Es posible controlar muchas de las funciones analizadas anteriormente (como el canal y el
direccionamiento), así como la cantidad de energía utilizada para transmitir mensajes y la cantidad de RAM que ocupará la cola de mensajes
entrantes. La documentación API contiene toda la información que necesita para configurar la radio según sus necesidades.

Suponiendo que estemos satisfechos con los valores predeterminados, la forma más sencilla de enviar un mensaje es así:

radio.enviar("un mensaje")

1.13. Radio 43
BBC micro:bit Documentación de MicroPython, versión 1.0.1

El ejemplo utiliza elenviarfunción para simplemente transmitir la cadena "un mensaje". Recibir un mensaje es aún más fácil:

nuevo mensaje=radio.recibir()

A medida que se reciben los mensajes, se colocan en una cola de mensajes. ElrecibirLa función devuelve el mensaje más antiguo de
la cola como una cadena, dejando espacio para un nuevo mensaje entrante. Si la cola de mensajes se llena, los nuevos mensajes
entrantes se ignoran.

¡Eso es realmente todo lo que hay que hacer! (Aunque el módulo de radio también es lo suficientemente potente como para que pueda enviar cualquier tipo de datos
arbitrario, no solo cadenas. Consulte la documentación de la API para saber cómo funciona).

Armado con este conocimiento, es sencillo hacer luciérnagas micro:bit como esta:

# Una luciérnaga micro:bit.

# Por Nicholas H. Tollervey. Liberado al dominio público. importarradio

importaraleatorio
demicrobitimportarpantalla, imagen, botón_a, suspensión

# Crea los fotogramas de animación "flash". ¿Puedes averiguar cómo se hace? destello=
[Imagen().invertir()*(i/9)paraienrango(9,-1,-1)]

# La radio no funcionará a menos que esté encendida. radio.

en()

# Bucle de eventos.
mientras que verdadero:

# El botón A envía un mensaje "flash". si

botón_a.estaba_presionado():
radio.enviar('destello')#a-ja
# Leer los mensajes entrantes.
entrante=radio.recibir() sientrante==
'destello':
# Si hay un mensaje "flash" entrante
# la animación flash de la luciérnaga después de un corto aleatorio
# pausa.
dormir (aleatorio.randint(50,350)) mostrar.mostrar
(destello, retraso=100, esperar=FALSO)
# Retransmitir aleatoriamente el mensaje flash después de un
# leve retraso.
sialeatorio.randint(0,9)==0:
dormir(500)
radio.enviar('destello')#a-ja

Las cosas importantes suceden en el bucle de eventos. Primero, verifica si se presionó el botón A y, si así fue, usa la radio para enviar
el mensaje “flash”. Luego lee cualquier mensaje de la cola de mensajes conradio.recibir().Si hay un mensaje, duerme durante un
breve periodo de tiempo aleatorio (para que la visualización sea más interesante) y utilizamostrar.mostrar() para animar el destello
de una luciérnaga. Finalmente, para hacer las cosas un poco interesantes, elige un número aleatorio para tener una probabilidad de
1 entre 10 de retransmitir el mensaje "flash" a cualquier otra persona (así es como es posible mantener la visualización de la
luciérnaga entre varios dispositivos). . Si decide retransmitir, espera medio segundo (para que la visualización del mensaje flash
inicial tenga la posibilidad de apagarse) antes de enviar la señal "flash" nuevamente. Debido a que este código está encerrado dentro
de un mientras que verdaderobloque, vuelve al principio del bucle de eventos y repite este proceso para siempre.

El resultado final (usando un grupo de micro:bits) debería verse así:

44 Capítulo 1 Introducción
 BBC micro:bit Documentación de MicroPython, versión 1.0.1

1.14 Próximos pasos

Estos tutoriales son solo los primeros pasos para usar MicroPython con BBC micro:bit. Una analogía musical: tienes
conocimientos básicos de un instrumento muy sencillo y tocas con confianza “Three Blind Mice”.

Este es un logro sobre el que construir.

Por delante tienes un viaje emocionante para convertirte en un codificador virtuoso.

Encontrarás frustración, fracaso y tontería. Cuando lo hagas, recuerda que no estás solo. Python tiene un arma
secreta: la comunidad de programadores más asombrosa del planeta. Conéctese con esta comunidad y hará amigos,
encontrará mentores, se apoyará mutuamente y compartirá recursos.

Los ejemplos de los tutoriales son sencillos de explicar, pero es posible que no sean las implementaciones más simples o eficientes. Hemos
dejado fuera muchoscosas realmente divertidaspara que podamos concentrarnos en brindarle lo básico. Si usteden realidadSi desea saber
cómo hacer que MicroPython vuele en el micro:bit de la BBC, lea la documentación de referencia de la API. Contiene información sobretodolas
capacidades disponibles para usted.

Explora, experimenta y no dudes en probar cosas, ya que estos son los atributos de un programador virtuoso. Para animarte hemos
escondido una serie dehuevos de Pascuaen MicroPython y los editores de código de Python. Son recompensas divertidas por mirar
“debajo del capó” y “hurgar con un palo”.

Esta habilidad en Python es valiosa: es uno de los lenguajes de programación profesional más populares del mundo.

¡Sorpréndenos con tu código! ¡Haz cosas que nos deleiten! ¡Sobre todo, diviértete!

¡Feliz pirateo!
Python es uno de losel mas popular del mundolenguajes de programación. Todos los días, sin darte cuenta, probablemente utilices
software escrito en Python. Todo tipo de empresas y organizaciones utilizan Python para una amplia gama de aplicaciones. Google,
NASA, Bank of America, Disney, CERN, YouTube, Mozilla, The Guardian: la lista continúa y cubre todos los sectores de la economía, la
ciencia y las artes.

Por ejemplo, ¿recuerda el anuncio de ladescubrimiento de las ondas gravitacionales? Los instrumentos utilizados para
realizar las mediciones fueron controladoscon pitón.

En pocas palabras, si enseñas o aprendes Python, estás desarrollando una habilidad muy valiosa que se aplica a todas las áreas del esfuerzo
humano.

Una de esas áreas es el sorprendente dispositivo micro:bit de la BBC. Ejecuta una versión de Python llamada MicroPython que está diseñada
para ejecutarse en computadoras pequeñas como la BBC micro:bit. Es una implementación completa de Python 3, por lo que cuando pases a
otras cosas (como programar Python en una Raspberry Pi) usarás exactamente el mismo lenguaje.

MicroPython no incluye todas las bibliotecas de código estándar que vienen con Python "normal". Sin embargo, hemos
creado un especialmicrobitmódulo en MicroPython que le permite controlar el dispositivo.

Python y MicroPython son software gratuito. Esto no solo significa que no pagas nada por usar Python, sino que también eres libre
de contribuir a la comunidad Python. Esto puede ser en forma de código, documentación, informes de errores, gestión de un grupo
comunitario o redacción de tutoriales (como este). De hecho, todos los recursos relacionados con Python para BBC micro:bit han sido
creados por un equipo internacional de voluntarios que trabajan en su tiempo libre.

Estas lecciones presentan MicroPython y BBC micro:bit en pasos fáciles de seguir. Siéntase libre de adoptarlos y adaptarlos
para lecciones presenciales, o tal vez simplemente seguirlos por su cuenta en casa.

Tendrás mayor éxito si exploras, experimentas y juegas. No puedes romper un micro:bit de la BBC escribiendo código incorrecto.
¡Sólo sumérgete!

Una palabra de advertencia:fallaras muchas veces, y eso está bien.El fracaso es la forma en que aprenden los buenos desarrolladores de software.
Aquellos de nosotros que trabajamos como desarrolladores de software nos divertimos mucho rastreando errores y evitando la repetición de errores.

En caso de duda, recuerda el Zen de MicroPython:

1.14. Próximos pasos 45

BBC micro:bit Documentación de MicroPython, versión 1.0.1

Código,
Hackearlo,
Menos es más,
Mantenlo simple,
Lo pequeño es hermoso,

¡Sé valiente! ¡Romper cosas! ¡Aprende y diviértete!

Exprésate con MicroPython.

¡Feliz pirateo! :-)

¡Toda la suerte!

46 Capítulo 1 Introducción
 CAPÍTULO 2

micro: bit API de Micropython

2.1 El módulo de microbits

Todo lo directamente relacionado con la interacción con el hardware reside en elmicrobitmódulo. Para facilitar su uso, se recomienda
iniciar todos los scripts con:

demicrobitimportar*

La siguiente documentación supone que usted ha hecho esto. Hay

algunas funciones disponibles directamente:

# dormir durante el número de milisegundos indicado.

dormir (sra)
# devuelve el número de milisegundos desde la última vez que se encendió el micro:bit. tiempo de
ejecución()
# hace que el micro:bit entre en modo de pánico (esto suele ocurrir cuando se ejecuta el DAL)
# sin memoria y provoca que se dibuje una cara triste en la pantalla). El error
# código puede ser cualquier valor entero arbitrario.
pánico (código_error)
# restablece el micro:bit.
reiniciar()

El resto de la funcionalidad la proporcionan objetos y clases en el módulo de microbits, como se describe a continuación.

Tenga en cuenta que la API sólo expone números enteros (es decir, no se necesitan flotantes, pero pueden aceptarse). Por tanto, utilizamos milisegundos como
unidad de tiempo estándar.

Nota:Puedes ver una lista de todos los módulos disponibles escribiendoayuda('módulos')en la REPL.

47
BBC micro:bit Documentación de MicroPython, versión 1.0.1

2.1.1 Botones

Hay 2 botones:

botón_a
botón_b

Ambos son objetos y tienen los siguientes métodos:

# devuelve Verdadero o Falso para indicar si el botón está presionado en el momento de

# la llamada al método.
botón.se presiona()
# devuelve Verdadero o Falso para indicar si el botón fue presionado desde el dispositivo
# comenzó o la última vez que se llamó a este método. botón.
estaba_presionado()
# devuelve el total acumulado de pulsaciones de botones y restablece este contador a cero botón.
get_presses()

2.1.2 La pantalla LED

La pantalla LED está expuesta a través delmostrarobjeto:

# obtiene el brillo del píxel (x,y). El brillo puede ser desde 0 (el píxel
# está desactivado) a 9 (el píxel tiene el brillo máximo). mostrar.
get_pixel(x,y)
# establece el brillo del píxel (x,y) en val (entre 0 [off] y 9 [max
# brillo], inclusive). mostrar.
set_pixel(x, y, valor)
# borra la pantalla. mostrar.
claro()
# muestra la imagen.
mostrar.mostrar (imagen, retraso=0, esperar=Verdadero, bucle=FALSO, claro=FALSO)
# muestra cada imagen o letra en el iterable, con retraso ms. entre cada uno. mostrar.mostrar (iterable,
retrasar=400, esperar=Verdadero, bucle=FALSO, claro=FALSO)
# desplaza una cadena por la pantalla (más interesante que display.show para
# mensajes escritos).
mostrar.desplazamiento (cadena, retraso=400)

2.1.3 Pines

Proporciona funcionalidad de entrada y salida digital y analógica para los pines del conector. Algunos pines están conectados
internamente a la E/S que controla la matriz de LED y los botones.

Cada pin se proporciona como un objeto directamente en elmicrobitmódulo. Esto mantiene la API relativamente plana, lo que la hace muy fácil
de usar:

• pin0
• pin1
•...
• clavija 15

• pin16
• Advertencia: P17-P18 (inclusive) no están disponibles.

48 Capítulo 2. API de Micropython micro:bit

 BBC micro:bit Documentación de MicroPython, versión 1.0.1

• pin19
• pin20
Cada uno de estos pines son instancias de laMicroBitPinclase, que ofrece la siguiente API:

# el valor puede ser 0, 1, Falso, Verdadero

alfiler.escribir_digital(valor)
# devuelve 1 o 0 alfiler.
lectura_digital()
# valor está entre 0 y 1023 alfiler.
escribir_analógico (valor)
# devuelve un número entero entre 0 y 1023 alfiler.
lectura_analógica()
# establece el período de la salida PWM del pin en milisegundos
# (ver https://en.wikipedia.org/wiki/Pulse-width_modulation) alfiler.
set_analog_period(En t)
# establece el período de la salida PWM del pin en microsegundos
# (ver https://en.wikipedia.org/wiki/Pulse-width_modulation) alfiler.
set_analog_period_microsegundos(En t)
# devuelve booleano
alfiler.está_tocado()

2.1.4 Imágenes

Nota:No siempre es necesario crear uno de estos usted mismo: puede acceder a la imagen que se muestra en la pantalla directamente con
mostrar imagen.mostrar imagenes solo un ejemplo deImagen, para que puedas utilizar todos los mismos métodos.

API de imágenes:

# crea una imagen vacía de 5x5

imagen=Imagen()
# crear una imagen a partir de una cadena: cada carácter de la cadena representa una
# LED: 0 (o espacio) está apagado y 9 es el brillo máximo. El colon ":"
# indica el final de una línea.
imagen=Imagen('90009:09090:00900:09090:90009:')
# crear una imagen vacía de un tamaño
determinado imagen=Imagen (ancho, alto)
# inicializa una imagen con el ancho y alto especificados. el buffer
# debe ser una matriz de largo ancho * alto imagen=Imagen
(ancho, alto, buffer)

# métodos
# devuelve el ancho de la imagen (normalmente 5)
imagen.ancho()
# devuelve la altura de la imagen (más a menudo 5)
imagen.altura()
# establece el píxel en la posición especificada (entre 0 y 9). Puede fallar por
# imágenes constantes.
imagen.set_pixel(x, y, valor)
# obtiene el píxel en la posición especificada (entre 0 y 9) imagen.get_pixel(x,y)

# devuelve una nueva imagen creada desplazando la imagen hacia la izquierda 'n' veces.
imagen.shift_left(n)
# devuelve una nueva imagen creada desplazando la imagen hacia la derecha 'n' veces.
(continúa en la página siguiente)

2.1. El módulo de microbits 49

BBC micro:bit Documentación de MicroPython, versión 1.0.1

(Continuación de la página anterior)

imagen.mayús_derecha(n)
# devuelve una nueva imagen creada desplazando la imagen hacia arriba 'n' veces.
imagen.cambio_arriba(n)
# devuelve una nueva imagen creada desplazando la imagen hacia abajo 'n' veces. imagen.
shift_down(n)
# obtener una representación de cadena compacta de la imagen
representante(imagen)
# obtener una representación de cadena más legible de la imagen cadena
(imagen)

# operadores
# devuelve una nueva imagen creada superponiendo las dos imágenes imagen+
imagen
# devuelve una nueva imagen creada multiplicando el brillo de cada píxel por n imagen*norte

# imágenes incorporadas.
Imagen.CORAZÓN
Imagen.CORAZÓN_PEQUEÑO
Imagen.FELIZ
Imagen.SONRISA
Imagen.TRISTE
Imagen.CONFUNDIDO
Imagen.ENOJADO
Imagen.DORMIDO
Imagen.SORPRENDIDO
Imagen.TONTO
Imagen.FABULOSO
Imagen.MEH
Imagen.SÍ
Imagen.NO
Imagen.RELOJ12#reloj a las 12 en punto Imagen.
RELOJ11
. . . # muchos relojes (Imagen.CLOCKn)
Imagen.RELOJ1#reloj a la 1 en punto Imagen
.FLECHA_N
. . . # flechas que apuntan a N, NE, E, SE, S, SW, W, NW (microbit.Image.ARROW_direction) Imagen.
FLECHA_NO
Imagen.TRIÁNGULO
Imagen.TRIANGLE_LEFT
Imagen.TABLERO DE AJEDREZ
Imagen.DIAMANTE
Imagen.DIAMANTE_PEQUEÑO
Imagen.CUADRADO
Imagen.CUADRADO_PEQUEÑO
Imagen.CONEJO
Imagen.VACA
Imagen.MÚSICA_CROCHET
Imagen.MÚSICA_QUAVER
Imagen.MUSIC_QUAVERS
Imagen.HORCA
Imagen.NAVIDAD
Imagen.PACMAN
Imagen.OBJETIVO
Imagen.CAMISETA
Imagen.PATÍN
Imagen.PATO
(continúa en la página siguiente)

50 Capítulo 2. API de Micropython micro:bit

 BBC micro:bit Documentación de MicroPython, versión 1.0.1

(Continuación de la página anterior)

Imagen.CASA
Imagen.TORTUGA
Imagen.MARIPOSA
Imagen.FIGURA DE PALO
Imagen.FANTASMA
Imagen.ESPADA
Imagen.JIRAFA
Imagen.CRÁNEO
Imagen.PARAGUAS
Imagen.SERPIENTE
# listas integradas: útiles para animaciones, por ejemplo, display.show(Image.ALL_CLOCKS) Imagen.
TODOS LOS RELOJES
Imagen.TODAS_FLECHAS

2.1.5 El acelerómetro

Se accede al acelerómetro a través delacelerómetroobjeto:

# leer el eje X del dispositivo. Medido en mili-g. acelerómetro.

obtener_x()
# leer el eje Y del dispositivo. Medido en mili-g. acelerómetro.
obtener_y()
# leer el eje Z del dispositivo. Medido en mili-g. acelerómetro.
obtener_z()
# obtener tupla de las tres lecturas X, Y y Z (enumeradas en ese orden). acelerómetro.
obtener_valores()
# devuelve el nombre del gesto actual. acelerómetro.
gesto_actual()
# devuelve Verdadero o Falso para indicar si el gesto nombrado está actualmente activo. acelerómetro
.es_gesto(nombre)
# devuelve Verdadero o Falso para indicar si el gesto nombrado estuvo activo desde el
# última llamada.
acelerómetro.era_gesto(nombre)
# devolver una tupla del historial de gestos. El más reciente aparece en último lugar.
acelerómetro.obtener_gestos()

Los gestos reconocidos son:arriba, abajo, izquierda, derecha, boca arriba, boca abajo, caída libre, 3g, 6g, 8g, agitar.

2.1.6 La brújula

Se accede a la brújula a través delBrújulaobjeto:

# calibrar la brújula (esto es necesario para obtener lecturas precisas). Brújula.calibrar()

# devuelve una indicación numérica de grados desplazados desde "norte". Brújula.

título()
# devolver una indicación numérica de la fuerza del campo magnético alrededor
# el micro:bit.
Brújula.get_field_strength()
# devuelve Verdadero o Falso para indicar si la brújula está calibrada. Brújula.
está_calibrado()
# restablece la brújula a un estado de precalibración. Brújula.
calibración_clara()

2.1. El módulo de microbits 51

BBC micro:bit Documentación de MicroPython, versión 1.0.1

2.1.7 Autobús I2C

Hay un bus I2C en el micro:bit que está expuesto a través deli2cobjeto. Tiene los siguientes métodos:

# leer n bytes del dispositivo con addr; repetir=True significa que un bit de parada no funcionará
# ser enviado.
i2c.leer(dirección, n, repetir=FALSO)
# escribe buf en el dispositivo con addr; repetir=True significa que no se enviará un bit de parada. i2c.
escribir(dirección, buf, repetir=FALSO)

2.1.8 UART

Usaruartepara comunicarse con un dispositivo serie conectado a los pines de E/S del dispositivo:

# configurar la comunicación (use los pines 0 [TX] y 1 [RX]) con una velocidad de 9600 baudios. uarte.en
eso()
# devuelve Verdadero o Falso para indicar si hay caracteres entrantes esperando
# ser leido.
uarte.cualquier()
# devolver (leer) n caracteres entrantes. uarte.
leer(n)
# devolver (leer) tantos datos entrantes como sea posible. uarte.
leer()
# devolver (leer) todos los caracteres hasta que se alcance un carácter de nueva línea. uarte.
línea de lectura()
# leer bytes en el búfer al que se hace referencia.
uarte.leer en (búfer)
# escribe bytes desde el búfer al dispositivo conectado. uarte.escribir
(búfer)

52 Capítulo 2. API de Micropython micro:bit

 CAPÍTULO 3

Módulo de microbits

ElmicrobitEl módulo le brinda acceso a todo el hardware integrado en su placa.

3.1 Funciones

microbit.pánico(norte)
Entra en modo pánico. Requiere reinicio. Pase un número entero arbitrario <= 255 para indicar un estado:

microbit.pánico(255)

microbit.reiniciar()
Reinicie el tablero.

microbit.dormir(norte)
Esperarnortemilisegundos. Un segundo son 1000 milisegundos, entonces:

microbit.dormir(1000)

pausará la ejecución durante un segundo.nortepuede ser un número entero o de coma flotante.

microbit.tiempo de ejecución()
Devuelve el número de milisegundos desde que se encendió o reinició la placa.

microbit.temperatura()
Devuelve la temperatura del micro:bit en grados Celsius.

3.2 Atributos

3.2.1 Botones

Hay dos botones en el tablero, llamadosbotón_aybotón_b.

53
BBC micro:bit Documentación de MicroPython, versión 1.0.1

Atributos

botón_a
ABotóninstancia (ver más abajo) que representa el botón izquierdo.

botón_b
Representa el botón derecho.

Clases

Botón de clase
Representa un botón.

Nota:Esta clase en realidad no está disponible para el usuario, solo la utilizan las dos instancias de botón, que se
proporcionan ya inicializadas.

se presiona()
DevolucionesVerdaderosi el botón especificadobotónactualmente está siendo mantenido presionado, yFALSOde lo contrario.

estaba_presionado()
DevolucionesVerdaderooFALSOpara indicar si el botón fue presionado (fue de arriba a abajo) desde que se inició el dispositivo o
la última vez que se llamó a este método. Llamar a este método borrará el estado de pulsación, por lo que el botón deberá
presionarse nuevamente antes de que este método regreseVerdaderode nuevo.

get_presses()
Devuelve el total acumulado de pulsaciones de botones y restablece este total a cero antes de regresar.

Ejemplo

importarmicrobit

mientras que verdadero:

simicrobit.botón_a.se presiona()ymicrobit.botón_b.se presiona():

microbit.mostrar.Desplazarse("AB")
romper
elifmicrobit.botón_a.se presiona():
microbit.mostrar.Desplazarse("A") elif
microbit.botón_b.se presiona():
microbit.mostrar.Desplazarse("B")
microbit.dormir(100)

3.2.2 Pines de entrada/salida

Los pines son la forma en que su placa se comunica con los dispositivos externos conectados a ella. Hay 19 pines a tu disposición,
numerados del 0 al 16 y del 19 al 20. Los pines 17 y 18 no están disponibles.

Por ejemplo, el siguiente script cambiará la visualización en el micro:bit dependiendo de la lectura digital en el pin 0:

demicrobitimportar*

mientras que verdadero:

sipin0.lectura_digital():
(continúa en la página siguiente)

54 Capítulo 3. Módulo de microbits

 BBC micro:bit Documentación de MicroPython, versión 1.0.1

(Continuación de la página anterior)

mostrar.mostrar imagen.FELIZ)
demás:
mostrar.mostrar imagen.TRISTE)

Funciones de pines

Esos pines están disponibles como atributos en elmicrobitmódulo:microbit.pin0 - microbit.pin20.

3.2. Atributos 55
BBC micro:bit Documentación de MicroPython, versión 1.0.1

Alfiler Tipo Función

0 Tocar Almohadilla 0

1 Tocar Almohadilla 1

2 Tocar Almohadilla 2

3 Cosa análoga Columna 1

4 Cosa análoga Columna 2
5 Digital Botón A
6 Digital Fila 2
7 Digital Fila 1
8 Digital
9 Digital Fila 3
10 Cosa análoga Columna 3
11 Digital Botón B
12 Digital
13 Digital SPI MOSI
14 Digital SPI MISO
15 Digital SPI SCK
dieciséis Digital

19 Digital I2C SCL

20 Digital I2C SDA

La tabla anterior resume los pines disponibles, sus tipos (ver más abajo) y a qué están conectados internamente.

Modulación de ancho de pulso

Los pines de su placa no pueden emitir una señal analógica de la misma manera que lo hace un amplificador de audio: modulando el
voltaje en el pin. Esos pines solo pueden habilitar la salida completa de 3,3 V o reducirla a 0 V. Sin embargo, todavía es posible
controlar el brillo de los LED o la velocidad de un motor eléctrico, encendiendo y apagando ese voltaje muy rápidamente y
controlando cuánto tiempo está encendido y cuánto tiempo está apagado. Esta técnica se llama modulación de ancho de pulso
(PWM) y eso es lo queescritura_analógicaEl método siguiente lo hace.

56 Capítulo 3. Módulo de microbits

 BBC micro:bit Documentación de MicroPython, versión 1.0.1

Arriba puedes ver los diagramas de tres señales PWM diferentes. Todos ellos tienen el mismo período (y por tanto
frecuencia), pero tienen diferentes ciclos de trabajo.

El primero sería generado porescribir_analógico (511),ya que tiene exactamente el 50% de servicio: la energía está encendida la mitad del
tiempo y apagada la mitad del tiempo. El resultado de esto es que la energía total de esta señal es la misma, como si fuera 1,65V en lugar de
3,3V.

La segunda señal tiene un ciclo de trabajo del 25% y podría generarse conescribir_analógico (255).Tiene un efecto similar al
de si se emitieran 0,825 V en ese pin.

La tercera señal tiene un ciclo de trabajo del 75% y se puede generar conescribir_analógico (767).Tiene tres veces más
energía que la segunda señal y equivale a emitir 2.475V en el pin.

Tenga en cuenta que esto funciona bien con dispositivos como motores, que tienen una gran inercia por sí mismos, o LED, que parpadean
demasiado rápido para que el ojo humano vea la diferencia, pero no funcionarán tan bien generando ondas sonoras. Esta placa solo puede
generar sonidos de ondas cuadradas en sí misma, que suenan muy parecidos a los juegos de computadora muy antiguos, principalmente
porque esos juegos también podían hacer eso.

Clases

Hay tres tipos de pines, que se diferencian en lo que están disponibles para ellos. Están representados por las clases que se enumeran a continuación.
Tenga en cuenta que forman una jerarquía, de modo que cada clase tiene toda la funcionalidad de la clase anterior y le agrega la suya propia.

Nota:Esas clases en realidad no están disponibles para el usuario, no se pueden crear nuevas instancias de ellas. Solo puedes usar las
instancias ya proporcionadas, que representan los pines físicos de tu tablero.

clasemicrobit.MicroBitDigitalPin

3.2. Atributos 57
BBC micro:bit Documentación de MicroPython, versión 1.0.1

lectura_digital()
Devuelve 1 si el pin está alto y 0 si está bajo.

escribir_digital(valor)
Coloque el pin en alto sivalores 1, o demasiado bajo, si es 0.

clasemicrobit.MicroBitAnalógicoDigitalPin

lectura_analógica()
Lea el voltaje aplicado al pin y devuélvalo como un número entero entre 0 (es decir, 0 V) y 1023 (es decir, 3,3 V).

escritura_analógica(valor)
Emita una señal PWM en el pin, con el ciclo de trabajo proporcional al proporcionadovalor.Elvalor puede ser un
número entero o de punto flotante entre 0 (0% de ciclo de trabajo) y 1023 (100% de trabajo).

set_analog_period(período)
Establezca el período de salida de la señal PWM enperíodoen milisegundos. El valor mínimo válido es 1
ms.

set_analog_period_microsegundos(período)
Establezca el período de salida de la señal PWM enperíodoen microsegundos. El valor mínimo válido es 256 µs.

clasemicrobit.MicroBitAnalógicoDigitalPin

lectura_analógica()
Lea el voltaje aplicado al pin y devuélvalo como un número entero entre 0 (es decir, 0 V) y 1023 (es decir, 3,3 V).

clasemicrobit.MicroBitTouchPin

esta_tocado()
DevolverVerdaderosi el pasador se toca con un dedo; en caso contrario, devuélvaloFALSO.

Esta prueba se realiza midiendo cuánta resistencia hay entre el pasador y tierra. Una resistencia baja da una
lectura deVerdadero.Para obtener una lectura confiable con un dedo, es posible que deba tocar el pin de tierra
con otra parte de su cuerpo, por ejemplo con la otra mano.

El modo de extracción de un pin se configura automáticamente cuando el pin cambia a un modo de entrada. Los modos de entrada
son cuando llamasread_analog/read_digital/is_touched.El modo de extracción predeterminado para estos es, respectivamente,
NO_PULL, PULL_DOWN, PULL_UP.Vocaciónconjunto_pullconfigurará el pin para que esté enlectura_digitalmodo con el modo de
extracción dado.

Nota: El micro:bit tiene pull-ups externos débiles (10M) instalados en los pines 0, 1 y 2 únicamente, para que la detección táctil
trabajar.

También hay dominadas externas (10k) montadas en los pines 5 y 11, para que funcionen los botones A y B.

Los pines GPIO también se utilizan para la pantalla. 6 de estos se dirigen al conector de borde en 3, 4, 6, 7, 9 y 10. Si desea utilizar
estos pines para otro propósito, es posible que deba girar elpantalla apagada.

Ver elhoja de datos del conector de borde.

58 Capítulo 3. Módulo de microbits

 BBC micro:bit Documentación de MicroPython, versión 1.0.1

3.3 Clases

3.3.1 Imagen

ElImagenLa clase se utiliza para crear imágenes que se pueden mostrar fácilmente en la matriz de LED del dispositivo. Dado un
objeto de imagen, es posible mostrarlo a través delmostrarAPI:

mostrar.mostrar imagen.FELIZ)

Hay cuatro formas de construir una imagen:

• Imagen() -Crea una imagen en blanco de 5x5

• Imagen (cadena) -Cree una imagen analizando la cadena, un solo carácter devuelve ese glifo
• Imagen (ancho, alto) -Crea una imagen en blanco de un tamaño determinado.

• Imagen (ancho, alto, búfer) -Crea una imagen a partir del búfer dado.

Clases

clase microbit.Imagen(cadena)
clase microbit.Imagen(ancho=Ninguno,altura=Ninguno,buffer=Ninguno)
SicadenaSi se utiliza, debe constar de dígitos del 0 al 9 dispuestos en líneas, que describan la imagen, por ejemplo:

3.3. Clases 59
BBC micro:bit Documentación de MicroPython, versión 1.0.1

imagen=Imagen("90009:"
"09090:"
"00900:"
"09090:"
"90009")

creará una imagen de 5 × 5 de una X. El final de una línea se indica con dos puntos. También es posible utilizar una nueva línea (n) para
indicar el final de una línea como esta:

imagen=Imagen("90009\norte"
"09090\norte"
"00900\norte"
"09090\norte"
"90009")

La otra forma crea una imagen vacía conanchocolumnas yalturafilas. Opcionalmentebufferpuede ser una serie
deancho``×``altonúmeros enteros en el rango 0-9 para inicializar la imagen:

Imagen(2,2,b'\x08\x08\x08\x08')

o:
Imagen(2,2,matriz de bytes([9,9,9,9]))

Creará una imagen de 2 x 2 píxeles con brillo máximo.

Nota:Los argumentos de palabras clave no se pueden pasar abuffer.

ancho()
Devuelve el número de columnas de la imagen.

altura()
Devuelve los números de filas de la imagen.

conjunto_pixel(X,y,valor)
Establecer el brillo del píxel en la columnaXy remaryhaciavalor,que tiene que estar entre 0 (oscuro) y 9
(brillante).

Este método generará una excepción cuando se llame a cualquiera de las imágenes integradas de solo lectura, comoImagen. CORAZÓN.

obtener_píxel(X,y)
Devuelve el brillo del píxel en la columna.Xy remarycomo un número entero entre 0 y 9.

shift_left(norte)
Devuelve una nueva imagen creada desplazando la imagen dejada pornortecolumnas.

shift_right(norte)
Igual queimagen.shift_left(-n).
cambio_arriba(norte)
Devuelve una nueva imagen creada desplazando la imagen hacia arribanortefilas.

mayúsculas_abajo(norte)
Igual queimagen.shift_up(-n).
cultivo(X,y,w,h)
Devuelva una nueva imagen recortándola a un ancho dewy una altura deh,comenzando con el píxel en la
columnaXy remary.

60 Capítulo 3. Módulo de microbits

 BBC micro:bit Documentación de MicroPython, versión 1.0.1

Copiar()
Devuelve una copia exacta de la imagen.

invertir()
Devuelve una nueva imagen invirtiendo el brillo de los píxeles en la imagen de origen.

llenar(valor)
Establezca el brillo de todos los píxeles de la imagen en elvalor,que tiene que estar entre 0 (oscuro) y 9
(brillante).

Este método generará una excepción cuando se llame a cualquiera de las imágenes integradas de solo lectura, comoImagen. CORAZÓN.

relámpago(src,X,y,w,h,xdest=0,ydest=0)
Copia el rectángulo definido porx, y, w, hde la imagensrcen esta imagen enxdest, ydest.Las áreas en el rectángulo de
origen, pero fuera de la imagen de origen, se tratan como si tuvieran un valor de 0.

shift_left(), shift_right(), shift_up(), shift_down()ycultivo()todos pueden implementarse mediante el uso

relámpago().Por ejemplo, img.crop(x, y, w, h) se puede implementar como:

definicióncultivo(ser, x, y, w, h):
res=Imagen (ancho, alto)
res.relámpago(ser, x, y, w, h)
devolverres

Atributos

ElImagenLa clase también tiene las siguientes instancias integradas de sí misma incluidas como atributos (los nombres de los atributos indican
lo que representa la imagen):

• Imagen.CORAZÓN

• Imagen.HEART_SMALL
• Imagen.FELIZ
• Imagen.SONRISA

• Imagen.SAD
• Imagen.CONFUNDIDA

• Imagen.ENOJADO

• Imagen.ASLEEP
• Imagen.SORPRENDIDO

• Imagen.TONTA
• Imagen.FABULOSA
• Imagen.MEH
• Imagen.SÍ
• Imagen.NO
• Imagen.CLOCK12, Imagen.CLOCK11, Imagen.CLOCK10, Imagen.CLOCK9, Imagen.CLOCK8, Imagen.
RELOJ7, Imagen.RELOJ6, Imagen.RELOJ5, Imagen.RELOJ4, Imagen.RELOJ3, Imagen.RELOJ2,
Imagen.RELOJ1
• Imagen.ARROW_N, Imagen.ARROW_NE, Imagen.ARROW_E, Imagen.ARROW_SE, Imagen.ARROW_S,
Imagen.ARROW_SW, Imagen.ARROW_W, Imagen.ARROW_NW

3.3. Clases 61
BBC micro:bit Documentación de MicroPython, versión 1.0.1

• Imagen.TRIÁNGULO
• Imagen.TRIANGLE_LEFT
• Imagen.TABLERO DE AJEDREZ

• Imagen.DIAMOND
• Imagen.DIAMOND_SMALL
• Imagen.CUADRADO

• Imagen.SQUARE_SMALL
• Imagen.CONEJO
• Imagen.COW

• Imagen.MUSIC_CROTCHET
• Imagen.MUSIC_QUAVER
• Imagen.MUSIC_QUAVERS
• Imagen.PITCHFORK
• Imagen.XMAS
• Imagen.PACMAN
• Imagen.OBJETIVO

• Imagen.CAMISETA

• Imagen.ROLLERSKATE
• Imagen.PATO
• Imagen.CASA
• Imagen.TORTUGA
• Imagen.MARIPOSA
• Imagen.STICKFIGURE
• Imagen. FANTASMA

• Imagen.ESPADA

• Imagen.JIRAFA
• Imagen.CRÁNEO

• Imagen.PARAGUAS
• Imagen.SERPIENTE

Finalmente, se han agrupado colecciones de imágenes relacionadas:

* ``Imagen.ALL_CLOCKS``
* ``Imagen.ALL_ARROWS``

Operaciones

representante(imagen)

62 Capítulo 3. Módulo de microbits

 BBC micro:bit Documentación de MicroPython, versión 1.0.1

Obtenga una representación de cadena compacta de la imagen.

cadena(imagen)

Obtenga una representación de cadena legible de la imagen.

imagen1+imagen2

Cree una nueva imagen sumando los valores de brillo de las dos imágenes para cada píxel.

imagen*norte

Crea una nueva imagen multiplicando el brillo de cada píxel pornorte.

3.4 Módulos

3.4.1 Pantalla

Este módulo controla la pantalla LED de 5×5 en el frente de su tablero. Se puede utilizar para mostrar imágenes, animaciones e
incluso texto.

Funciones

pantalla.de.microbits.obtener_píxel(X,y)
Devuelve el brillo del LED en la columna.Xy remarycomo un número entero entre 0 (apagado) y 9 (brillante).

pantalla.de.microbits.conjunto_pixel(X,y,valor)
Establezca el brillo del LED en la columnaXy remaryavalor,que tiene que ser un número entero entre 0 y 9.

pantalla.de.microbits.claro()
Establezca el brillo de todos los LED en 0 (apagado).

pantalla.de.microbits.espectáculo(imagen)
Mostrar elimagen.
pantalla.de.microbits.espectáculo(valor,retraso = 400,*,esperar = Verdadero,bucle = Falso,claro = falso)
Sivalores una cadena, flotante o entera, muestra letras/dígitos en secuencia. De lo contrario, sivalores una secuencia
iterable de imágenes, muestra estas imágenes en secuencia. Cada letra, dígito o imagen se muestra condemora
milisegundos entre ellos.

SiesperaresVerdadero,esta función se bloqueará hasta que finalice la animación; de lo contrario, la animación se realizará en
segundo plano.

SibucleesVerdadero,La animación se repetirá para siempre.

SiclaroesVerdadero,la pantalla se borrará una vez finalizado el iterable.

Tenga en cuenta que elespera, bucleyclaroLos argumentos deben especificarse utilizando su palabra clave.

Nota:Si utiliza un generador comoiterable,luego tenga cuidado de no asignar memoria en el generador, ya que está prohibido
asignar memoria en una interrupción y generará un error.Error de memoria.

3.4. Módulos 63
BBC micro:bit Documentación de MicroPython, versión 1.0.1

pantalla.de.microbits.Desplazarse(valor,retraso = 150,*,esperar = Verdadero,bucle = Falso,monoespacio=Falso)

Pergaminosvalorhorizontalmente en la pantalla. Sivalores un número entero o flotante, primero se convierte en una cadena usando
cadena().EldemoraEl parámetro controla qué tan rápido se desplaza el texto.

SiesperaresVerdadero,esta función se bloqueará hasta que finalice la animación; de lo contrario, la animación se realizará en
segundo plano.

SibucleesVerdadero,La animación se repetirá para siempre.

SimonoespacioesVerdadero,todos los caracteres ocuparán 5 columnas de píxeles de ancho; de lo contrario, habrá exactamente 1 columna de
píxeles en blanco entre cada carácter a medida que se desplazan.

Tenga en cuenta que elespera, bucleymonoespacioLos argumentos deben especificarse utilizando su palabra clave.

pantalla.de.microbits.en()
Utilice on() para encender la pantalla.

pantalla.de.microbits.apagado()
Utilice off() para apagar la pantalla (permitiéndole así reutilizar los pines GPIO asociados con la pantalla para otros
fines).

pantalla.de.microbits.Está encendido()
DevolucionesVerdaderosi la pantalla está encendida, en caso contrario regresaFALSO.

pantalla.de.microbits.nivel_luz_lectura()
Utilice los LED de la pantalla en modo de polarización inversa para detectar la cantidad de luz que cae sobre la pantalla. Devuelve un
número entero entre 0 y 255 que representa el nivel de luz, donde mayor significa más luz.

Ejemplo

Para desplazar continuamente una cadena por la pantalla y hacerlo en segundo plano, puede utilizar:

importarmicrobit

microbit.mostrar.Desplazarse('¡Hola!', esperar=FALSO, bucle=Verdadero)

3.4.2 UART

EluarteEl módulo le permite hablar con un dispositivo conectado a su placa mediante una interfaz serie.

Funciones

microbit.uart.en eso(velocidad en baudios=9600,bits=8,paridad=Ninguna,detener=1,*,tx=Ninguno,rx=Ninguno)

Inicialice la comunicación en serie con los parámetros especificados en eltxyRXpatas. Tenga en cuenta que para una
comunicación correcta, los parámetros deben ser los mismos en ambos dispositivos que se comunican.

Advertencia:Inicializar el UART en pines externos hará que la consola Python en USB deje de ser accesible,
ya que utiliza el mismo hardware. Para recuperar la consola debes reinicializar el UART sin pasar nada portx
oreceta (o pasandoNingunoa estos argumentos). Esto significa que llamaruart. inicio(115200)es suficiente
para restaurar la consola Python.

Elvelocidad en baudiosDefine la velocidad de la comunicación. Las velocidades en baudios comunes incluyen:

• 9600

64 Capítulo 3. Módulo de microbits

 BBC micro:bit Documentación de MicroPython, versión 1.0.1

• 14400
• 19200
• 28800
• 38400
• 57600
• 115200
Elbitsdefine el tamaño de los bytes que se transmiten y la placa solo admite 8. ElparidadEl parámetro define
cómo se verifica la paridad y puede serNinguno, microbit.uart.ODDomicrobit.uart.INCLUSO.El detenerEl
parámetro indica el número de bits de parada y debe ser 1 para esta placa.

SitxyRXno se especifican, entonces se utilizan los pines internos USB-UART TX/RX que se conectan al
convertidor serie USB en el micro:bit, conectando así el UART a su PC. Puede especificar cualquier otro pin que
desee pasando los objetos de pin deseados altxyRXparámetros.

Nota:Al conectar el dispositivo, asegúrese de "cruzar" los cables: el pin TX de su placa debe estar conectado con el pin
RX del dispositivo y el pin RX, con el pin TX del dispositivo. También asegúrese de que las clavijas de tierra de ambos
dispositivos estén conectadas.

uart.cualquier()
DevolverVerdaderosi hay algún dato esperando, de lo contrarioFALSO.

uart.leer([nbytes])
Leer bytes. Sinbytesse especifica, luego lea como máximo esa cantidad de bytes; de lo contrario, lea tantos bytes como sea posible.

Valor de retorno: un objeto de bytes oNingunoen tiempo de espera.

Un objeto de bytes contiene una secuencia de bytes. PorqueASCIILos caracteres pueden caber en bytes individuales. Este tipo de
objeto se utiliza a menudo para representar texto simple y ofrece métodos para manipularlo como tal, por ejemplo, puede mostrar el
texto usando elimprimir()función.

También puede convertir este objeto en un objeto de cadena y, si hay caracteres que no sean ASCII, se puede especificar la
codificación:

msg_bytes=uarte.leer() msg_str=
cadena(mensaje,'UTF-8')

Nota:El tiempo de espera para todas las lecturas de UART depende de la velocidad en baudios y, de lo contrario, no se puede modificar a través
de Python. El tiempo de espera, en milisegundos, viene dado por:microbit_uart_timeout_char = 13000 / velocidad en baudios
+1

Nota:El búfer interno UART RX tiene 64 bytes, así que asegúrese de leer los datos antes de que el búfer esté lleno o algunos de los
datos podrían perderse.

Advertencia:Recepción0x03detendrá su programa generando una interrupción del teclado. Puedes habilitar o

deshabilitar esto usandomicropython.kbd_intr().

uart.Lee todo()
Eliminado desde la versión 1.0.

3.4. Módulos sesenta y cinco

BBC micro:bit Documentación de MicroPython, versión 1.0.1

En su lugar, utiliceuart.leer()sin argumentos, que leerá la mayor cantidad de datos posible.

uart.leer en(buf[,nbytes])
Leer bytes en elbuf.Sinbytesse especifica y luego lee como máximo esa cantidad de bytes. De lo contrario, lea como máximo
len(buf)bytes.

Valor de retorno: número de bytes leídos y almacenados enbufoNingunoen tiempo de espera.

uart.línea de lectura()
Lee una línea que termina en un carácter de nueva línea.

Valor de retorno: la línea leída oNingunoen tiempo de espera. El carácter de nueva línea se incluye en los bytes devueltos.

uart.escribir(buf)
Escriba el búfer en el bus, puede ser un objeto de bytes o una cadena:

uarte.escribir('Hola Mundo') uarte.

escribir(hola mundo) uarte.escribir(
bytes([1,2,3]))

Valor de retorno: número de bytes escritos oNingunoen tiempo de espera.

3.4.3 SPI

ElespiEl módulo le permite hablar con un dispositivo conectado a su placa mediante un bus de interfaz periférica serie (SPI). SPI
utiliza la denominada arquitectura maestro-esclavo con un único maestro. Deberá especificar las conexiones para tres señales:

• SCLK: Reloj serie (salida del maestro).

• MOSI: Salida maestra, Entrada esclava (salida del maestro).

• MISO: Entrada maestra, Salida esclava (salida desde esclavo).

Funciones

microbit.spi.en eso(velocidad en baudios=1000000,bits=8,modo=0,sclk=pin13,mosi=pin15,miso=pin14)

Inicialice la comunicación SPI con los parámetros especificados en elpatas.Tenga en cuenta que para una comunicación
correcta, los parámetros deben ser los mismos en ambos dispositivos que se comunican.

Elvelocidad en baudiosDefine la velocidad de la comunicación.

Elbitsdefine el tamaño de los bytes que se transmiten. Actualmente solobits=8esta apoyado. Sin embargo, esto puede cambiar
en el futuro.

Elmododetermina la combinación de polaridad de reloj y fase de acuerdo con la siguiente convención, con la polaridad como
bit de orden superior y la fase como bit de orden inferior:

Modo SPI Polaridad (CPOL) Fase (CPHA)

0 0 0
1 0 1
2 1 0
3 1 1

Polaridad (también conocida como CPOL) 0 significa que el reloj está en el valor lógico 0 cuando está inactivo y sube (valor lógico 1) cuando está
activo; La polaridad 1 significa que el reloj está en el valor lógico 1 cuando está inactivo y baja (valor lógico 0) cuando está activo. Fase (también
conocida como CPHA) 0 significa que los datos se muestrean en el flanco anterior del reloj, y 1 significa en el flanco posterior (a saber.https://
en.wikipedia.org/wiki/Signal_edge).

66 Capítulo 3. Módulo de microbits

 BBC micro:bit Documentación de MicroPython, versión 1.0.1

Elsclk, mosiymisoLos argumentos especifican los pines que se utilizarán para cada tipo de señal.

espí.leer(nbytes)
Leer como muchonbytes.Devuelve lo leído.
espí.escribir(buffer)
Escribe elbufferde bytes al bus.
espí.escribir_leer en(afuera,en)
Escribe elafuerabuffer al bus y leer cualquier respuesta en elenbuffer. La longitud de los buffers debe ser la misma.
Los buffers pueden ser el mismo objeto.

3.4.4 Yo2C

Eli2cEl módulo le permite comunicarse con dispositivos conectados a su placa usando el I2Protocolo de bus C. Puede haber varios
dispositivos esclavos conectados al mismo tiempo y cada uno tiene su propia dirección única, que está fijada para el dispositivo o
configurada en él. Tu tablero actúa como el yo2Maestro C.

Usamos direccionamiento de 7 bits para dispositivos por las razones expuestasaquí.

Esto puede ser diferente a otras soluciones relacionadas con micro:bit.

Cómo exactamente debe comunicarse con los dispositivos, es decir, qué bytes enviar y cómo interpretar las respuestas, depende del
dispositivo en cuestión y debe describirse por separado en la documentación de ese dispositivo.

Funciones

microbit.i2c.en eso(frecuencia=100000,sda=pin20,scl=pin19)
Reinicialice el periférico con la frecuencia de reloj especificadafrecuenciaen el especificadosdaysclpatas.

Advertencia:Cambiando el yo2Los pines C predeterminados harán que el acelerómetro y la brújula dejen de funcionar, ya que
están conectados internamente a esos pines.

microbit.i2c.escanear()
Escanee el bus en busca de dispositivos. Devuelve una lista de direcciones de 7 bits correspondientes a aquellos dispositivos que respondieron al escaneo.

microbit.i2c.leer(dirección,norte,repetir = falso)
Leernortebytes del dispositivo con dirección de 7 bitsdirecciónSirepetiresVerdadero,no se enviará ningún bit de parada.

microbit.i2c.escribir(dirección,buf,repetir = falso)
Escribir bytes debufal dispositivo con dirección de 7 bitsdirecciónSirepetiresVerdadero,no se enviará ningún bit de parada.

Conectando

Debes conectar el dispositivoSCLpin al pin 19 de micro:bit, y el dispositivoASDpin al pin 20 de micro:bit. También debes conectar la
tierra del dispositivo a la tierra de micro:bit (pinTierra).Es posible que necesites alimentar el dispositivo mediante una fuente de
alimentación externa o el micro:bit.

Hay resistencias pull-up internas en el I2C de la placa, pero con cables particularmente largos o una gran cantidad de dispositivos, es posible
que necesite agregar resistencias pull-up adicionales para garantizar una comunicación sin ruido.

3.4. Módulos 67
BBC micro:bit Documentación de MicroPython, versión 1.0.1

3.4.5 Acelerómetro

Este objeto le da acceso al acelerómetro a bordo. El acelerómetro también ofrece funciones prácticas para detectar
gestos. Los gestos reconocidos son:arriba, abajo, izquierda, derecha, boca arriba, boca abajo, caída libre, 3g, 6g, 8g,
agitar.

De forma predeterminada, MicroPython establece el rango del acelerómetro en +/- 2 g; actualmente, no es posible cambiar el rango del
acelerómetro en MicroPython. El acelerómetro devuelve un valor en el rango de 0 a 1024 para cada eje, que luego se escala en consecuencia.

Funciones

acelerómetro.microbit.obtener_x()
Obtenga la medida de aceleración en elXeje, como un número entero positivo o negativo, dependiendo de la dirección. La
medida se da en mili-g. De forma predeterminada, el acelerómetro está configurado con un rango de +/- 2 g, por lo que este
método volverá dentro del rango de +/- 2000 mg.

acelerómetro.microbit.obtener_y()
Obtenga la medida de aceleración en elyeje, como un número entero positivo o negativo, dependiendo de la dirección. La
medida se da en mili-g. De forma predeterminada, el acelerómetro está configurado con un rango de +/- 2 g, por lo que este
método volverá dentro del rango de +/- 2000 mg.

acelerómetro.microbit.obtener_z()
Obtenga la medida de aceleración en elzeje, como un número entero positivo o negativo, dependiendo de la dirección. La
medida se da en mili-g. De forma predeterminada, el acelerómetro está configurado con un rango de +/- 2 g, por lo que este
método volverá dentro del rango de +/- 2000 mg.

acelerómetro.microbit.obtener_valores()
Obtenga las mediciones de aceleración en todos los ejes a la vez, como una tupla de tres elementos de números enteros ordenados como X, Y, Z.
De forma predeterminada, el acelerómetro está configurado con un rango de +/- 2 g, por lo que X, Y y Z estar dentro del rango de
+/-2000mg.

acelerómetro.microbit.gesto_actual()
Devuelve el nombre del gesto actual.

Nota:MicroPython entiende los siguientes nombres de gestos: "arriba", "abajo", "izquierda", "derecha", "boca arriba",
"boca abajo", "caída libre", "3g", "6g", "8g", "agitar".Los gestos siempre se representan como cadenas.

acelerómetro.microbit.es_gesto(nombre)
Devuelve Verdadero o Falso para indicar si el gesto nombrado está actualmente activo.

acelerómetro.microbit.era_gesto(nombre)
Devuelve Verdadero o Falso para indicar si el gesto nombrado estuvo activo desde la última llamada.

acelerómetro.microbit.obtener_gestos()
Devuelve una tupla del historial de gestos. El más reciente aparece en último lugar. También borra el historial de gestos antes de
regresar.

Nota:Los gestos no se actualizan en segundo plano, por lo que es necesario que haya llamadas constantes a algún método de acelerómetro para realizar
la detección de gestos. Normalmente los gestos se pueden detectar mediante un bucle con un pequeñomicrobit.dormir()demora.

68 Capítulo 3. Módulo de microbits

 BBC micro:bit Documentación de MicroPython, versión 1.0.1

Ejemplos

Una bola 8 mágica para adivinar la fortuna. Haga una pregunta y luego agite el dispositivo para obtener una respuesta.

# Bola mágica 8 de Nicholas Tollervey. Febrero de 2016.

#
# Haz una pregunta y luego agita.
#
# Este programa ha sido puesto en el dominio público. demicrobit
importar* importaraleatorio

respuestas=[
"Es cierto", "Es
decididamente así", "Sin
duda", "Sí definitivamente",

"Puedes confiar en ello",

"Como yo lo veo, sí", "Más
probable",
"Perspectivas buena",
"Sí",
"Las señales apuntan a que sí",
"Respuesta confusa, intenta otra vez",
"Pregunta de nuevo más tarde", "Mejor
no decirte ahora", "No se puede
predecir ahora", "Concéntrate y
pregunta otra vez", "No cuentes con
ello", "Mi respuesta es no", "Mis fuentes
dicen que no", "Las perspectivas no son
tan buenas", "Muy dudoso",

mientras que verdadero:

mostrar.espectáculo('8')
siacelerómetro.era_gesto('agitar'):
mostrar.claro()
dormir(1000)
mostrar.desplazamiento (aleatorio.elección(respuestas))
dormir(10)

Eslalon sencillo. Mueva el dispositivo para evitar los obstáculos.

# Slalom simple por Larry Hastings, septiembre de 2015

#
# Este programa ha sido puesto en el dominio público.

importarmicrobitcomometro
importaraleatorio

pag=metro.mostrar.espectáculo

marta= -1024
max_x=1024
rango_x=max_x-marta
(continúa en la página siguiente)

3.4. Módulos 69
BBC micro:bit Documentación de MicroPython, versión 1.0.1

(Continuación de la página anterior)

pared_min_velocidad=400
jugador_min_velocidad=200

pared_max_velocidad=100
jugador_max_velocidad=50

velocidad_max=12

mientras que verdadero:

i=metro.Imagen('00000:'*5) s=i.
conjunto_pixel

jugador_x=2

criajo= -1
agujero=0

puntaje=0
manejado_esta_pared=FALSO

velocidad_de_la_pared=wall_min_speed
velocidad_del jugador=jugador_min_velocidad

pared_siguiente=0
jugador_siguiente=0

mientras que verdadero:

t=metro.running_time()
actualización_jugador=t>=player_next
wall_update=t>=pared_siguiente
si no(actualización_jugadoroactualización_pared):
próximo evento=mín.(pared_siguiente,
jugador_siguiente) delta=próximo evento-tm.dormir
(delta)
continuar

siactualización_de_muro:
# calcular nuevas velocidades velocidad=
mín.(puntuación, velocidad_max)
velocidad_de_la_pared=pared_min_velocidad+En t((wall_max_speed-pared_min_velocidad)*
→˓ velocidad/velocidad_max)

velocidad_del_jugador=jugador_min_velocidad+En t((jugador_max_velocidad-jugador_min_
→˓ velocidad)*velocidad/velocidad_max)

pared_siguiente=t+
velocidad_de_la_pared sicriajo<5:
# borrar la vieja pared use_wall_y=
máximo(criajo,0) parapared_xen
rango(5):
sipared_x!=agujero:
s(wall_x, use_wall_y,0)

wall_reached_player=(criajo==4) si
actualización_jugador:
(continúa en la página siguiente)

70 Capítulo 3. Módulo de microbits

 BBC micro:bit Documentación de MicroPython, versión 1.0.1

(Continuación de la página anterior)

jugador_siguiente=t+velocidad_del_jugador
# encontrar nueva coord x
X=metro.acelerómetro.obtener_x()x=
mín.(máximo(mín_x, x), máx_x)
# imprimir("x aceleración", x)
s(jugador_x,4,0)#apagar el píxel antiguo X=((X-
marta)/rango_x)*5 X=mín.(máximo(0, X),4) X=En t(X
+0,5)

# print("tener", posición, "querer", x)

si nohandled_this_wall:
sijugador_x<X:
jugador_x+=1
elifjugador_x>X:
jugador_x-=1
# imprimir("nuevo", posición)
# imprimir()

siactualización_de_muro:
# actualizar la posición de la
pared criajo+=1
sicriajo==7:
criajo= -1
agujero=aleatorio.rango rand(5)
manejado_este_muro=FALSO

sicriajo<5:
# dibujar nueva pared
use_wall_y=máximo(criajo,0) para
pared_xenrango(5):
sipared_x!=agujero:
s(wall_x, use_wall_y,6)

siwall_reached_playery nohandled_this_wall:
manejado_esta_pared=cierto si(
jugador_x!=agujero):
# ¡colisión! ¡juego terminado!
romper
puntaje+=1

siactualización_jugador:
s(jugador_x,4,9)#activar nuevo píxel

Pi)

Pi.TRISTE)
metro.dormir(1000)
metro.mostrar.Desplazarse("Puntaje:"+cadena(puntaje))

mientras que verdadero:

si(metro.botón_a.se presiona()ymetro.botón_a.se presiona()):

romper
metro.dormir(100)

3.4. Módulos 71
BBC micro:bit Documentación de MicroPython, versión 1.0.1

3.4.6 Brújula

Este módulo le permite acceder a la brújula electrónica incorporada. Antes de usarla, se debe calibrar la brújula; de lo contrario, las lecturas
pueden ser incorrectas.

Advertencia:La calibración de la brújula hará que el programa se detenga hasta que se complete la calibración. La calibración
consiste en un pequeño juego de dibujar un círculo en la pantalla LED girando el dispositivo.

Funciones

microbit.brújula.calibrar()
Inicia el proceso de calibración. Se mostrará un mensaje instructivo al usuario, después del cual deberá girar el
dispositivo para dibujar un círculo en la pantalla LED.

microbit.brújula.está_calibrado()
DevolucionesVerdaderosi la brújula ha sido calibrada exitosamente y regresaFALSOde lo contrario.

microbit.brújula.calibración_clara()
Deshace la calibración, haciendo que la brújula vuelva a quedar descalibrada.

microbit.brújula.obtener_x()
Da la lectura de la intensidad del campo magnético en elXeje en nano tesla, como un número entero positivo o negativo,
dependiendo de la dirección del campo.

microbit.brújula.obtener_y()
Da la lectura de la intensidad del campo magnético en elyeje en nano tesla, como un número entero positivo o negativo,
dependiendo de la dirección del campo.

microbit.brújula.obtener_z()
Da la lectura de la intensidad del campo magnético en elzeje en nano tesla, como un número entero positivo o negativo,
dependiendo de la dirección del campo.

microbit.brújula.título()
Proporciona el rumbo de la brújula, calculado a partir de las lecturas anteriores, como un número entero en el rango de 0 a 360, que representa el ángulo en
grados, en el sentido de las agujas del reloj, con el norte como 0.

microbit.brújula.get_field_strength()
Devuelve una indicación entera de la magnitud del campo magnético alrededor del dispositivo en nano tesla.

Ejemplo

"""
brújula.py
~~~~~~~~~~

Crea una brújula.

El usuario deberá calibrar la brújula primero. La brújula utiliza las imágenes del reloj
incorporadas para mostrar la posición de la aguja.

"""
demicrobitimportar*

# Comience a calibrar
(continúa en la página siguiente)

72 Capítulo 3. Módulo de microbits

 BBC micro:bit Documentación de MicroPython, versión 1.0.1

(Continuación de la página anterior)

Brújula.calibrar()

# Intente mantener la aguja apuntando (aproximadamente) en la dirección correcta mientras que

verdadero:
dormir(100)
aguja=((15-Brújula.título())//30)%12 mostrar.mostrar imagen.
ALL_CLOCKS[aguja])

3.4. Módulos 73
BBC micro:bit Documentación de MicroPython, versión 1.0.1

74 Capítulo 3. Módulo de microbits

 CAPÍTULO 4

Audio

Este módulo le permite reproducir sonidos desde un altavoz conectado al Microbit. Para utilizar el módulo de audio deberá
proporcionar una fuente de sonido.

Una fuente de sonido es un iterable (secuencia, como una lista o tupla, o un generador) de fotogramas, cada uno de 32 muestras. Elaudio Los módulos
reproducen muestras a una velocidad de 7812,5 muestras por segundo, lo que significa que puede reproducir frecuencias de hasta 3,9 kHz.

4.1 Funciones

audio.jugar(fuente,esperar = Verdadero,pin=pin0,return_pin=Ninguno)
Reproduzca la fuente hasta su finalización.

fuentees un iterable, cada elemento del cual debe ser unMarco de audio.

SiesperaresVerdadero,esta función se bloqueará hasta que se agote la fuente.

alfilerespecifica a qué pin está conectado el altavoz.

pin_retornoespecifica un pin diferencial para conectar al altavoz en lugar de a tierra.

4.2 Clases

claseaudio.Marco de audio
UnMarco de audioEl objeto es una lista de 32 muestras, cada una de las cuales es un byte firmado (un número entero entre -128 y 127).

Se necesitan poco más de 4 ms para reproducir un solo cuadro.

75
BBC micro:bit Documentación de MicroPython, versión 1.0.1

4.3 Uso de audio

Necesitará una fuente de sonido, como entrada aljugarfunción. Puedes generar el tuyo propio, como enejemplos/formas de onda.py
o puede utilizar las fuentes de sonido proporcionadas por módulos comosintetizador.

4.4 Detalles técnicos

Nota:No es necesario que comprenda esta sección para utilizar elaudiomódulo. Está aquí por si quieres saber cómo
funciona.

ElaudioEl módulo consume muestras a 7812,5 kHz y utiliza interpolación lineal para emitir una señal PWM a 32,5 kHz, lo que
proporciona una calidad de sonido tolerable.

La funciónjugarcopia completamente todos los datos de cadaMarco de audioantes de que llamepróximo()para el siguiente cuadro, por lo que una fuente
de sonido puede usar el mismoMarco de audiorepetidamente.

ElaudioEl módulo tiene un búfer interno de 64 muestras desde el cual lee muestras. Cuando la lectura alcanza el inicio o el punto medio del
buffer, activa una devolución de llamada para recuperar el siguienteMarco de audioque luego se copia en el búfer. Esto significa que una
fuente de sonido tiene menos de 4 ms para calcular la siguientemarco de audio,y para un funcionamiento confiable se necesitan menos de 2
ms (que son 32000 ciclos, por lo que debería ser suficiente).

4.5 Ejemplo

demicrobitimportarpantalla, suspensión, botón_a importar

audio
importarmatemáticas

definiciónmarco_repetido(cuadro, recuento):
paraienrango(contar):
producirmarco

# Presione el botón A para pasar a la siguiente ola.

definiciónmostrar_onda(nombre, marco, duración=1500):
mostrar.desplazarse (nombre+" ola", esperar=FALSO,demora=100)
sonido.reproducir (cuadro_repetido (cuadro, duración), esperar=FALSO)
paraienrango(75):
dormir(100)
sibotón_a.se presiona():
mostrar.claro()
audio.detener()
romper

marco=audio.Marco de audio()

paraienrango(len(marco)):
marco[yo]=En t(matemáticas.pecado (matemáticas.Pi*i/dieciséis)*124+
128,5) mostrar_onda("Seno", marco)

triángulo=audio.Marco de audio()

CUARTO=len(triángulo)//4
(continúa en la página siguiente)

76 Capítulo 4. Audio
 BBC micro:bit Documentación de MicroPython, versión 1.0.1

(Continuación de la página anterior)

paraienrango(CUARTO):
triangulo[yo]=i*15 triangulo[yo+CUARTO]=
248-i*15 triangulo[yo+CUARTO*2]=128-i*
15 triangulo[yo+CUARTO*3]=i*15+8
mostrar_onda("Triángulo", triángulo)

cuadrado=audio.Marco de audio()

MEDIO=len(cuadrado)//2
paraienrango(MEDIO):
cuadrado[i]=8
cuadrado[yo+MEDIO]=248
mostrar_onda("Cuadrado", cuadrado)
dormir(1000)

paraienrango(len(marco)):
marco[yo]=252-i*8 mostrar_onda(
"Diente de sierra", marco)

delmarco

# Genere una forma de onda que vaya de triángulo a onda cuadrada, razonablemente suavemente. marcos=[
Ninguno]*32 paraienrango(32):

marcos[i]=marco=audio.Marco de audio() parajen

rango(len(triángulo)):
marco[j]=(triángulo[j]*(32-i)+cuadrado[j]*i)>>5

definiciónfotogramas_repetidos(fotogramas, contar):
paramarcoenmarcos:
paraienrango(contar):
producirmarco

mostrar.Desplazarse("Ola ascendente", esperar=FALSO)

sonido.reproducir(cuadros_repetidos(cuadros,60))

4.5. Ejemplo 77
BBC micro:bit Documentación de MicroPython, versión 1.0.1

78 Capítulo 4. Audio
 CAPÍTULO 5

Bluetooth

Si bien el BBC micro:bit tiene un hardware capaz de permitir que el dispositivo funcione como un dispositivo Bluetooth de bajo
consumo (BLE), solo tiene 16k de RAM. La pila BLE por sí sola ocupa 12k de RAM, lo que significa que no hay suficiente memoria para
que MicroPython admita Bluetooth.

Nota:MicroPython utiliza el hardware de radio con elradiomódulo. Esto permite a los usuarios crear redes inalámbricas simples pero
efectivas de dispositivos micro:bit.

Además, el protocolo utilizado en elradioEl módulo es mucho más simple que BLE, lo que lo hace mucho más fácil de usar en un
contexto educativo.

79
BBC micro:bit Documentación de MicroPython, versión 1.0.1

80 Capítulo 5. Bluetooth
 CAPÍTULO 6

Sistema de archivos persistente local

Es útil almacenar datos de manera persistente para que permanezcan intactos entre reinicios del dispositivo. En las computadoras tradicionales, esto a
menudo se logra mediante un sistema de archivos que consta de archivos con nombre que contienen datos sin procesar y directorios con nombre que
contienen archivos. Python admite las diversas operaciones necesarias para trabajar con dichos sistemas de archivos.

Sin embargo, dado que micro:bit es un dispositivo limitado en términos de hardware y capacidad de almacenamiento, MicroPython proporciona un
pequeño subconjunto de las funciones necesarias para conservar los datos en el dispositivo. Debido a limitaciones de memoriahay aproximadamente 30k
de almacenamiento disponibleen el sistema de archivos.

Advertencia:Volver a flashear el dispositivo DESTRUIRA TUS DATOS.

Dado que el sistema de archivos se almacena en la memoria flash del micro:bit y al actualizar el dispositivo se reescribe toda la memoria
flash disponible, todos sus datos se perderán si actualiza su dispositivo.

Sin embargo, si apaga su dispositivo, los datos permanecerán intactos hasta que los elimine (ver más abajo) o vuelva a actualizar el
dispositivo.

MicroPython en micro:bit proporciona un sistema de archivos planos; es decir, no existe una noción de jerarquía de directorios, el sistema de archivos es
simplemente una lista de archivos con nombres. La lectura y escritura de un archivo se logra mediante el estándar Python.abiertofunción y el objeto
resultante similar a un archivo (que representa el archivo) de tiposTextoIOoBytesIO.Las operaciones para trabajar con archivos en el sistema de archivos
(por ejemplo, enumerar o eliminar archivos) están contenidas en elsistema operativomódulo.

Si un archivo termina en .py fila extensión entonces se puede importar. Por ejemplo, un archivo llamadohola.pyse puede
importar así:importar hola.

Una sesión de ejemplo en MicroPython REPL puede verse así:

> > > conabierto('hola.py','w')comoHola:

... Hola.escribir("imprimir('Hola')")
...
> > > importarHola
Hola
> > > conabierto('hola.py')comoHola:
... imprimir(Hola.leer())
(continúa en la página siguiente)

81
BBC micro:bit Documentación de MicroPython, versión 1.0.1

(Continuación de la página anterior)

...
imprimir('Hola')
> > > importarsistema operativo
> > > sistema operativo.
listadir() ['hola.py']
> > > sistema operativo.eliminar('hola.py')
> > > sistema operativo.listadir()
[]

abierto(Nombre del archivo,modo = 'r')

Devuelve un objeto de archivo que representa el archivo nombrado en el argumento.Nombre del archivo.El modo
predeterminado es 'r'lo que significa abierto para lectura en modo texto. El otro modo común es 'w'para escribir
(sobrescribiendo el contenido del archivo si ya existe). Hay otros dos modos disponibles para usar junto con los
descritos anteriormente: 't'significa modo texto (para leer y escribir cadenas) y 'b'significa modo binario (para leer y
escribir bytes). Si no se especifican, entonces 't'(modo texto). Cuando esté en modo texto, el objeto de archivo será
una instancia deTextoIO.Cuando esté en modo binario, el objeto de archivo será una instancia deBytesIO.Por ejemplo,
utilice 'rb'para leer datos binarios de un archivo.

clase TextoIO
clase BytesIO
Las instancias de estas clases representan archivos en el sistema de archivos planos de micro:bit. La clase TextIO se utiliza para
representar archivos de texto. La clase BytesIO se utiliza para representar archivos binarios. Funcionan exactamente igual excepto que
TextIO funciona con cadenas y BytesIO funciona con bytes.

No crea instancias directas de estas clases. Más bien, el programa devuelve una instancia de la clase configurada apropiadamente.
abiertofunción descrita anteriormente.

cerca()
Vacíe y cierre el archivo. Este método no tiene ningún efecto si el archivo ya está cerrado. Una vez que se cierra el archivo, cualquier
operación en el archivo (por ejemplo, leer o escribir) generará una excepción.

nombre()
Devuelve el nombre del archivo que representa el objeto. Esto será lo mismo que elNombre del archivo
argumento pasado a la llamada alabiertofunción que instancia el objeto.

leer(tamaño)
Leer y regresar como máximotamañocaracteres como una sola cadena otamañobytes del archivo. Por conveniencia, si
tamañono se especifica o -1, se devuelven todos los datos contenidos en el archivo. Menos quetamañoSe pueden
devolver caracteres o bytes si hay menos detamañocaracteres o bytes que quedan por leer del archivo.

Si se devuelven 0 caracteres o bytes, ytamañono era 0, esto indica el final del archivo.

AError de memoriase producirá una excepción sitamañoes mayor que la RAM disponible.

leer en(buf,norte=-1)
Leer caracteres o bytes en el bufferbuf.Sinortese suministra, leanortenúmero de bytes o caracteres en el
bufferbuf.

línea de lectura(tamaño)
Lea y devuelva una línea del archivo. Sitamañose especifica, como máximotamañoSe leerán los caracteres.

El terminador de línea siempre es '\norte'para cuerdas ob'\n'por bytes.

grabable()
DevolverVerdaderosi el archivo admite escritura. SiFalso, escribe()elevaráOSError.

escribir(buf)
Escribe la cadena o los bytes.bufal archivo y devolver el número de caracteres o bytes escritos.

82 Capítulo 6. Sistema de archivos persistente local

 CAPÍTULO 7

Máquina

El módulo de la máquina contiene funciones específicas relacionadas con el hardware micro:bit. La mayoría de las funciones de este módulo
permiten lograr acceso directo y sin restricciones y control de bloques de hardware en un sistema (como CPU, temporizadores, buses, etc.). Si
se usa incorrectamente, esto puede provocar mal funcionamiento, bloqueos, fallas de la placa y, en casos extremos, daños al hardware.

7.1 Funciones

máquina.Identificación única()
Devuelve una cadena de bytes con un identificador único de una placa. Variará de una instancia de tablero a otra.

máquina.reiniciar()
Reinicia el dispositivo de manera similar a presionar el botón RESET externo.

máquina.frecuencia()
Devuelve la frecuencia de la CPU en hercios.

máquina.desactivar_irq()
Deshabilite las solicitudes de interrupción. Devuelve el estado IRQ anterior que debe considerarse un valor opaco.
Este valor de retorno debe pasarse almáquina.enable_irq()función para restaurar las interrupciones a su estado
original, antesmáquina.disable_irq()fue llamado.

máquina.habilitar_irq()
Vuelva a habilitar las solicitudes de interrupción. ElestadoEl parámetro debe ser el valor que se devolvió de la llamada
más reciente almáquina.disable_irq()función.

máquina.time_pulse_us(alfiler,nivel_pulso,tiempo de espera_us = 1000000)

Cronometrar un pulso en lo dadoalfilery devuelve la duración del pulso en microsegundos. Elnivel_pulsoEl argumento debe ser 0 para
cronometrar un pulso bajo o 1 para cronometrar un pulso alto.

Si el valor de entrada actual del pin es diferente alnivel_pulso, la función primero (*) espera hasta que la entrada del pin sea
igual anivel_pulso, luego (**) multiplicado por la duración a la que el pin es igualnivel_pulso. Si el pin ya es igual anivel_pulso
entonces el cronometraje comienza de inmediato.

83
BBC micro:bit Documentación de MicroPython, versión 1.0.1

La función devolverá -2 si hubo tiempo de espera en espera de la condición marcada (*) arriba, y -1 si hubo tiempo de espera durante
la medición principal, marcada (**) arriba. El tiempo de espera es el mismo para ambos casos y está dado por tiempo de espera_us(que
está en microsegundos).

7.2 Lectura de la memoria

ElmáquinaEl módulo le permite leer desde la memoria del dispositivo, obteniendo 1 byte (8 bits;mem8),2 bytes (16
bits; memoria16),o 4 bytes (32 bits;mem32)palabras de direcciones físicas. Por ejemplo:mem8[0x00]lee 1 byte en la
dirección física0x00.Esto tiene varios usos, por ejemplo, si desea leer datos de los registros nRF51.

84 Capítulo 7. Máquina
 CAPÍTULO 8

MicroPython

Acceda y controle los componentes internos de MicroPython.

8.1 Funciones

micropitón.constante(exprés)
Se utiliza para declarar que la expresión es una constante para que el compilador pueda optimizarla. El uso de esta función
debe ser el siguiente:

demicropitónimportarconstante CONST_X
=constante(123) CONST_Y=constante(2*
CONST_X+1)

Las constantes declaradas de esta manera aún son accesibles como variables globales desde fuera del módulo en el que se
declaran. Por otro lado, si una constante comienza con un guión bajo, entonces está oculta, no está disponible como variable
global y no ocupa cualquier memoria durante la ejecución.

micropitón.nivel_opt([nivel])
Si se proporciona el nivel, esta función establece el nivel de optimización para la compilación posterior de scripts y devuelve Ninguno.
De lo contrario, devuelve el nivel de optimización actual.

El nivel de optimización controla las siguientes características de compilación:

• Afirmaciones: en el nivel 0, las declaraciones de aserción se habilitan y compilan en el código de bytes; en los niveles 1 y
superiores las afirmaciones no se compilan.

• __ incorporadodepurar__variable: en el nivel 0 esta variable se expande a Verdadero; en los niveles 1 y superiores se expande a
Falso.

• Números de línea del código fuente: en los niveles 0, 1 y 2, el número de línea del código fuente se almacena junto con el código de bytes para que las
excepciones puedan informar el número de línea en el que ocurrieron; en los niveles 3 y superiores, los números de línea no se almacenan.

El nivel de optimización predeterminado suele ser el nivel 0.

85
BBC micro:bit Documentación de MicroPython, versión 1.0.1

micropitón.mem_info([verboso])
Imprime información sobre la memoria utilizada actualmente. Si se da el argumento detallado, entonces se proporciona información adicional.
impreso.

micropitón.qstr_info([verboso])
Imprime información sobre las cadenas internas actualmente. Si se proporciona el argumento detallado, se imprime información
adicional.

Esto incluye la cantidad de cadenas internas y la cantidad de RAM que utilizan. En modo detallado, imprime los nombres de
todas las cadenas internas en la RAM.

micropitón.uso_pila()
Devuelve un número entero que representa la cantidad actual de pila que se está utilizando. El valor absoluto de esto no es
particularmente útil, sino que debería usarse para calcular las diferencias en el uso de la pila en diferentes puntos.

micropitón.montón_lock()
micropitón.montón_unlock()
Bloquear o desbloquear el montón. Cuando está bloqueado, no se puede realizar ninguna asignación de memoria y seError de memoriase generará si se
intenta realizar alguna asignación de montón.

micropitón.kbd_intr(chr)
Establezca el carácter que generará una excepción KeyboardInterrupt. De forma predeterminada, esto se establece en 3 durante la
ejecución del script, correspondiente a Ctrl-C. Pasar -1 a esta función deshabilitará la captura de Ctrl-C, y pasar 3 la restaurará.

Esta función se puede usar para evitar la captura de Ctrl-C en el flujo entrante de caracteres que generalmente se usa
para REPL, en caso de que ese flujo se use para otros fines.

86 Capítulo 8. MicroPython
 CAPÍTULO 9

Música

Este es elmúsicamódulo. Puedes usarlo para reproducir melodías simples, siempre que conectes un altavoz a tu placa. Por defecto el
músicaEl módulo espera que el altavoz esté conectado a través del pin 0:

87
BBC micro:bit Documentación de MicroPython, versión 1.0.1

Esta disposición se puede anular (como se explica a continuación).

Para acceder a este módulo es necesario:

importarmúsica

Suponemos que ha hecho esto para los ejemplos siguientes.

9.1 Notación musical

Una nota individual se especifica así:

NOTA[octava][:duración]

88 Capítulo 9. Música
 BBC micro:bit Documentación de MicroPython, versión 1.0.1

Por ejemplo,A1:4se refiere a la nota “A” en la octava 1 que dura cuatro tics (un tic es un período de tiempo arbitrario definido por una función
de ajuste de tempo; consulte a continuación). Si el nombre de la notaRse utiliza entonces se trata como un descanso (silencio).

Las alteraciones ( bemoles y sostenidos ) se indican con elb (fl.)at - minúscula b) y # (sostenido - símbolo de almohadilla). Por ejemplo, abes La
bemol yC#es C sostenido.

Los nombres de las notas no distinguen entre mayúsculas y minúsculas.

EloctavayduraciónLos parámetros son estados que se trasladan a notas posteriores hasta que se vuelvan a especificar. Los estados
predeterminados sonoctava = 4 (que contiene el C central) yduración = 4 (una entrepierna, dada la configuración de tempo predeterminada
(ver más abajo).

Por ejemplo, si 4 ticks es una entrepierna, la siguiente lista es un arpegio basado en entrepierna, corchea, corchea y entrepierna:

['c1:4','e:2','gramo','c2:4']

La apertura de la Quinta Sinfonía de Beethoven se codificaría así:

['r4:2','gramo','gramo','gramo','eb:8','r:2','F','F','F','d:8']

La definición y el alcance de una octava se ajustan a la tabla enumerada.en esta página sobre notación científica de tono. Por
ejemplo, la “C” central es 'c4'y el concierto “A” (440) es 'a4'.Las octavas comienzan en la nota "C".

9.2 Funciones

música.establecer_tempo(garrapatas = 4,bpm=120)
Establece el tempo aproximado para la reproducción.

Un número de tics (expresados como un número entero) constituyen un latido. Cada tiempo debe reproducirse a una cierta frecuencia por
minuto (expresada como el BPM más familiar - tiempos por minuto - también como un número entero).

Los valores predeterminados sugeridos permiten el siguiente comportamiento útil:

• música.set_tempo() -restablecer el tempo al valor predeterminado de ticks = 4, bpm = 120

• música.set_tempo(ticks=8) -cambiar la “definición” de un ritmo

• música.set_tempo(bpm=180) -solo cambia el tempo
Calcular la duración de un tic en milisegundos es una aritmética muy simple: ticks_per_beat
60000/lpm/
.Para
los valores predeterminados que son60000/120/4 = 125 milisegundoso1 latido = 500 milisegundos.

música.obtener_tempo()
Obtiene el tempo actual como una tupla de números enteros: (tics, bpm).

música.jugar(música,pin=microbit.pin0,esperar = Verdadero,bucle = Falso)

Obras de teatromúsicaque contiene el DSL musical definido anteriormente.

Simúsicaes una cadena, se espera que sea una sola nota como, 'c1:4'.

Simúsicase especifica como una lista de notas (como se define en la sección sobre DSL musical, arriba) y luego se reproducen una tras
otra para interpretar una melodía.

En ambos casos, elduraciónyoctavaLos valores se restablecen a sus valores predeterminados antes de que se reproduzca la música (cualquiera
que sea).

Se puede utilizar un argumento opcional para especificar el pin de salida para anular el valor predeterminado demicrobit.pin0. Siesperar

se establece enVerdadero,esta función está bloqueando.

Sibuclese establece enVerdadero,La melodía se repite hastadetenerse llama (ver más abajo) o se interrumpe la llamada de bloqueo.

9.2. Funciones 89
BBC micro:bit Documentación de MicroPython, versión 1.0.1

música.paso(frecuencia,duración=-1,pin=microbit.pin0,esperar = Verdadero)
Reproduce un tono a la frecuencia entera dada durante el número especificado de milisegundos. Por ejemplo, si la frecuencia se
establece en 440 y la duración en 1000, entonces escucharemos un concierto estándar A durante un segundo.

Tenga en cuenta que solo puede jugar un lanzamiento en un pin a la vez.

Siesperarse establece enVerdadero,esta función está bloqueando.

Siduraciónes negativo, el tono se reproduce continuamente hasta que se interrumpe la llamada de bloqueo o, en el caso de una
llamada en segundo plano, se establece una nueva frecuencia odetenerse llama (ver más abajo).

música.detener(pin=microbit.pin0)
Detiene toda la reproducción de música en un pin determinado, por ejemplo.música.parada(pin1).Si no se proporciona ningún pin, por ejemplo.
música.parar() Se supone pin0.

música.reiniciar()
Restablece el estado de los siguientes atributos de la siguiente manera:

• garrapatas = 4

• lpm = 120
• duración = 4
• octava = 4

9.2.1 Melodías integradas

Con fines educativos y de entretenimiento, el módulo contiene varias melodías de ejemplo expresadas como listas de
Python. Se pueden utilizar así:

> > > importarmúsica

> > > música.reproducir música.NYAN)

Todas las melodías no tienen derechos de autor, están compuestas por Nicholas H. Tollervey y son de dominio público o tienen un compositor
desconocido y están cubiertas por una disposición de uso justo (educativo).

Ellos son:

• DADADADUM -la apertura de la Quinta Sinfonía en do menor de Beethoven.

• ANIMADOR -el fragmento inicial del clásico de Ragtime de Scott Joplin “The Entertainer”.
• PRELUDIO -la apertura del primer Preludio en Do mayor de los 48 Preludios y Fugas de JSBach.

• ODA -el tema “Oda a la alegría” de la novena sinfonía en re menor de Beethoven.

• NYAN -el tema de Nyan Cat (http://www.nyan.cat/). El compositor es desconocido. Este es un uso legítimo para las marsopas
educativas (como dicen en Nueva York).

• TONO DE LLAMADA -algo que suena como el tono de llamada de un teléfono móvil. Se utiliza para indicar un mensaje entrante.

• FUNK -una línea de bajo funky para agentes secretos y autores intelectuales del crimen.

• AZULES -un bajo andante de blues boogie-woogie de 12 compases.

• CUMPLEAÑOS - "Feliz cumpleaños. . . ”Para conocer el estado de los derechos de autor, consulte: http://www.bbc.co.uk/news/
world-us-canada-34332853

• BODA -el coro nupcial de la ópera “Lohengrin” de Wagner.

• FUNERAL -la “marcha fúnebre” también conocida como Sonata para piano n.° 2 en si menor de Frédéric Chopin, op. 35.

• LÍNEA FINAL -un fragmento divertido que significa que se ha hecho una broma.

90 Capítulo 9. Música
 BBC micro:bit Documentación de MicroPython, versión 1.0.1

• PITÓN -La marcha de John Philip Sousa “Liberty Bell”, también conocida como el tema de “Monty Python's Flying Circus” (que
da nombre al lenguaje de programación Python).

• MALO -Entrada de un malo en la era del cine mudo.

• PERSEGUIR -Escena de persecución de la época del cine mudo.

• BA_DING -una señal corta para indicar que algo ha sucedido.

• WAWAWAWAA -Un trombón muy triste.

• SALTAR -para usar en un juego, indicando movimiento ascendente.

• BAJAR DE UN SALTO -para usar en un juego, indicando movimiento hacia abajo.

• ENCENDER -una fanfarria para indicar un logro desbloqueado.

• CORRIENTE CORTADA -una triste fanfarria para indicar un logro perdido.

9.2.2 Ejemplo

"""
musica.py
~~~~~~~~

Reproduce una melodía sencilla utilizando el módulo de música Micropython.

Este ejemplo requiere un altavoz/zumbador/auriculares conectados a P0 y GND.
"""
demicrobitimportar*
importarmúsica

# reproducir Preludio en C.
notas=[
'c4:1','mi','gramo','c5','e5','g4','c5','e5','c4','mi','gramo','c5','e5','g4',
→˓ 'c5','e5',

'c4','d','a','d5','f5','a4','d5','f5','c4','d','a','d5','f5','a4',
→˓ 'd5','f5',

'b3','d4','gramo','d5','f5','g4','d5','f5','b3','d4','gramo','d5','f5','g4',
→˓ 'd5','f5',

'c4','mi','gramo','c5','e5','g4','c5','e5','c4','mi','gramo','c5','e5','g4',
→˓ 'c5','e5',

'c4','mi','a','e5','a5','a4','e5','a5','c4','mi','a','e5','a5','a4',
→˓ 'e5','a5',

'c4','d','F#','a','d5','f#4','a','d5','c4','d','F#','a','d5','f#4',
→˓ 'a','d5',

'b3','d4','gramo','d5','g5','g4','d5','g5','b3','d4','gramo','d5','g5','g4',
→˓ 'd5','g5',

'b3','c4','mi','gramo','c5','e4','gramo','c5','b3','c4','mi','gramo','c5','e4','gramo
→˓ ','c5',

'a3','c4','mi','gramo','c5','e4','gramo','c5','a3','c4','mi','gramo','c5','e4','gramo
→˓ ','c5',

'd3','a','d4','F#','c5','d4','F#','c5','d3','a','d4','F#','c5','d4',
→˓ 'F#','c5',

'g3','b','d4','gramo','b','d','gramo','b','g3','b3','d4','gramo','b','d','gramo','b
→˓ '

música.jugar (notas)

9.2. Funciones 91
BBC micro:bit Documentación de MicroPython, versión 1.0.1

92 Capítulo 9. Música
 CAPÍTULO 10

neopíxel

ElneopíxelEl módulo le permite utilizar tiras de LED RGB direccionables individualmente NeoPixel (WS2812) con el micro:bit.
Nota para utilizar elneopíxelmódulo, debe importarlo por separado con:

importarneopíxel

Nota:Según nuestras pruebas, el módulo Microbit NeoPixel puede manejar hasta alrededor de 256 NeoPixels. Cualquier valor superior a eso
puede provocar errores y problemas extraños. Como el micro:bit solo puede suministrar 90 mA a dispositivos externos, un mayor número de
NeoPixels requieren una fuente de alimentación externa con conexión a tierra común.

Los NeoPixels están diseñados para funcionar a 5 V, pero afortunadamente todavía funcionan con el suministro de 3 V del BBC micro:bit.
Tenga en cuenta que el conector de borde micro:bit no debe conectarse a nada que suministre 5 V.

Los NeoPixels son divertidas tiras de LED programables multicolores. Este módulo contiene todo lo necesario para conectarlos a un micro:bit y
crear pantallas, arte y juegos originales como la demostración que se muestra a continuación.

Para conectar una tira de neopíxeles, deberá conectar el micro:bit como se muestra a continuación (suponiendo que desee controlar
los píxeles desde el pin 0; también puede conectar neopíxeles a los pines 1 y 2). La etiqueta en la pinza de cocodrilo le indica dónde
colocar el otro extremo de la tira de neopíxeles. El pin VDD puede estar etiquetado como otra cosa en algunas variantes de
neopíxeles, por ejemplo, "V+". En algunos casos, puede denominarse “+5V” y solo es seguro usarlo si no tiene otros dispositivos de 5V
conectados.

Advertencia:No utilice el conector de 3v del Microbit para alimentar más de 8 Neopixels a la vez.

Si desea utilizar más de 8 Neopixels, debe utilizar una fuente de alimentación separada de 3v-5v para el pin de alimentación de Neopixel.

93
BBC micro:bit Documentación de MicroPython, versión 1.0.1

10.1 Clases

claseneopíxel.neopíxel(alfiler,norte)
Inicialice una nueva tira denortenúmero de LED de neopixel controlados mediante pinalfiler.Cada píxel está direccionado por una
posición (comenzando desde 0). Los neopíxeles reciben valores RGB (rojo, verde, azul) entre 0 y 255 como una tupla. Por ejemplo,
(255.255.255)es blanco.

claro()
Borra todos los píxeles.

espectáculo()

94 Capítulo 10. Neopíxel

 BBC micro:bit Documentación de MicroPython, versión 1.0.1

Muestra los píxeles. Se debe llamar para que las actualizaciones sean visibles.

10.2 Operaciones

Escribir el color no actualiza la pantalla (useespectáculo()para eso).

notario público[0]=(255,0, # primer elemento

128) np[-1]=(0,255,0) # último elemento
notario público.espectáculo()#solo ahora se mostrará el valor actualizado

Para leer el color de un píxel específico, simplemente haga referencia a él.

imprimir(notario público[0])

10.3 Usando neopíxeles

Interactúa con Neopixels como si fueran una lista de tuplas. Cada tupla representa la mezcla de colores RGB (rojo, verde y
azul) para un píxel específico. Los valores RGB pueden oscilar entre 0 y 255.

Por ejemplo, inicialice una tira de 8 neopíxeles en una tira conectada al pin0 de esta manera:

importarneopíxel
notario público=neopíxel.NeoPixel(pin0,8)

Establezca píxeles indexándolos (como con una lista de Python). Por ejemplo, para configurar el primer píxel en rojo con brillo total,
usaría:

notario público[0]=(255,0,0)

O el píxel final a violeta:

notario público[-1]=(255,0,255)

Obtenga el valor de color actual de un píxel indexándolo. Por ejemplo, para imprimir el valor RGB del primer píxel utilice:

imprimir(notario público[0])

Finalmente, para enviar los nuevos datos de color a su tira Neopixel, use la función .show():

notario público.espectáculo()

Si no pasa nada, probablemente sea porque has olvidado este último paso...!

Nota:Si no ve ningún cambio en su tira Neopixel, asegúrese de tenerespectáculo()al menos en algún lugar, de lo contrario
sus actualizaciones no se mostrarán.

10.4 Ejemplo

10.2. Operaciones 95
BBC micro:bit Documentación de MicroPython, versión 1.0.1

"""
neopixel_random.py

Muestra repetidamente colores aleatorios en la tira de LED.

Este ejemplo requiere una tira de 8 Neopixels (WS2812) conectada al pin0.

"""
demicrobitimportar*
importarneopíxel
dealeatorioimportarrandint

# Configure la tira de Neopixel en pin0 con una longitud de 8 píxeles notario

público=neopíxel.NeoPixel(pin0,8)

mientras que verdadero:

# Iterar sobre cada LED en la tira

paraid_píxelenrango(0,len(notario público)):
rojo=randint(0,60) verde=
randint(0,60) azul=randint(0,
60)

# Asigne al LED actual un valor aleatorio de rojo, verde y azul entre 0 y 60 np[pixel_id]=(rojo verde azul)

# Mostrar los datos de píxeles actuales en la tira de Neopixel notario público.

espectáculo()
dormir(100)

96 Capítulo 10. Neopíxel

 CAPÍTULO 11

Elsistema operativoMódulo

MicroPython contiene unsistema operativomódulo basado en elsistema operativomódulo en la biblioteca estándar de Python. Se utiliza para
acceder a lo que tradicionalmente se denominaría funcionalidad dependiente del sistema operativo. Dado que MicroPython no tiene un
sistema operativo, el módulo proporciona funciones relacionadas con la gestión del sistema de archivos persistente simple en el dispositivo e
información sobre el sistema actual.

Para acceder a este módulo es necesario:

importarsistema operativo

Suponemos que ha hecho esto para los ejemplos siguientes.

11.1 Funciones

os.listadir()
Devuelve una lista de los nombres de todos los archivos contenidos en el sistema de archivos local persistente en el dispositivo.

os.eliminar(Nombre del archivo)

Elimina (elimina) el archivo nombrado en el argumento.Nombre del archivo.Si el archivo no existeOSErrorse producirá una
excepción.

os.tamaño(Nombre del archivo)

Devuelve el tamaño, en bytes, del archivo nombrado en el argumento.Nombre del archivo.Si el archivo no existeOSError se producirá
una excepción.

os.tu nombre()
Devuelve información que identifica el sistema operativo actual. El valor de retorno es un objeto con cinco atributos:

• nombre del sistema -nombre del sistema operativo

• nombre del nodo -nombre de la máquina en la red (definido por la implementación)

• liberar -lanzamiento del sistema operativo

• versión -versión del sistema operativo

97
BBC micro:bit Documentación de MicroPython, versión 1.0.1

• máquina -identificador de hardware

Nota:No hay ningún sistema operativo subyacente en MicroPython. En consecuencia, la información devuelta por eltu nombre La función es
principalmente útil para detalles de versiones.

98 Capítulo 11. Elsistema operativoMódulo

 CAPÍTULO 12

Radio

ElradioEl módulo permite que los dispositivos funcionen juntos a través de redes inalámbricas simples. El

módulo de radio es conceptualmente muy sencillo:

• Los mensajes de difusión tienen una determinada longitud configurable (hasta 251 bytes).

• Los mensajes recibidos se leen desde una cola de tamaño configurable (cuanto más grande es la cola, más RAM se utiliza). Si la
cola está llena, los mensajes nuevos se ignoran. Leer un mensaje lo elimina de la cola.

• Los mensajes se transmiten y reciben en un canal preseleccionado (numerado del 0 al 83).

• Las transmisiones tienen un cierto nivel de potencia: más potencia significa más alcance.

• Los mensajes se filtran por dirección (como el número de una casa) y grupo (como un destinatario designado en la dirección
especificada).

• La tasa de rendimiento puede ser una de tres configuraciones predeterminadas.

• Enviar y recibir bytes para trabajar con datos arbitrarios.

• Usarrecibir_completopara obtener detalles completos sobre un mensaje entrante: los datos, la intensidad de la señal de recepción y una marca de
tiempo de microsegundos cuando llegó el mensaje.

• Para comodidad de los niños, es fácil enviar y recibir mensajes como cadenas.

• La configuración predeterminada es sensata y compatible con otras plataformas orientadas a BBC micro:bit.

Para acceder a este módulo es necesario:

importarradio

Suponemos que ha hecho esto para los ejemplos siguientes.

12.1 Constantes

radio.TASA_250KBIT
Constante utilizada para indicar un rendimiento de 256 Kbit por segundo.

99
BBC micro:bit Documentación de MicroPython, versión 1.0.1

radio.TASA_1MBIT
Constante utilizada para indicar un rendimiento de 1 MBit por segundo.

radio.TASA_2MBIT
Constante utilizada para indicar un rendimiento de 2 MBit por segundo.

12.2 Funciones

radio.en()
Enciende la radio. Esto debe llamarse explícitamente ya que la radio consume energía y memoria que de otro modo
podría necesitar.

radio.apagado()
Apaga la radio, ahorrando así energía y memoria.

radio.configuración(**kwargs)
Configura varias configuraciones basadas en palabras clave relacionadas con la radio. Las configuraciones disponibles y sus valores predeterminados sensatos se

enumeran a continuación.

Ellongitud (default=32) define la longitud máxima, en bytes, de un mensaje enviado por radio. Puede tener una longitud
máxima de 251 bytes (254 - 3 bytes para el preámbulo S0, LENGTH y S1).

Elcola (default=3) especifica el número de mensajes que se pueden almacenar en la cola de mensajes
entrantes. Si no quedan espacios en la cola para mensajes entrantes, el mensaje entrante se descarta.

Elcanal (default=7) puede ser un valor entero de 0 a 83 (inclusive) que define un “canal” arbitrario al que está sintonizada la
radio. Los mensajes se enviarán a través de este canal y solo los mensajes recibidos a través de este canal se colocarán en la
cola de mensajes entrantes. Cada paso tiene 1MHz de ancho, basado en 2400MHz.

Elfuerza (default=6) es un valor entero de 0 a 7 (inclusive) para indicar la intensidad de la señal utilizada al transmitir
un mensaje. Cuanto mayor sea el valor, más fuerte será la señal, pero más energía consumirá el dispositivo. La
numeración se traduce a posiciones en la siguiente lista de valores de dBm (decibelios milivatios): -30, -20,
- 16, -12, -8, -4, 0, 4.

ElDIRECCIÓN (default=0x75626974) es un nombre arbitrario, expresado como una dirección de 32 bits, que se utiliza para filtrar paquetes entrantes a nivel de
hardware, manteniendo solo aquellos que coinciden con la dirección que usted configuró. La configuración predeterminada utilizada por otras plataformas
relacionadas con micro:bit es la configuración predeterminada utilizada aquí.

Elgrupo (predeterminado=0) es un valor de 8 bits (0-255) utilizado con elDIRECCIÓNal filtrar mensajes. Conceptualmente,
"dirección" es como la dirección de una casa/oficina y "grupo" es como la persona en esa dirección a la que desea enviar su
mensaje.

Elvelocidad de datos (default=radio.RATE_1MBIT) indica la velocidad a la que se produce el procesamiento de

datos. Puede ser uno de los siguientes contenidos definidos en elradiomódulo:TASA_250KBIT, TASA_1MBITo
TASA_2MBIT.

Siconfiguraciónno se llama, entonces se asumen los valores predeterminados descritos anteriormente.

radio.reiniciar()
Restablezca la configuración a sus valores predeterminados (como se enumeran en la documentación delconfiguraciónfunción anterior).

Nota:Ninguno de los siguientes métodos de envío o recepción funcionará hasta que se encienda la radio.

radio.enviar_bytes(mensaje)
Envía un mensaje que contiene bytes.

100 Capítulo 12. Radio

 BBC micro:bit Documentación de MicroPython, versión 1.0.1

radio.recibir_bytes()
Reciba el siguiente mensaje entrante en la cola de mensajes. DevolucionesNingunosi no hay mensajes pendientes. Los
mensajes se devuelven como bytes.

radio.recibir_bytes_en(buffer)
Reciba el siguiente mensaje entrante en la cola de mensajes. Copia el mensaje enbuffer,recortando el final del
mensaje si es necesario. DevolucionesNingunosi no hay mensajes pendientes; de lo contrario, devuelve la longitud del
mensaje (que puede ser mayor que la longitud del búfer).

radio.enviar(mensaje)
Envía una cadena de mensaje. Este es el equivalente deenviar_bytes(bytes(mensaje, 'utf8'))pero con
b'\x01\x00\x01'antepuesto al frente (para que sea compatible con otras plataformas que apuntan al
micro:bit).
radio.recibir()
Funciona exactamente de la misma manera querecibir_bytespero devuelve todo lo enviado.

Actualmente equivale astr(recibir_bytes(), 'utf8')pero con una verificación de que los primeros tres bytes estén
b'\x01\x00\x01' (para hacerlo compatible con otras plataformas que puedan apuntar al micro:bit). Elimina los bytes
antepuestos antes de convertirlos en una cadena.

AError de valorSe genera una excepción si falla la conversión a cadena.

radio.recibir_completo()
Devuelve una tupla que contiene tres valores que representan el siguiente mensaje entrante en la cola de mensajes. Si no hay
mensajes pendientes entoncesNingunoes regresado.

Los tres valores de la tupla representan:

• el siguiente mensaje entrante en la cola de mensajes como bytes.

• el RSSI (intensidad de la señal): un valor entre 0 (más fuerte) y -255 (más débil) medido en dBm.

• una marca de tiempo de microsegundos: el valor devuelto portiempo.ticks_us()cuando se recibió el mensaje.

Por ejemplo:

detalles=radio.recibir_completo() si
detalles:
mensaje, rssi, marca de tiempo=detalles

Esta función es útil para proporcionar información necesaria para la triangulación y/o triliteración con otros dispositivos
micro:bit.

12.2.1 Ejemplos

# Una luciérnaga micro:bit.

# Por Nicholas H. Tollervey. Liberado al dominio público. importarradio

importaraleatorio
demicrobitimportarpantalla, imagen, botón_a, suspensión

# Crea los fotogramas de animación "flash". ¿Puedes averiguar cómo se hace? destello=
[Imagen().invertir()*(i/9)paraienrango(9,-1,-1)]

# La radio no funcionará a menos que esté encendida. radio.

en()

# Bucle de eventos.
(continúa en la página siguiente)

12.2. Funciones 101

BBC micro:bit Documentación de MicroPython, versión 1.0.1

(Continuación de la página anterior)

mientras que verdadero:

# El botón A envía un mensaje "flash". si

botón_a.estaba_presionado():
radio.enviar('destello')#a-ja
# Leer los mensajes entrantes.
entrante=radio.recibir() sientrante==
'destello':
# Si hay un mensaje "flash" entrante
# la animación flash de la luciérnaga después de un corto aleatorio
# pausa.
dormir (aleatorio.randint(50,350)) mostrar.mostrar
(destello, retraso=100, esperar=FALSO)
# Retransmitir aleatoriamente el mensaje flash después de un
# leve retraso.
sialeatorio.randint(0,9)==0:
dormir(500)
radio.enviar('destello')#a-ja

102 Capítulo 12. Radio

 CAPÍTULO 13

Generación de números aleatorios

Este módulo se basa en elaleatoriomódulo en la biblioteca estándar de Python. Contiene funciones para generar
comportamiento aleatorio.

Para acceder a este módulo es necesario:

importaraleatorio

Suponemos que ha hecho esto para los ejemplos siguientes.

13.1 Funciones

aleatorio.obtener bits(norte)
Devuelve un número entero connortebits aleatorios.

Advertencia:Debido a que la función generadora subyacente devuelve como máximo 30 bits,nortesolo puede ser un valor entre 1 y 30
(inclusive).

aleatorio.semilla(norte)
Inicialice el generador de números aleatorios con un número entero conocidonorte.Esto le dará una aleatoriedad determinista reproducible a
partir de un estado inicial determinado (norte).

aleatorio.randint(a,b)
Devuelve un número entero aleatorionortetal quea <= N <= segundo.Alias pararango aleatorio (a, b+1).

aleatorio.randrange(detener)
Devuelve un número entero seleccionado aleatoriamente entre cero y hasta (pero sin incluir)detener.

aleatorio.randrange(comenzar,detener)
Devuelve un número entero seleccionado aleatoriamente derango (inicio, parada).

aleatorio.randrange(comenzar,detener,paso)
Devuelve un elemento seleccionado aleatoriamente derango (inicio, parada, paso).

103
BBC micro:bit Documentación de MicroPython, versión 1.0.1

aleatorio.elección(secuencia)
Devuelve un elemento aleatorio de la secuencia no vacíasiguienteSisecuenciaestá vacío, se elevaError de índice.

aleatorio.aleatorio()
Devuelve el siguiente número de coma flotante aleatorio en el rango [0.0, 1.0)

aleatorio.uniforme(a,b)
Devuelve un número de coma flotante aleatorionortetal quea <= norte <= bparaa <= byb <= norte <= aparab < a.

104 Capítulo 13. Generación de números aleatorios

 CAPÍTULO 14

Discurso

Advertencia: ¡ADVERTENCIA! Este es todavía un trabajo en progreso; Nos reservamos el derecho de cambiar esta API a medida que se desarrolle.
continúa.
La calidad del discurso no es excelente, simplemente “suficientemente buena”. Dadas las limitaciones del dispositivo, es posible
encontrar errores de memoria y/o sonidos adicionales inesperados durante la reproducción. Es pronto y estamos mejorando el código del
sintetizador de voz todo el tiempo. Los informes de errores y las solicitudes de extracción son bienvenidos.

Este módulo hace que los microbits hablen, canten y emitan otros sonidos similares al habla, siempre que conecte un altavoz a su placa como se muestra
a continuación:

105
BBC micro:bit Documentación de MicroPython, versión 1.0.1

Nota:Este trabajo se basa en los increíbles esfuerzos de ingeniería inversa de Sebastian Macke basados en un antiguo programa de
texto a voz (TTS) llamado SAM (Software Automated Mouth) lanzado originalmente en 1982 para el Commodore 64. El resultado es
una pequeña biblioteca C que tenemos. Adoptado y adaptado para el micro:bit. Puedes obtener más información en su pagina de
inicio. Gran parte de la información contenida en este documento se obtuvo del manual del usuario original que se puede encontrar
aquí.

El sintetizador de voz puede producir alrededor de 2,5 segundos de sonido a partir de hasta 255 caracteres de entrada de texto.

Para acceder a este módulo es necesario:

importardiscurso

Suponemos que ha hecho esto para los ejemplos siguientes.

106 Capítulo 14. Discurso

 BBC micro:bit Documentación de MicroPython, versión 1.0.1

14.1 Funciones

discurso.traducir(palabras)
Dadas palabras en inglés en la cadenapalabras,devuelve una cadena que contiene una mejor suposición de los fonemas apropiados
para pronunciar. La salida se genera a partir de estetabla de traducción de texto a fonema.

Esta función debe usarse para generar una primera aproximación de los fonemas que se pueden editar manualmente para
mejorar la precisión, la inflexión y el énfasis.

discurso.pronunciar(fonemas,*,tono = 64,velocidad = 72,boca=128,garganta=128)

Pronuncia los fonemas en la cadena.fonemas.Consulte a continuación los detalles sobre cómo utilizar fonemas para controlar
con precisión la salida del sintetizador de voz. Anule los ajustes opcionales de tono, velocidad, boca y garganta para cambiar
el timbre (calidad) de la voz.

discurso.decir(palabras,*,tono = 64,velocidad = 72,boca=128,garganta=128)

Di las palabras en inglés en la cadena.palabras.El resultado es semipreciso para el inglés. Anule los ajustes
opcionales de tono, velocidad, boca y garganta para cambiar el timbre (calidad) de la voz. Este es un
equivalente abreviado de: discurso.pronunciar(voz.traducir(palabras))

discurso.cantar(fonemas,*,tono = 64,velocidad = 72,boca=128,garganta=128)

Cantar los fonemas contenidos en la cuerda.fonemas.A continuación se describe cómo cambiar el tono y la duración de la
nota. Anule los ajustes opcionales de tono, velocidad, boca y garganta para cambiar el timbre (calidad) de la voz.

14.2 Puntuación

La puntuación se utiliza para alterar la forma de expresarse. El sintetizador comprende cuatro signos de puntuación: guión, coma,
punto y signo de interrogación.

El guión (-) marca los límites de las cláusulas insertando una breve pausa en el discurso.

La coma (,) marca los límites de la frase e inserta una pausa de aproximadamente el doble que el guión. El punto (.) y el

signo de interrogación (?) finalizan las oraciones.

El punto inserta una pausa y hace que el tono baje.

El signo de interrogación también inserta una pausa pero hace que el tono suba. Esto funciona bien con preguntas de sí o no como
"¿ya llegamos a casa?" en lugar de preguntas más complejas como “¿por qué nos vamos a casa?”. En este último caso, utilice un
punto.

14.3 Timbre

El timbre de un sonido es la calidad del sonido. Es la diferencia entre la voz de un DALEK y la voz de un humano (por
ejemplo). Para controlar el timbre cambie los ajustes numéricos deltono, velocidad, bocaygarganta argumentos.

Las configuraciones de tono (qué tan alto o bajo suena la voz) y velocidad (qué tan rápido se pronuncia el discurso) son bastante
obvias y generalmente se clasifican en las siguientes categorías:

Paso:
• 0-20 poco práctico

• 20-30 muy alto

• 30-40 alto

14.1. Funciones 107

BBC micro:bit Documentación de MicroPython, versión 1.0.1

• 40-50 alto normal

• 50-70 normales

• 70-80 bajo normal

• 80-90 bajo

• 90-255 muy bajo

(El valor predeterminado es 64)

Velocidad:

• 0-20 poco práctico

• 20-40 muy rápido

• 40-60 rápido

• 60-70 conversacionales rápidos

• 70-75 conversacional normal

• 75-90 narrativa

• 90-100 lento

• 100-225 muy lento

(El valor predeterminado es 72)

Los valores de boca y garganta son un poco más difíciles de explicar y las siguientes descripciones se basan en nuestras impresiones auditivas
del habla producidas a medida que se cambia el valor de cada configuración.

Para la boca, cuanto más bajo sea el número, más parecerá que el hablante está hablando sin mover los labios. Por el contrario, los números
más altos (hasta 255) hacen que parezca que el discurso se enuncia con movimientos exagerados de la boca.

Para la garganta, cuanto menor sea el número, más relajado suena el hablante. Por el contrario, cuanto mayor es el número, más
tenso se vuelve el tono de voz.

Lo importante es experimentar y ajustar la configuración hasta obtener el efecto que deseas.

Para comenzar, aquí hay algunos ejemplos:

discurso.decir("Soy un pequeño robot", velocidad=92, paso=60, garganta=190, boca=190) discurso.decir(

"Soy un elfo", velocidad=72, paso=64, garganta=110, boca=160) discurso.decir("Soy presentador de
noticias", velocidad=82, paso=72, garganta=110, boca=105) discurso.decir("Soy una señora mayor",
velocidad=82, paso=32, garganta=145, boca=145) discurso.decir("Soy ET", velocidad=100, paso=64,
garganta=150, boca=200)
discurso.decir("Soy un DALEK - EXTERMINAR", velocidad=120, paso=100, garganta=100, boca=200)

14.4 Fonemas

EldecirEsta función facilita la producción de voz, pero a menudo no es precisa. Para asegurarse de que el sintetizador de voz
pronuncie las cosasexactamenteComo quieras, necesitas usar fonemas: las unidades de sonido perceptualmente distintas más
pequeñas que se pueden usar para distinguir diferentes palabras. Esencialmente, son los sonidos básicos del habla.

ElpronunciarLa función toma una cadena que contiene una versión simplificada y legible delAlfabeto Fonético
Internacionaly anotaciones opcionales para indicar inflexión y énfasis.

¡La ventaja de usar fonemas es que no es necesario saber deletrear! Más bien, sólo hay que saber decir la palabra
para poder deletrearla fonéticamente.

108 Capítulo 14. Discurso

 BBC micro:bit Documentación de MicroPython, versión 1.0.1

La siguiente tabla enumera los fonemas comprendidos por el sintetizador.

Nota:La tabla contiene el fonema como caracteres y una palabra de ejemplo. Las palabras de ejemplo tienen el sonido del fonema
(entre paréntesis), pero no necesariamente las mismas letras.

A menudo se pasa por alto: el símbolo del sonido “H” es /h.Una parada glotal es una interrupción forzada del sonido.

VOCALES SIMPLES CONSONANTES SONORAS

IY pies R (rojo
HI alfiler l permitir
EH mendigar W. lejos
AE S(a)m W. (ballena
Automóvil club británico maceta Y (tú
Ah presupuesto METRO sa(m)
ao hablar norte hombre)
OH cono NX canción)
OH libro B (malo
experiencia de usuario botín D (perro
urgencias pájaro GRAMO de nuevo
HACHA galón j (juez
IX dígito z (zoo
ZH placer
DIPTONGOS V Siete
ey hecho HD (entonces
SÍ alto)
oy chico)
AW cómo) CONSONANTES SORDAS
AY lento) S (S) soy
universidad multitud) SH pez)
F (pez
TH (th)en
FONEMAS ESPECIALES PAG (dar un toque

UL asentarse) (=AXL) astron(om)y t (hablar

MU (=Función AXM) (=AXN) gatito- k (pastel
Naciones Unidas es (oclusión glotal) CH discurso)
q /h adelante

Los siguientes símbolos no estándar también están disponibles para el usuario:

YX Terminación de diptongo (versión más débil de Y)

WX Terminación de diptongo (versión más débil de W)
RX R después de una vocal (versión suave de R) L
LX después de una vocal (versión suave de L)
/X H antes de un no-vocal anterioroconsonante-como en(quien)o Tcomo
DX enpi(t)y (versión más débil de T)

A continuación se muestran algunas combinaciones de fonemas que se utilizan con poca frecuencia (y alternativas sugeridas):

FONEMA PROBABLEMENTE QUIERES: A MENOS QUE DIVIDE SÍLABAS COMO:

COMBINACIÓN
GS GZ y.gramo.ba(gs) BZe. repelente de insectos

Licenciatura gramo.slo(bz) DZ e. obsceno

DS gramo.su(ds) PS e. Hu(ds)hijo
PZ gramo.sla(ps) TS e. -----
TZ gramo.cur(ts)y KS e. -----
KZ gramo.arreglar) -----
(continúa en la página siguiente)

14.4. Fonemas 109

BBC micro:bit Documentación de MicroPython, versión 1.0.1

(Continuación de la página anterior)

NG NXG y.gramo.cantando tasa de i(ng)

NK NXK e.gramo.banco su(nk)ista

Si utiliza cualquier otra cosa que no sean los fonemas descritos anteriormente, unError de valorse planteará una excepción. Pase los fonemas
como una cadena como esta:

discurso.pronunciar("/HEHLOW")# "Hola"

Los fonemas se clasifican en dos grandes grupos: vocales y consonantes.

Las vocales se subdividen en vocales simples y diptongos. Las vocales simples no cambian su sonido cuando las pronuncias, mientras
que los diptongos comienzan con un sonido y terminan con otro. Por ejemplo, cuando dices la palabra "aceite", la vocal "oi" comienza
con un sonido "oh" pero cambia a un sonido "ee".

Las consonantes también se subdividen en dos grupos: sonoras y sordas. Las consonantes sonoras requieren que el hablante utilice
sus cuerdas vocales para producir el sonido. Por ejemplo, se expresan consonantes como “L”, “N” y “Z”. Las consonantes sordas se
producen con el aire en movimiento, como “P”, “T” y “SH”.

Una vez que te acostumbras, el sistema de fonemas es sencillo. Para empezar, algunas ortografías pueden parecer complicadas (por ejemplo,
“aventura” tiene una “CH”) pero la regla es escribir lo que dices, no lo que deletreas. La experimentación es la mejor manera de resolver
palabras problemáticas.

También es importante que el habla suene natural y comprensible. Para ayudar a mejorar la calidad de la producción hablada, a menudo es
bueno utilizar el sistema de acentuación incorporado para agregar inflexión o énfasis.

Hay ocho marcadores de estrés indicados por los números.1 - 8.Simplemente inserte el número requerido después de la vocal que
desea acentuar. Por ejemplo, la falta de expresión de "/HEHLOW" mejora mucho (y es más amigable) cuando se escribe "/HEH3LOW".

También es posible cambiar el significado de las palabras mediante la forma en que se acentúan. Considere la frase "¿Por qué debería caminar
hasta la tienda?". Podría pronunciarse de varias maneras diferentes:

# Necesitas una razón para hacerlo.

discurso.pronunciar("WAY2 SHUH7D AY WAO5K TUX DHAH STOH5R.")
# Eres reacio a ir.
discurso.pronunciar("WAY7 SHUH2D AY WAO7K TUX DHAH STOH5R.")
# Quieres que alguien más lo haga.
discurso.pronunciar("WAY5 SHUH7D AY2 WAO7K TUX DHAH STOHR.")
# Prefieres conducir.
discurso.pronunciar("WAY5 SHUHD AY7 WAO2K TUX7 DHAH STOHR.")
# Quieres caminar a otro lugar.
discurso.pronunciar("WAY5 SHUHD AY WAO5K TUX DHAH STOH2OH7R.")

En pocas palabras, diferentes acentos en el discurso crean un tono de voz más expresivo.

Funcionan subiendo o bajando el tono y alargando el sonido vocal asociado según el número que proporciones:

1. estrés muy emocional

2. estrés muy enfático

3. estrés bastante fuerte

4. estrés ordinario

5. tensión apretada

6. tensión neutral (sin cambio de tono)

7. estrés vertiginoso
8. estrés extremo por la caída del tono

110 Capítulo 14. Discurso

 BBC micro:bit Documentación de MicroPython, versión 1.0.1

Cuanto menor sea el número, más extremo será el énfasis. Sin embargo, estos marcadores de estrés ayudarán a pronunciar correctamente
las palabras difíciles. Por ejemplo, si una sílaba no se enuncia lo suficiente, coloque un marcador de acento neutro.

También es posible alargar palabras con marcadores de acento:

discurso.pronunciar("/HEH5EH4EH3EH2EH2EH3EH4EH5EHLP.”)

14.5 Canto

Es posible hacer que MicroPython cante fonemas.

Esto se hace anotando un número relacionado con el tono en un fonema. Cuanto menor sea el número, mayor será el tono. Los números se
traducen aproximadamente en notas musicales como se muestra en el siguiente diagrama:

Las anotaciones funcionan anteponiendo un signo de almohadilla (#) y el número de tono delante del fonema. El tono seguirá siendo el mismo
hasta que se dé una nueva anotación. Por ejemplo, haz que MicroPython cante una escala como esta:

solfa=[
"#115DOWWWWWW", #doh
"#103REYYYYYY", # Re
"#94MIAAAAAA", #mi
"#88FAOAOAOAOR", #Fa
"#78SOHWWWWW", #soy
"#70LAOAOAOAOR", #la
"#62TIAAAAAA", #ti
"#58DOWWWWWW", #doh
]
canción=''.unirse (solfa) discurso.
cantar(canción, velocidad=100)

14.5. Cantando 111

BBC micro:bit Documentación de MicroPython, versión 1.0.1

Para cantar una nota durante un tiempo determinado, extienda la nota repitiendo fonemas vocales o consonantes sonoros (como se
demuestra en el ejemplo anterior). Tenga cuidado con los diptongos: para extenderlos es necesario dividirlos en sus partes
componentes. Por ejemplo, "OY" se puede ampliar con "OHOHIYIYIY".

Experimentar, escuchar atentamente y ajustar es la única forma segura de calcular cuántas veces se debe repetir un fonema
para que la nota dure el tiempo deseado.

14.6 ¿Cómo funciona?

El manual original lo explica bien:

Primero, en lugar de registrar la forma de onda del habla real, solo almacenamos los espectros de frecuencia. Al hacer esto,
ahorramos memoria y obtenemos otras ventajas. En segundo lugar, nosotros [. . . ] almacena algunos datos sobre el tiempo.
Estos son números relacionados con la duración de cada fonema en diferentes circunstancias, y también algunos datos sobre
los tiempos de transición para que podamos saber cómo combinar un fonema con sus vecinos. En tercer lugar, ideamos un
sistema de reglas para manejar todos estos datos y, para nuestro asombro, nuestra computadora comienza a balbucear en
poco tiempo.

— Manual del propietario de SAM.

La salida se canaliza a través de las funciones proporcionadas por elaudiomódulo y, listo, tenemos un micro:bit parlante.

14.7 Ejemplo

importardiscurso
demicrobitimportardormir

# El método say intenta convertir el inglés en fonemas. discurso.decir("¡Puedo

cantar!") dormir(1000)

discurso.decir("¡Escúchame!")
dormir(1000)

# Aclararse la garganta requiere el uso de fonemas. Cambiando

# el tono y la velocidad también ayudan a crear el efecto correcto. discurso.
pronunciar("AEAE/HAEMM", paso=200, velocidad=100)#Ejem dormir(1000)

# Cantar requiere un fonema con un tono anotado para cada sílaba. solfa=[

"#115DOWWWWWW", #doh
"#103REYYYYYY", # Re
"#94MIAAAAAA", #mi
"#88FAOAOAOAOR", #Fa
"#78SOHWWWWW", #soy
"#70LAOAOAOAOR", #la
"#62TIAAAAAA", #ti
"#58DOWWWWWW", #doh
]

# Cante la escala ascendente en tono. canción=''.

unirse (solfa) discurso.cantar(canción, velocidad=
100)
# Invertir la lista de sílabas.
(continúa en la página siguiente)

112 Capítulo 14. Discurso

 BBC micro:bit Documentación de MicroPython, versión 1.0.1

(Continuación de la página anterior)

solfa.contrarrestar()
canción=''.unirse(solfa)
# Cante la escala de tono descendente. discurso.
cantar(canción, velocidad=100)

14.7. Ejemplo 113

BBC micro:bit Documentación de MicroPython, versión 1.0.1

114 Capítulo 14. Discurso

 CAPÍTULO 15

utime

ElutimeEl módulo proporciona funciones para obtener la hora y fecha actuales, medir intervalos de tiempo y retrasos.

Nota:ElutimeEl módulo es una implementación MicroPython del estándar Python.tiempomódulo. Se puede importar usando
ambosimportar tiempoytiempo de importación,pero el módulo es el mismo.

15.1 Funciones

tiempo.dormir(segundos)
Duerme durante el número de segundos indicado. Puede usar un número de punto flotante para dormir durante una
fracción de segundos, o usar elutime.sleep_ms()yutime.sleep_us()funciones.

tiempo.dormir_ms(EM)
El retraso para un número determinado de milisegundos debe ser positivo o 0.

tiempo.dormir_nosotros(a nosotros)

El retraso para un número determinado de microsegundos debe ser positivo o 0.

tiempo.ticks_ms()
Devuelve un contador creciente de milisegundos con un punto de referencia arbitrario, que se ajusta después de algún valor.

tiempo.ticks_us()
Al igual queutime.ticks_ms()arriba, pero en microsegundos.

tiempo.ticks_add(garrapatas,delta)
Compensa el valor de los ticks en un número determinado, que puede ser positivo o negativo. Dado un valor de ticks, esta función
permite calcular el valor delta de ticks antes o después de él, siguiendo la definición aritmética modular de los valores de ticks.

Ejemplo:

# Descubra qué valor de ticks había hace 100 ms imprimir

(ticks_add(hora.ticks_ms(),-100))

(continúa en la página siguiente)

115
BBC micro:bit Documentación de MicroPython, versión 1.0.1

(Continuación de la página anterior)

# Calcule la fecha límite para la operación y pruébela fecha límite=

ticks_add(hora.ticks_ms(),200) mientrasticks_diff(fecha límite, hora.
ticks_ms())>0:
hacer_un_poco_de_algo()

# Descubra los TICKS_MAX utilizados por este

puerto imprimir(ticks_add(0,-1))

tiempo.ticks_diff(garrapatas1,garrapatas2)
Medir la diferencia de ticks entre los valores devueltos desdeutime.ticks_ms()oticks_us()funciones, como un
valor con signo que puede ajustarse.

El orden de los argumentos es el mismo que para el operador de resta,ticks_diff(ticks1, ticks2)tiene el mismo
significado quegarrapatas1 - garrapatas2.

utime.ticks_diff()está diseñado para adaptarse a varios patrones de uso, entre ellos:

Sondeo con tiempo de espera. En este caso, se conoce el orden de los acontecimientos y sólo se tratará con resultados
positivos de utime.ticks_diff():

# Espere a que se confirme el pin GPIO, pero como máximo 500us

comenzar=tiempo.ticks_us() mientrasalfiler.valor()==0:

sitiempo.ticks_diff(hora.ticks_us(), inicio)>500:
aumentarError de tiempo de espera

Programación de eventos. En este caso,utime.ticks_diff()El resultado puede ser negativo si un evento está vencido:

# Este fragmento de código no está optimizado

ahora=tiempo.ticks_ms() hora_programada=tarea.
hora programada() siticks_diff(tiempo_programado,
ahora)>0:
imprimir("Demasiado temprano, vamos a dormir") tarea
sleep_ms(ticks_diff(hora_programada, ahora)).correr()

elifticks_diff(tiempo_programado, ahora)==0:
imprimir("¡Justo en el momento!")
tarea.correr()
elifticks_diff(tiempo_programado, ahora)<0:
imprimir("¡Ups, llega tarde, dile a la tarea que se ejecute más rápido!") tarea.ejecutar
(ejecutar_más rápido=verdadero)

116 Capítulo 15. utime

 CAPÍTULO dieciséis

Instalación

Esta sección lo ayudará a configurar las herramientas y programas necesarios para desarrollar programas y firmware para flashear en BBC
micro:bit usando MicroPython.

16.1 Dependencias

16.2 Entorno de desarrollo

Necesitará:
• git
• yotta
Dependiendo de su sistema operativo, las instrucciones de instalación varían. Utilice el escenario de instalación que mejor se adapte a su
sistema.

Yotta requerirá una cuenta ARM mbed. Le guiará durante el proceso de registro si no está registrado.

16.3 Escenarios de instalación

• ventanas
• OSX
• linux
• Debian y Ubuntu
• Red Hat Fedora/CentOS
• Frambuesa Pi

117
BBC micro:bit Documentación de MicroPython, versión 1.0.1

16.3.1 Ventanas

Al instalaryota, asegúrese de tener estos componentes marcados para instalar.

• pitón
• gcc
• cHacer

• ninjas

• Yota
• git-scm
• controlador serie mbed

16.3.2 OSX

16.3.3 Linux

Estos pasos cubrirán las versiones básicas de Linux y el trabajo con micro:bit y MicroPython. Consulte también las secciones
específicas para Raspberry Pi, Debian/Ubuntu y Red Hat Fedora/Centos.

Debian y Ubuntu

sudo agregar-apto-repositorio-y ppa:equipo-gcc-brazo-sudo añadido

incrustado-apto-repositorio-y ppa:pmiller-fuente abierta/ppa sudo apto
-obtener actualización
sudo apto-instalar cmake ninja-construir gcc-brazo-ninguno-eabi srecord libssl-dev pip3 instala yotta

Red Hat Fedora/CentOS

Frambuesa Pi

16.4 Próximos pasos

Felicidades. Ha instalado su entorno de desarrollo y está listo para comenzar.Floridafirmware intermitenteal

micro:bit.

118 Capítulo 16. Instalación

 CAPÍTULO 17

Firmware intermitente

17.1 Creación de firmware

Usa yotta para construir.

Utilice el objetivo bbc-microbit-classic-gcc-nosd:

yt objetivo bbc-microbit-clásico-gcc-cabecear

Ejecute yotta update para recuperar activos remotos:

yt arriba

Comience la compilación con yotta:

yt construir

. . . o utilice el Makefile:

hacertodo

El resultado es un archivo hexadecimal microbit-micropython (es decir,microbit-micropython.hex)que se encuentra en build/

bbcmicrobit-classic-gcc-nosd/source desde la raíz del repositorio.

El Makefile realiza un preprocesamiento adicional de la fuente, que sólo es necesario si agrega nuevas cadenas
internas aqstrdefsport.h.Makefile también coloca el firmware resultante en build/firmware.hex e incluye algunos
objetivos convenientes.

17.2 Preparación del firmware y un programa Python

herramientas/hacer combinado

hexlificar

119
BBC micro:bit Documentación de MicroPython, versión 1.0.1

17.3 Flasheo al micro:bit

Escenarios de instalación

• ventanas
• OSX
• linux
• Debian y Ubuntu
• Red Hat Fedora/CentOS
• Frambuesa Pi

120 Capítulo 17. Actualización del firmware

 CAPÍTULO 18

Accediendo al REPL

REPL (Read-Evaluate-Print-Loop) permite que micro:bit lea y evalúe el código en tiempo real mientras lo escribe.

Para acceder al REPL en el micro:bit será necesario:

• Determinar el identificador del puerto de comunicación para el micro:bit

• Utilice un programa para establecer comunicación con el dispositivo

Para versiones de Windows anteriores a 10, es posible que necesite instalar el controlador serie Mbed, cuyas instrucciones se
encuentran aquí:

https://os.mbed.com/docs/latest/tutorials/windows-serial-driver.html

18.1 Usando un programa de comunicación serial

Eleditor mutiene soporte incorporado para REPL e incluso incluye un trazador de datos en tiempo real. Algunas otras opciones
comunes sonpicocomypantalla. Deberá instalar un programa y leer la documentación adecuada para comprender los conceptos
básicos de conexión a un dispositivo.

18.2 Determinar el puerto

El micro:bit tendrá un identificador de puerto (tty, usb) que la computadora puede utilizar para comunicarse. Antes de conectarnos al
micro:bit debemos determinar el identificador del puerto.

ventanas
Cuando haya instalado los controladores antes mencionados, el micro:bit aparecerá en el administrador de dispositivos como un puerto COM.

Mac OS
Abra Terminal y escribals /dev/cu.*para ver una lista de dispositivos seriales conectados; uno de ellos se parecerá a /dev/
cu.usbmodem1422 (el número exacto dependerá de su computadora).

linux

121
BBC micro:bit Documentación de MicroPython, versión 1.0.1

En la terminal, escribadmesg | colaque mostrará cuál /desarrolladornodo al que se asignó el micro:bit (por ejemplo, /dev/
ttyUSB0).

18.3 Comunicación con el micro:bit

Una vez que haya encontrado el identificador del puerto, puede utilizar un programa de terminal serie para comunicarse con el micro:bit.

ventanas
Es posible que desee utilizar Tera Term, PuTTY u otro programa.

En Tera Término:

• Conecte el micro:bit y abra Tera Term

• Seleccione Serie como puerto

• Vaya a Configuración -> Puerto serie. Asegúrese de que el puerto sea el puerto COM correcto.

• Elija una velocidad en baudios de115200,datos 8 bits, paridad ninguna, parada 1 bit.

En masilla:
• Conecte el micro:bit y abra PuTTY
• Cambie el tipo de conexión a serie
• Asegúrese de que el puerto sea el puerto COM correcto

• Cambie la velocidad en baudios a115200

• Seleccione 'Serie' en el menú de la izquierda, luego haga clic en 'Abrir'

Mac OS
Abra Terminal y escribapantalla /dev/cu.usbmodem1422 115200,reemplazando /dev/cu.usbmodem1422 con el puerto que
encontraste anteriormente. Esto abrirá la salida serial del micro:bit y mostrará todos los mensajes recibidos del dispositivo.
Para salir, presione Ctrl-A y luego Ctrl-D.

linux
Utilizando elpantallaprograma, tipopantalla /dev/ttyUSB0 115200,reemplazando /dev/ttyUSB0con el puerto que encontraste
anteriormente.

Usandopicocom,tipopicocom /dev/ttyACM0 -b 115200,reemplazando nuevamente /dev/ttyACM0con el puerto que encontraste

anteriormente.

122 Capítulo 18. Acceso al REPL

 CAPÍTULO 19

Archivo hexadecimal de firmware

Cuando se construye MicroPython, el compilador produce unIntel hexagonalarchivo que contiene el firmware de MicroPython. Luego se
pueden agregar datos adicionales a este archivo para contener información sobre la versión de MicroPython o el código Python para ejecutar
al inicio.

El diseño general de memoria utilizado es:

• 0x00000000:Inicio del firmware MicroPython: hasta 248 KB

• 0x0003e000:Inicio del script adjunto (opcional): hasta 8 Kbs
• 0x100010c0:Registro de cliente UICR [16], inicio de información de MicroPython - 28 bytes

Nota:Si agrega datos o modifica el archivo Intel Hex, asegúrese de que las direcciones de los datos almacenados progresen en orden
incremental. Si hay un salto de dirección hacia atrás, DAPLink no podrá actualizar el archivo.

19.1 Formato de script adjunto

MicroPython verifica los primeros 2 bytes en la dirección0x0003e000para que una cadena mágica indique si hay un script adjunto. Si se
encuentra la cadena mágica, ejecutará automáticamente el código Python almacenado allí, a menos que haya un archivo main.py almacenado
en el sistema de archivos MicroPython.

• 0x0003e000:2 bytes “MP”

• 0x0003e002:2 bytes, entero little endian para la longitud (en bytes) del script adjunto (sin contar este encabezado de 4
bytes)

• 0x0003e004:Script almacenado como bytes, para que MicroPython lo decodifique usando utf-8.

123
BBC micro:bit Documentación de MicroPython, versión 1.0.1

19.2 Formato UICR

Los registros de configuración de información de usuario (UICR) son una región de memoria no volátil disponible para almacenar configuraciones
específicas del usuario. Los primeros 128 Bytes están reservados, pero podemos usar los otros 128 Bytes para almacenar cualquier dato arbitrario.

MicroPython almacena la siguiente información, en little endian, a partir del registro de clientes UICR[16]:

• 0x100010c0:Entero de 4 bytes con valor mágico0x17eeb07c

• 0x100010c4:Entero de 4 bytes con valor0xffffffff
• 0x100010c8:Entero de 4 bytes con valor0x0000000a (log base 2 del tamaño de página flash, siendo 1024 bytes)

• 0x100010ca:Entero de 2 bytes con valor0x0000 (página de inicio del firmware)

• 0x100010cc:Entero de 2 bytes que almacena el número de páginas utilizadas por el firmware

• 0x100010d0:Entero de 4 bytes con valor0xffffffff

• 0x100010d4:Entero de 4 bytes con la dirección en el firmware de la cadena de versión

• 0x100010d8:Entero de 4 bytes con valor0x00000000

19.3 Pasos para crear el archivo firmware.hex

La herramienta yotta se utiliza para construir MicroPython, pero antes de que eso suceda, Makefile debe generar archivos adicionales en
preparación para la compilación, y luego se agregan datos adicionales al archivo hexadecimal.

ejecutando elHaz todoEl comando ejecuta los siguientes pasos:

• Elherramientas/makeversionhdr.pyEl guión crea elmicrobitversion.h fiarchivo con macros que contienen información
de compilación

• Yotta compila el código fuente y crea un archivo hexadecimal básico solo con el firmware

• Elherramientas/adduicr.pyEl script agrega el UICR al hexadecimal desnudo.

• El archivo hexadecimal final se coloca encompilación/firmware.hex

• Opcionalmente, el usuario puede agregar un script usandoherramientas/makecombinedhex.py (u otras herramientas)

124 Capítulo 19. Archivo hexadecimal de firmware

 CAPÍTULO 20

Preguntas frecuentes para desarrolladores

Nota:Este proyecto está en desarrollo activo. Ayude a otros desarrolladores agregando sugerencias, procedimientos y preguntas y respuestas a este
documento. ¡Gracias!

¿Dónde consigo una copia del DAL? R: Pregúntele a Nicholas Tollervey para más detalles.

125
BBC micro:bit Documentación de MicroPython, versión 1.0.1

126 Capítulo 20. Preguntas frecuentes para desarrolladores

 CAPÍTULO 21

Contribuyendo

¡Ey! Muchas gracias por querer mejorar MicroPython en el micro:bit.

Las contribuciones son bienvenidas sin perjuicio dealguienindependientemente de edad, género, religión, raza o sexualidad. Un
código de buena calidad y compromiso con respeto, humor e inteligencia siempre ganan.

• Si provienes de un entorno que no está bien representado en la mayoría de los grupos geek, involúcrate.queremos ayudarte a
marcar la diferencia.

• Si eres de un entorno queesbien representado en la mayoría de los grupos geek, involúcrese.queremos tu ayuda
haciendo la diferencia.

• Si le preocupa no ser lo suficientemente técnico, involúcrese.tu nueva perspectiva será invaluable.

• Si crees que eres un impostor, involúcrate.

• Si su trabajo diario no es codificar, involúcrese.

• Este no es un grupo de expertos, sólo personas. ¡Involucrarse!

• Esta es una comunidad nueva, así que participe.

Esperamos que los contribuyentes sigan el Código de conducta de la Python Software Foundation:https://www.python.org/psf/
codeofconduct/

Se pueden dar comentarios sobre las contribuciones y, cuando sea necesario, los cambios se solicitarán cortésmente y se discutirán con el
autor original. Un argumento respetuoso pero sólido es muy bienvenido.

21.1 Lista de verificación

• Su código debe estar comentado eninglés simple(ortografía británica).

• Si su contribución es para un bloque importante de trabajo y aún no lo ha hecho, agréguese al archivo AUTORES
siguiendo la convención que se encuentra allí.

• En caso de duda, haga una pregunta. La única pregunta estúpida es la que nunca se hace.

• ¡Divertirse!

127
BBC micro:bit Documentación de MicroPython, versión 1.0.1

• geníndice

• modíndice

• buscar

128 Capítulo 21. Contribuyendo

 Índice del módulo Python

a
audio,75

metro

máquina,83
microbit,54
acelerómetro de microbits,68
microbit.brújula,72
pantalla.de.microbits,63
microbit.i2c,67
microbit.spi,66
microbit.uart,64
micropitón,85
música,87

norte

neopíxel,93

oh
os,97

r
radio,99
aleatorio,103

s
discurso,105

tu
tiempo,115

129
BBC micro:bit Documentación de MicroPython, versión 1.0.1

130 Índice del módulo Python

 Índice

A get_presses() (método de botón),54 get_tempo() (en el

any() (método microbit.uart.uart),sesenta y cinco módulo música),89 get_values() (en el módulo

audio (módulo),75 microbit.accelerometer),68 get_x() (en el módulo

AudioFrame (clase de audio),75 microbit.accelerometer),68 get_x() (en el módulo

microbit.compass),72 get_y() (en el módulo
B microbit.accelerometer),68 get_y() (en el módulo
microbit.compass),72 get_z() (en el módulo
blit() (método microbit.Image),61
microbit.accelerometer),68 get_z() (en el módulo
Botón (clase incorporada),54
microbit.compass),72 getrandbits() (en módulo aleatorio),
botón_a,54
103
botón_b,54

h
BytesIO (clase incorporada),82

C encabezado() (en el módulo microbit.compass),72

altura() (método microbit.Image),60
calibrar() (en el módulo microbit.compass),72 elección() (en
módulo aleatorio),103 clear() (en el módulo microbit.display),
63 clear() (método neopixel.NeoPixel),94 clear_calibration()
I
(en el módulo microbit.compass),72 cerrar() (método Imagen (clase en microbit),59 init() (en el módulo
BytesIO),82 config() (en el módulo de radio),100 copiar() microbit.i2c),67 init() (en el módulo microbit.spi),66
(método microbit.Image),61 crop() (método microbit.Image), init() (en el módulo microbit.uart),64 invert() (método
60 current_gesture() (en el módulo microbit.accelerometer), microbit.Image),61 is_calibrated() (en el módulo
68 microbit.compass),72 is_gesture() (en el módulo
microbit.accelerometer),68 is_on() (en el módulo
microbit.display),64 is_pressed() (método de botón),54

D
enable_irq() (método máquina.máquina),83 is_touched() (método microbit.MicroBitTouchPin),58

mi l
enable_irq() (método máquina.máquina),83 listdir() (en el módulo os),97

F METRO

fill() (método microbit.Image),61 freq() máquina (módulo),83

(método máquina.máquina),83 microbit (módulo),53,54,59
acelerómetro microbit (módulo),68
GRAMO microbit.compass (módulo),72
microbit.display (módulo),63
get_field_strength() (en el módulo microbit.compass),72
microbit.i2c (módulo),67 microbit.spi
get_gestures() (en el módulo microbit.accelerometer),68
(módulo),66 microbit.uart (módulo),
get_pixel() (en el módulo microbit.display),63 get_pixel()
64
(método microbit.Image),60

131
BBC micro:bit Documentación de MicroPython, versión 1.0.1

MicroBitAnalogDigitalPin (clase en microbit),58 readinto() (método microbit.uart.uart),66

MicroBitDigitalPin (clase en microbit),57 MicroBitTouchPin readline() (método BytesIO),82 readline() (método
(clase en microbit),58 micropython (módulo),85 microbit.uart.uart),66 recibir() (en el módulo de
micropython.const() (en el módulo micropython),85 radio),101 recibir_bytes() (en el módulo de radio),
micropython.heap_lock() (en el módulo micropython),86 100 recibir_bytes_into() (en la radio del módulo),
micropython.heap_unlock() (en el módulo micropython),86 101 recibir_full() (en el módulo de radio),101
micropython.kbd_intr() (en el módulo micropython),86 remove() (en el módulo os),97 reset() (en el
micropython.mem_info() (en el módulo micropython),85 microbit del módulo),53 reset() (en el módulo de
micropython.opt_level() (en el módulo micropython),85 música),90 reset() (en el módulo de radio),100
micropython.qstr_info() (en el módulo micropython),86 reset() (método máquina.máquina),83
micropython.stack_use() (en el módulo micropython),86 running_time() (en el módulo microbit),53
música (módulo),87

norte S
nombre() (método BytesIO),82 say() (en el discurso del módulo),107 scan() (en el módulo
NeoPixel (clase en neopixel),94 microbit.i2c),67 scroll() (en el módulo microbit.display),63
neopíxel (módulo),93 semilla() (en módulo aleatorio),103 send() (en el módulo de
radio),101 send_bytes() (en el módulo de radio),100
oh set_analog_period() (microbit.MicroBitAnalogDigitalPin
off() (en el módulo microbit.display),64
off() (en el módulo de radio),100
on() (en el módulo microbit.display),64 on() (en el método),58
módulo de radio),100 open() (función set_analog_period_microsegundos() (micro-
incorporada),82 sistema operativo (módulo),97 bit.MicroBitAnalogDigitalPin método),
58
set_pixel() (en el módulo microbit.display),63
PAG set_pixel() (método microbit.Image),60
pánico() (en el módulo microbit),53 tono() (en
set_tempo() (en el módulo de música),89
el módulo de música),89 play() (en el módulo
shift_down() (método microbit.Image),60
de audio),75 play() (en el módulo música),89
shift_left() (método microbit.Image),60
pronunciar() (en el habla del módulo),107
shift_right() (método microbit.Image),60
shift_up() (método microbit.Image),60 show()
(en el módulo microbit.display),63 show()
R (método neopixel.NeoPixel),94 sing() (en el
discurso del módulo),107 size() (en el módulo
radio (módulo),99
os),97 dormir() (en el módulo microbit),53
randint() (en módulo aleatorio),103
dormir() (método utime.utime),115 sleep_ms()
aleatorio (módulo),103
(método utime.utime),115 sleep_us() (método
aleatorio() (en el módulo aleatorio),104
utime.utime),115 discurso (módulo),105
randrange() (en módulo aleatorio),103
RATE_1MBIT (en la radio del módulo),99
RATE_250KBIT (en la radio del módulo),99
stop() (en el módulo de música),90
RATE_2MBIT (en la radio del módulo),100
leer() (método BytesIO),82 read() (en el
módulo microbit.i2c),67 read() (método
t
microbit.spi.spi),67 read() (método
temperatura() (en microbit del módulo),53 TextIO
microbit.uart.uart),sesenta y cinco
(clase incorporada),82 ticks_add() (método
lectura_analógica() (método utime.utime),115 ticks_diff() (método utime.utime),
microbit.MicroBitAnalogDigitalPin),58 116 ticks_ms() (método utime.utime),115 ticks_us()
read_digital() (método microbit.MicroBitDigitalPin),57
(método utime.utime),115 time_pulse_us() (método
read_light_level() (en el módulo microbit.display),64 readall()
máquina.máquina),83 traducir() (en voz del
(método microbit.uart.uart),sesenta y cinco readinto() (método
módulo),107
BytesIO),82

132 Índice
 BBC micro:bit Documentación de MicroPython, versión 1.0.1

Ud.
uname() (en el módulo os),97 uniforme() (en
módulo aleatorio),104 Unique_id() (método
máquina.máquina),83 utime (módulo),115

W.
was_gesture() (en el módulo microbit.accelerometer),68
was_pressed() (método de botón),54 ancho() (método
microbit.Image),60 grabable() (método BytesIO),82 escribir()
(método BytesIO),82 escribir() (en el módulo microbit.i2c),67
escribir() (método microbit.spi.spi),67 escribir() (método
microbit.uart.uart),66 write_analog()
(microbit.MicroBitAnalogDigitalPin

método),58
write_digital() (método microbit.MicroBitDigitalPin),58
write_readinto() (método microbit.spi.spi),67

Índice 133