# Tutorial de MicroPython
## Descargar archivo de código
Nota: Todo el código del curso está disponible para descargar aquí. Los enlaces de descarga no se proporcionarán más adelante. Para evitar olvidarlo, le recomendamos descargar el código ahora para el futuro aprendizaje del tutorial.
[Haga clic para descargar](./MiroPython_Resource.7z)
## 1. MU IDE
### 1.1 Instalar MU IDE
Mu es un editor de código Python para programadores principiantes basado en profesores y estudiantes. La forma más fácil de obtener Mu es a través del instalador oficial para Windows o Mac OSX (Mu ya no es compatible con Windows de 32 bits). La versión actual recomendada es Mu 1.0-beta 2.
#### Paso 1 - Determinar la versión y descargar el instalador de Mu
Abra el enlace: [https://codewith.mu/en/download](https://codewith.mu/en/download) para descargar la versión correspondiente del software Mu.
Averigüe si su computadora ejecuta Windows o Mac OSX, y abra el Explorador, haga clic en "Este PC", luego seleccione Propiedades para saber si su sistema Windows es de 32 o 64 bits.
**Ver el tipo de sistema:**
#### Paso 2 - Ejecutar el instalador
Localice el instalador que acaba de descargar (puede estar en su carpeta de descargas) y haga doble clic para abrir el archivo del instalador.
Enlace de descarga para el sistema Mac OSX: [https://codewith.mu/en/howto/1.1/install_macos](https://codewith.mu/en/howto/1.1/install_macos)
**Sistema Windows 10**
Toque "Más información"
Introduzca "Ejecutar de todos modos"
#### Paso 3 - Protocolo
Marque la licencia y luego haga clic en Instalar.
#### Paso 4 - Instalación
Tomará unos segundos instalar Mu en su computadora.
#### Paso 5 - Finalizar
Toque Finalizar
#### Paso 6 - Iniciar Mu
Puede iniciar Mu haciendo clic en el icono en el menú Inicio, o escribiendo Mu en el cuadro de búsqueda (ambos métodos se muestran a continuación).
La interfaz principal de Mu se muestra a continuación:
### 1.2 Configuración del compilador e introducción a la barra de herramientas
Primero, configure el "modo" en micro:bit.
Abra el software Mu, haga clic en el botón Mode en la barra de menú y seleccione "BBC micro:bit", luego toque "OK".
### 1.3 Instalar el archivo de la biblioteca
Antes de importar la biblioteca, debe cargar un código .py a micro:bit. Aquí tomamos como ejemplo el módulo RGB "code_1.py" del tutorial.
Importar el archivo de biblioteca "keyes_MiniCar.py"
El directorio predeterminado para guardar Mu es el archivo "Mu_code", que se encuentra en la raíz del directorio de usuario.
Por ejemplo, en Windows, si su sistema está instalado en la unidad C de su computadora y el nombre de usuario es Administrador, la ruta al directorio mu_code es C:\Users\Administrator\mu_code. En Linux, la ruta es ~/home/mu_code.
**Entrar en el archivo "mu_code"**
Copie el archivo de la biblioteca "keyes_MiniCar.py" a la carpeta "mu_code". La ruta del código es la siguiente:
Abra el software Mu y conecte el micro:bit a su computadora, luego haga clic en el botón "Files" y arrastre el archivo de la biblioteca "keyes_MiniCar.py" al micro:bit.
Después de que la importación sea exitosa, lo verá en el cuadro izquierdo.
Toque "Check" para verificar si el código tiene errores. Si aparece una línea con un cursor o un guion bajo, hay un error en el programa para esa línea.
Estos consejos son solo advertencias, no consejos de error de código.
También debe asegurarse de que el cable micro USB esté conectado al micro:bit y a la computadora, y luego haga clic en el botón "Flash" para descargar el código al micro:bit.
Si hay un error después de hacer clic en el botón "Flash", confirme si ha importado el archivo de la biblioteca a micro:bit.
Nota:
Si ha descargado otros programas en la placa micro:bit, excepto el archivo de la biblioteca "keyes_MiniCar.py". Antes de programar en Micropython, debe importar el archivo de la biblioteca al micro:bit.
Si siempre usa la misma placa micro:bit para programar en Micropython, no necesita enviarla al micro:bit nuevamente.
### 1.4 Añadir código al compilador
Tomamos como ejemplo el primer proyecto del tutorial básico "Latido del corazón", abrimos la carpeta "Program" en la primera carpeta del proyecto y localizamos el archivo "microbit-Heartbeat".
O abra el software Mu y toque el archivo "microbit-Heartbeat.py", luego arrástrelo al software Mu:
como se muestra a continuación:
### 1.5 Descargar código a Micro:bit
Conecte la placa micro:bit y la computadora a través del cable micro USB.
Toque "Flash" para descargar el código a micro:bit.
Si hay un error en el código, puede descargar el código al micro:bit con éxito, pero no funcionará. Si "sleep" es "sleeps", haga clic en "Flash", y el código también se descargará al micro:bit.
Después de la descarga, si la matriz de LED muestra algunos mensajes de error, toque el botón "REPL", luego presione el botón de reinicio del micro
| display.show(val1) sleep(500) display.show(val3) sleep(500) | El LED en (1,0) parpadea durante 0.5s |
| display.show(val2) sleep(500) display.show(val3) sleep(500) | El LED en (3,4) parpadea durante 0.5s |
#### 2.2.5 Resultado de la prueba
Después de descargar el código, conecte la alimentación con un cable USB, verá que el LED en (1,0) parpadea durante 0.5s y luego el LED en (3,4) parpadea durante 0.5s, en bucle.
### 2.3 Matriz de puntos LED de 5 x 5
#### 2.3.1 Descripción
La matriz de puntos gana popularidad en nuestra vida, como las pantallas LED, las estaciones de autobús y los mini televisores en el ascensor.
La matriz de puntos de la placa Micro:bit consta de 25 diodos emisores de luz. En la lección anterior, controlamos el LED de la placa Micro:bit para formar patrones, números y cadenas de caracteres configurando los puntos de coordenadas. Además, podríamos adoptar otra forma de completar la visualización de patrones, números y cadenas de caracteres.
#### 2.3.2 Componentes necesarios
|  |  |
| :-----------------------: | :------------------: |
| Micro:bit * 1 | Micro:bit * 1 |
#### 2.3.3 Código de prueba
Puede cargar el código directamente desde el tutorial (lea el archivo "Configuración del entorno de desarrollo" si tiene dudas).
```python
from microbit import *
val = Image("00900:""00900:""90909:""09990:""00900")
display.show(val)
```
**Resultado de la prueba:** Cargue `2.3-5× 5 LED Dot Matrix-1.py` en micro:bit, luego aparecerá una flecha hacia abajo.
```python
from microbit import *
val = Image("00900:""00900:""90909:""09990:""00900")
display.show('1')
sleep(500)
display.show('2')
sleep(500)
display.show('3')
sleep(500)
display.show('4')
sleep(500)
display.show('5')
sleep(500)
display.show(val)
sleep(500)
display.scroll("hello!")
sleep(200)
display.show(Image.HEART)
sleep(500)
display.show(Image.ARROW_NE)
sleep(500)
display.show(Image.ARROW_SE)
sleep(500)
display.show(Image.ARROW_SW)
sleep(500)
display.show(Image.ARROW_NW)
sleep(500)
display.clear()
```
#### 2.3.4 Explicación del código
| código | Explicación |
| :----------------------------------------------------------- | :----------------------------------------------------------- |
| from microbit import * | importa el archivo de la biblioteca de micro:bit |
| val = Image("09000:""00000:""00000:""0000 0:""00000:") | Establece Image() en la variable val |
| display.show(val) | micro:bit muestra "→" |
| display.show('1') | display.show('1') |
| sleep(500) | sleep(500) |
| display.scroll("hello!") | micro:bit se desplaza para mostrar "hello!" |
| display.show(Image.HEART) | micro:bit muestra "❤" |
| display.show(Image.ARROW_NE) display.show(Image.ARROW_SE) display.show(Image.ARROW_SW) display.show(Image.ARROW_NW) | micro:bit muestra la flecha "Noreste" micro:bit muestra la flecha "Sureste" micro:bit muestra la flecha "Suroeste" micro:bit muestra la flecha "Noroeste" |
| display.clear() | La matriz de puntos LED de micro:bit se borra |
#### 2.3.5 Resultado de la prueba
Descargue `2.3-5×5 LED Dot Matrix-2.py` en micro:bit, luego la matriz de puntos LED mostrará "1", "2",
"3", "4", "5", "↓", "hello!", "❤", , , ,  patrones. Cada intervalo es de 500ms.
### 2.4 Botones programables
#### 2.4.1 Descripción
El botón puede controlar el encendido y apagado del circuito, que está conectado al circuito. El circuito se desconecta cuando no se presiona el botón. El circuito se conecta tan pronto como se presiona, pero se desconecta después de soltarlo.
Ambos extremos del botón son como dos montañas. Hay un río en medio. La pieza de metal interna conecta los dos lados para permitir el paso de la corriente, como construir un puente para conectar las dos montañas.
**Principio de funcionamiento**: Antes de presionar el botón, 1, 2, 3 y 4 están encendidos, pero 1, 3 o 1, 4 o 2, 3 o 2, 4 están desconectados (bloqueados), que se encenderán cuando se presione el botón.
La placa Micro:bit tiene tres botones, el botón de reinicio está en la parte posterior y dos botones programables están en la parte frontal. Presione A, B y AB al mismo tiempo respectivamente, y la pantalla correspondiente los mostrará respectivamente.
#### 2.4.2 Componentes necesarios
|  |  |
| :-----------------------: | :------------------: |
| Micro:bit * 1 | Micro:bit * 1 |
#### 2.4.3 Código de prueba
Puede cargar el código directamente desde el tutorial (lea el archivo "Configuración del entorno de desarrollo" si tiene dudas).
```python
from microbit import *
while True:
if button_a.is_pressed():
display.show("A")
elif button_a.is_pressed() and button_b.is_pressed():
display.scroll("AB")
elif button_b.is_pressed():
display.show("B")
```
**Resultado de la prueba:** Cargue `2.4-Programmable Buttons-1.py` y conecte micro:bit a través de un cable USB, presione "A" en la placa Micro:bit, se mostrará el carácter "A"; en caso de que se presione B, aparecerá la letra "B". Se mostrará "AB" si presiona los botones A y B simultáneamente.
```python
from microbit import *
a = 0
b = 0
val1 = Image("00000:""00000:""00000:""00000:""00900")
val2 = Image("00000:""00000:""00000:""00900:""99999")
val3 = Image("00000:""00000:""00900:""99999:""99999")
val4 = Image
| sleep(500) | Retraso de 500ms |
| **if** temperature() >= 35: display.show(Image.HEART) **else**: display.show(Image.HEART_SMALL) | Si el valor de la temperatura ≥35℃ micro:bit muestra “ ” Si el valor de la temperatura <35℃ micro:bit muestra “ ” |
### 2.6 Brújula
#### 2.6.1 Descripción
Este proyecto introduce principalmente el uso de la brújula de Micro:bit. Se puede utilizar para determinar la dirección. Necesitamos calibrar la placa Micro:bit cuando el sensor magnético funciona. El método de calibración correcto es rotar la placa Micro:bit.
Además, los objetos cercanos pueden afectar la precisión de las lecturas y la calibración.
#### 2.6.2 Componentes Necesarios
|  |  |
| :-----------------------: | :------------------: |
| Micro:bit * 1 | Micro:bit * 1 |
#### 2.6.3 Código de Prueba
Puedes subir el código directamente desde el tutorial (lee el archivo "Configuración del Entorno de Desarrollo" si tienes dudas).
```python
from microbit import *
compass.calibrate()
while True:
if button_a.is_pressed():
display.scroll(compass.heading())
```
**Explicación del Código:** Necesitamos calibrar micro:bit debido a los diferentes campos magnéticos en diferentes áreas. Micro:bit te pedirá que calibres la primera vez que lo uses.
Transfiere `2.6-Magnetic sensor-1.py` a micro:bit, conecta micro:bit a través del cable USB y presiona el botón A. Aparecerá "TILT TO FILL SCREEN" en micro:bit. Luego, ingresa a la interfaz de calibración, el método de calibración es rotar la placa micro:bit y mostrar un patrón cuadrado completo (25 LEDs encendidos), como se muestra en la siguiente figura:
La calibración finaliza cuando veas el patrón de sonrisa .
El monitor serie mostrará 0°, 90°, 180° y 270° al presionar A.
--------
```python
from microbit import *
compass.calibrate()
x = 0
while True:
x = compass.heading()
if x >= 293 and x < 338:
display.show(Image("00999:""00099:""00909:""09000:""90000"))
elif x >= 23 and x < 68:
display.show(Image("99900:""99000:""90900:""00090:""00009"))
elif x >= 68 and x < 113:
display.show(Image("00900:""09000:""99999:""09000:""00900"))
elif x >= 113 and x < 158:
display.show(Image("00009:""00090:""90900:""99000:""99900"))
elif x >= 158 and x < 203:
display.show(Image("00900:""00900:""90909:""09990:""00900"))
elif x >= 203 and x < 248:
display.show(Image("90000:""09000:""00909:""00099:""00999"))
elif x >= 248 and x < 293:
display.show(Image("00900:""00090:""99999:""00090:""00900"))
else:
display.show(Image("00900:""09990:""90909:""00900:""00900"))
```
Haz que la placa micro:bit apunte al norte, sur, este y oeste horizontalmente, la matriz de puntos LED mostrará los patrones de dirección correspondientes.
Como se muestra a continuación, la flecha apunta hacia arriba a la derecha cuando el valor oscila entre 292.5 y 337.5. No se puede introducir 0.5 en el código, por lo tanto, los valores que obtenemos son 293 y 338.
Sube `2.6-Magnetic sensor-2.py` a la placa micro:bit y no desconectes el cable USB. Después de la calibración, inclina la placa Micro:bit, la matriz de puntos LED mostrará los signos de dirección.
#### 2.6.4 Explicación del Código
| código | Explicación |
| ------------------------------------------------------------ | ------------------------------------------------------------ |
| from microbit import * | Importa el archivo de la biblioteca de micro:bit |
| compass.calibrate() | Calibración de la brújula |
| while True: | Este es un bucle permanente, que hace que micro:bit ejecute el código. |
| **if** button_a.is_pressed(): display.scroll(compass.heading()) | Cuando se presiona el botón A Micro:bit muestra el valor de la brújula |
| x = 0 | Establece la variable x=0 |
| x = compass.heading() | Establece el valor de la brújula en la variable x |
| **if**...**elif**...**else** | Establece el valor de la brújula en la variable x |
| display.show(Image("00999:""0009 9:""00909:""09000:""90000")) display.show(Image("99900:""9900 0:""90900:""00090:""00009")) display.show(Image("00900:""0900 0:""99999:""09000:""00900")) display.show(Image("00009:""0009 0:""90900:""99000:""99900")) display.show(Image("00900:""0090 0:""90909:""09990:""00900")) display.show(Image("90000:""0900 0:""00909:""00099:""00999")) display.show(Image("00900:""0009 0:""99999:""00090:""00900")) display.show(Image("00900:""0999 0:""90909:""00900:""00900")) | Micro:bit muestra el signo de flecha Noreste Micro:bit muestra el signo de flecha Noroeste Micro:bit muestra el signo de flecha Oeste Micro:bit muestra el signo de flecha Suroeste Micro:bit muestra el signo de flecha Sureste Micro:bit muestra el signo de flecha Sur Micro:bit muestra el signo de flecha Este Micro:bit muestra el signo de flecha Norte |
### 2.7 Acelerómetro
#### 2.7.1 Descripción
La placa Micro:bit tiene un sensor de
| from microbit import * | Importa el archivo de la biblioteca de micro:bit |
| gesture = accelerometer.current_gesture() | Establece accelerometer.current_gesture() como gesture |
| while True: | Este es un bucle permanente, y micro:bit ejecuta el código |
| Lightintensity = display.read_light_level() | Establece display.read_light_level() como Lightintensity |
| print("Light intensity:", Lightintensity) | El REPL de BBC micro:bit imprime el valor de intensidad de luz detectado |
| sleep(100) | Retraso de 100ms |
#### 2.8.5 Resultado de la prueba
Descargue el código en la placa micro:bit, no desconecte el cable USB. Haga clic en "REPL" y presione los botones de reinicio, el valor de intensidad de luz se mostrará, como se muestra a continuación.
Al cubrir la matriz de puntos LED, el valor de intensidad es 0; por el contrario, el valor de intensidad aumenta al colocar la placa micro:bit bajo el sol.
### 2.9 Altavoz
#### 2.9.1 Descripción
La placa base micro:bit tiene un altavoz incorporado, lo que facilita mucho la adición de sonido a su proyecto. El altavoz puede programarse para emitir una variedad de tonos, como escribir una canción: Oda a la Alegría, y reproducirla.
#### 2.9.2 Componentes necesarios
|  |  |
| :-----------------------: | :------------------: |
| Micro:bit * 1 | Micro:bit * 1 |
#### 2.9.3 Código de prueba
Puede cargar el código directamente desde el tutorial (lea el archivo "Configuración del entorno de desarrollo" si tiene dudas).
```python
from microbit import *
import audio
display.show(Image.MUSIC_QUAVER)
while True:
audio.play(Sound.GIGGLE)
sleep(1000)
audio.play(Sound.HAPPY)
sleep(1000)
audio.play(Sound.HELLO)
sleep(1000)
audio.play(Sound.YAWN)
sleep(1000)
```
#### 2.9.4 Explicación del código
| Código | Explicación |
| ------------------------ | ------------------------------------------------------- |
| from microbit import * | Importa el archivo de la biblioteca de micro:bit |
| import audio | Archivo de la biblioteca de audio |
| while True: | Este es un bucle permanente, y micro:bit ejecuta el código |
| audio.play(Sound.GIGGLE) | Emite un sonido de risa |
| sleep(1000) | Retraso de 1000ms |
#### 2.9.5 Resultado de la prueba
Descargue el código en la placa micro:bit, no desconecte el cable USB, entonces el altavoz emitirá un sonido y la matriz de puntos LED mostrará un patrón de logotipo musical.
### 2.10 Logotipo sensible al tacto
#### 2.10.1 Descripción
Si tiene una placa principal micro:bit, tiene sentido usar un logotipo dorado sensible al tacto como otra entrada en su proyecto, que es como un botón adicional. Utiliza un sensor táctil capacitivo que detecta pequeños cambios en los campos eléctricos cuando lo presiona (o toca) con el dedo. Cuando lo toca, puede controlar la placa micro:bit para realizar ciertas funciones.
#### 2.10.2 Componentes necesarios
|  |  |
| :-----------------------: | :------------------: |
| Micro:bit * 1 | Micro:bit * 1 |
#### 2.10.3 Código de prueba
Puede cargar el código directamente desde el tutorial (lea el archivo "Configuración del entorno de desarrollo" si tiene dudas).
```python
from microbit import *
time = 0
start = 0
running = False
while True:
if button_a.was_pressed():
running = True
start = running_time()
if button_b.was_pressed():
if running:
time += running_time() - start
running = False
if pin_logo.is_touched():
if not running:
display.scroll(int(time/1000))
if running:
display.show(Image.HEART)
sleep(300)
display.show(Image.HEART_SMALL)
sleep(300)
else:
display.show(Image.ASLEEP)
```
#### 2.10.4 Explicación del código
（1）Micro:bit registra el tiempo en ms (miles de minutos por segundo) cuando se inicia. Esto se llama tiempo de ejecución.
（2）Cuando presiona el botón A, una variable llamada `start` se establece en el tiempo de ejecución actual.
（3）Cuando presiona el botón B, el tiempo de inicio se restará del nuevo tiempo de ejecución para determinar cuánto tiempo ha pasado desde que inició el cronómetro. Esta diferencia se agrega al tiempo total, que se almacena en una variable llamada `time`.
（4）Si presiona el icono dorado del LOGO, el programa muestra el tiempo total transcurrido en la pantalla LED. Convierte el tiempo de ms (milésimas de segundo) a segundos dividiendo por 1000. Utiliza el operador de división entera para dar el resultado de un entero.
（5）El programa también utiliza una variable booleana llamada `running` para controlar el programa. Las variables booleanas solo tienen dos valores: verdadero o falso. Si `running` es verdadero, el cronómetro se inicia. Si `running` es falso, el cronómetro no se inicia o se detiene.
（6）Si `running` es verdadero, el corazón latiendo se muestra en la pantalla de puntos LED.
（7）Si el cronómetro se ha detenido, si "running" es falso, solo mostrará la hora cuando presione el icono dorado del LOGO.
（8）Si el cronómetro ya está iniciado, si "running" es verdadero, el código también evita lecturas falsas al asegurar que la variable `time` cambie solo cuando se presiona el botón B.
#### 2.10.5 Resultado de la prueba
Cargue el código y conecte micro:bit a través de un cable USB. Presione el botón A para iniciar el cronómetro. Cuando el temporizador está en marcha, la matriz de puntos LED muestra un corazón latiendo, toque el botón B para detenerlo. Seguirá sumando tiempo, como un cronómetro real.
Presione el logotipo dorado del LOGO en la parte frontal del micro:bit para mostrar el tiempo medido en segundos. Para restablecer el tiempo a cero, presione el botón de reinicio en la parte posterior de la placa micro:bit.
### 2.11 Micrófono
#### 2.11.1 Descripción
La placa base micro:bit cuenta con un micrófono incorporado, que se puede utilizar para medir el nivel de sonido ambiental. Cuando aplaude, el indicador LED de la placa base micro:bit se encenderá. Puede medir la intensidad del sonido. En este sentido, puede hacer una tabla de nivel de sonido o luces de discoteca que estén en sintonía con la música.
#### 2.11.2 Componentes necesarios
|  |  |
| :-----------------------: | :------------------: |
| Micro:bit * 1 | Micro:bit * 1 |
#### 2.11.3 Código de prueba
Puede cargar el código directamente desde el tutorial (lea el archivo "Configuración del entorno de desarrollo" si tiene dudas).
```python
from microbit import *
while True:
if microphone.current_event() == SoundEvent.LOUD:
display.show(Image.HEART)
sleep(200)
if microphone.current_event() == SoundEvent.QUIET:
display.show(Image.HEART_SMALL)
```
**Resultado de la prueba:** Descargue `2.11-Microphone-1.
| ------ | ------------------ | -------- | ------------------ |
| Negro | 255,255,255 | Rojo | 0,255,255 |
| Verde | 255,0,255 | Azul | 255,255,0 |
| Cian | 255,0,0 | Rojo oscuro | 0,255,0 |
| Amarillo | 0,0,255 | Blanco | 0,0,0 |
| ...... | ....... | ...... | ...... |
Dado que nuestras luces LED son de ánodo común, 255 es el valor más bajo y 0 es el valor más brillante.
En este proyecto, vamos a realizar dos experimentos. Uno es hacer que dos luces RGB enciendan tres colores: rojo, verde y azul; el otro es hacer que dos luces RGB muestren gradualmente diferentes colores.
#### 3.1.2 Preparación
（1）Inserte correctamente la micro:bit en la placa de expansión.
（2）Conecte el portapilas a la placa de expansión.
（3）Encienda el interruptor de alimentación ( Deslice el interruptor POWER a la posición ON).
（4）Conecte la micro:bit y el ordenador mediante un cable micro USB.
（5）Abra el IDE de MU.
Si desea añadir la biblioteca de extensión Mini car (puede consultar el archivo "1.4 Instalar el archivo de biblioteca").
#### 3.1.3 Diagrama esquemático
**Principio de funcionamiento:** Microbit, como host, envía instrucciones al esclavo STC8G1K08 a través del IIC, luego el esclavo emite PWM para controlar las luces LED RGB. Esto ahorra en gran medida los puertos IO de la placa microbit, ya que el IIC permite controlar dos motores y dos luces LED RGB.
#### 3.1.4 Explicación del código
Funciones de los LED RGB en el archivo Keyes_MiniCar.py:
Left.red(0-255): Establece el RGB izquierdo en rojo, 0 es el más brillante y 255 es el más oscuro.
Left.green（0-255): Establece el RGB izquierdo en verde, 0 es el más brillante y 255 es el más oscuro.
Left.blue（0-255）: Establece el RGB izquierdo en azul, 0 es el más brillante y 255 es el más oscuro.
right.red（0-255）: Establece el RGB derecho en rojo, 0 es el más brillante y 255 es el más oscuro.
right.green（0-255）: Establece el RGB derecho en verde, 0 es el más brillante y 255 es el más oscuro.
right.blue（0-255）: Establece el RGB derecho en azul, 0 es el más brillante y 255 es el más oscuro.
#### 3.1.5 Código de prueba
Puede cargar el archivo `3.1-RGB LED-1.py` directamente desde el tutorial (lea el archivo "Configuración del entorno de desarrollo" si tiene dudas).
```python
from microbit import *
from keyes_MiniCar import *
minicar = MiniCar()
while True:
minicar.left_red(0)
minicar.right_red(0)
sleep(1000)
minicar.led_off()
minicar.left_green(0)
minicar.right_green(0)
sleep(1000)
minicar.led_off()
minicar.left_blue(0)
minicar.right_blue(0)
sleep(1000)
minicar.led_off()
```
**Resultado de la prueba:** Después de cargar el código, el LED RGB cambiará cada segundo en el orden de rojo, verde y azul.
-------
Importe el archivo `3.1-RGB LED-2.py`
```python
from microbit import *
from keyes_MiniCar import *
minicar = MiniCar()
while True:
for num in range(0 , 255): #It is a loop statement, the range is 0 to 255
num += 1 #It is equal to num = num + 1
minicar.left_red(255 - num)
minicar.right_red(255 - num)
sleep(10)
for num in range(0 , 255):
num += 1
minicar.left_green(255 - num)
minicar.right_green(255 - num)
sleep(10)
for num in range(0 , 255):
num += 1
minicar.left_red(num)
minicar.right_red(num)
sleep(10)
for num in range(0 , 255):
num += 1
minicar.left_blue(255 - num)
minicar.right_blue(255 - num)
sleep(10)
for num in range(0 , 255):
num += 1
minicar.left_red(255 - num)
minicar.right_red(255 - num)
sleep(10)
for num in range(0 , 255):
num += 1
minicar.left_green(num)
minicar.right_green(num)
sleep(10)
for num in range(0 , 255):
num += 1
minicar.left_red(num)
minicar.right_red(num)
sleep(10)
for num in range(0 , 255):
num += 1
minicar.left_blue(num)
minicar.right_blue(num)
sleep(10)
```
**Resultado de la prueba:** Después de cargar el código, el LED RGB será rojo, luego verde, luego aparecerá una mezcla de rojo y verde. Cuando la luz roja se apague, la luz azul se encenderá, luego se mostrará una mezcla de azul y verde.
Sin embargo, cuando la luz verde se apague, la luz roja se encenderá, luego se mostrará una mezcla de azul y rojo. Al final, las luces roja y azul se apagarán.
#### 3.1.6 Conocimiento ampliado
1s = 1000ms; 1ms = 1000us; 1us = 1000nm
Entonces los 1000 ms que usamos en el proyecto son 1 s.
Quizás seas capaz de configurar el color de luz que desees por ti mismo. Solo necesitas configurar el PWM rojo, verde y azul para el RGB.
### 3.2 Conducción del motor
#### 3.2.1 Descripción
El coche robot está equipado con dos motores de corriente continua con engranajes, que se desarrollan a partir de los motores de corriente continua ordinarios. Disfruta de una caja reductora de engranajes a juego, que proporciona una velocidad más baja pero un par mayor. Además, diferentes relaciones de reducción de la caja pueden proporcionar diferentes velocidades y pares.
El motor reductor es la integración de motorreductor y motor, que se aplica ampliamente en la industria del acero y la maquinaria.
Además, el coche cuenta con un chip STC8G1K08 y un chip HR8833MTE. Para ahorrar puertos IO, enviamos instrucciones al chip STC8G1K08 a través del IIC de la micro:bit, luego el chip STC8G1K08 controla el chip HR8833MTE de acuerdo con las instrucciones correspondientes para controlar la dirección de rotación y la velocidad de los dos motores de reducción de CC (el proceso de control es el siguiente).
#### 3.2.2 Preparación
（1）Inserte correctamente la micro:bit en la placa de expansión.
（2）Conecte
```python
minicar.Motor_L(1, 70) #It is a code of advance
minicar.Motor_R(1, 70)
elif LDR_L > 650 and LDR_R <= 650: #Judge if the left brightness＞650，right≤650
minicar.Motor_L(0, 70) #Left turn code
minicar.Motor_R(1, 70)
elif LDR_L <= 650 and LDR_R > 650: #Judge if the left side of the car≤650，right＞650
minicar.Motor_L(1, 70) #The car turns right
minicar.Motor_R(0, 70)
else:
minicar.Motor_stop() #The car stops
```
#### 3.3.7 Resultado de la prueba
Después de cargar el código, encienda el interruptor en la parte trasera del coche, luego puede usar la linterna para jugar con el coche. Es mejor usarlo en un ambiente relativamente oscuro. Cuando la intensidad de la luz ambiental es superior a 650, el coche seguirá moviéndose.
### 3.4 Coche inteligente seguidor de línea
#### 3.4.1 Descripción
El coche viene con dos sensores de seguimiento de línea y dos potenciómetros.
Además, adopta un tubo IR TCRT5000, que contiene un tubo emisor de IR y un tubo receptor de IR. Cuando las señales infrarrojas del tubo emisor son recibidas por el tubo receptor a través de la reflexión, la resistencia del tubo receptor cambiará, lo que generalmente se refleja en el cambio de voltaje en el circuito.
La resistencia varía dependiendo de la intensidad de las señales infrarrojas recibidas por el tubo receptor, que a menudo depende del color de la superficie reflectante y su distancia al tubo receptor. En el momento de la detección, el negro es activo de nivel alto y el blanco es activo de nivel bajo.
**Principio de funcionamiento:** Cuando el coche circula sobre una carretera blanca, el tubo emisor de IR instalado debajo del coche emite señales infrarrojas para detectar la carretera y el tubo receptor recibirá las señales que se devuelven. Luego, el extremo de salida emite un nivel bajo (0). Cuando detecta líneas negras, emite un nivel alto (1).
Envía la señal detectada al puerto I/O del microcontrolador. Cuando es de nivel alto (1), el coche está sobre la línea negra. De manera similar, cuando es de nivel bajo (0), el coche está sobre el suelo blanco.
Los dos sensores de seguimiento de línea en la placa de expansión son controlados por P12 y P13 de la placa de control micro:bit, el izquierdo es controlado por P13 y el derecho por P12. Ajuste los sensores de seguimiento de línea y coloque el coche en un suelo negro, gire los potenciómetros hasta que el LED (D3, D2) se encienda, luego ajústelos hasta que se apague.
#### 3.4.2 Preparación
(1) Inserte el micro:bit correctamente en la placa de expansión.
(2) Conecte el portapilas a la placa de expansión.
(3) Encienda el interruptor de alimentación (Deslice el interruptor POWER a la posición ON).
(4) Conecte el micro:bit y el ordenador mediante un cable micro USB.
(5) Abra el IDE de MU.
Si desea añadir la biblioteca de extensión Mini car (puede consultar el archivo "1.4 Instalar el archivo de la biblioteca").
#### 3.4.3 Diagrama de circuito
#### 3.4.4 Leer el sensor de seguimiento de línea
Puede cargar el código `3.4-Read the Line Tracking Sensor.py` directamente desde el tutorial (lea el archivo "Configuración del entorno de desarrollo" si tiene dudas).
```python
from microbit import *
pin12.set_pull(pin12.PULL_UP)
pin13.set_pull(pin13.PULL_UP)
sensor_L = 0
sensor_R = 0
while True:
sensor_L = pin13.read_digital()
sensor_R = pin12.read_digital()
print("sensor_L:", sensor_L)
print("sensor_R:", sensor_R)
sleep(1000)
```
**Resultado de la prueba:** Descargue el código en la placa micro:bit, no desconecte el cable USB. Haga clic en "REPL" y presione el botón de reinicio, las lecturas detectadas por el sensor de seguimiento de línea se mostrarán en el monitor.
Cuando el sensor de seguimiento de línea detecta un objeto blanco, se mostrará 0 y D2, D3 se encenderán; cuando no se detectan objetos blancos y solo se detecta un objeto negro, se mostrará 1 y D2, D3 se apagarán, como se muestra a continuación.
#### 3.4.5 Diagrama de flujo
#### 3.4.6 Código de prueba
Puede cargar el código `3.4-Patrol car.py` directamente desde el tutorial (lea el archivo "Configuración del entorno de desarrollo" si tiene dudas).
```python
from microbit import *
from keyes_MiniCar import * #Import the library file
minicar = MiniCar() #Instantiate an object MiniCar（）as minicar
pin12.set_pull(pin12.PULL_UP) #Set pin12 to pull up
pin13.set_pull(pin13.PULL_UP)
sensor_L = 0
sensor_R = 0
while True:
sensor_L = pin13.read_digital() #Read the value of the sensor
sensor_R = pin12.read_digital()
print("sensor_L:", sensor_L)
print("sensor_R:", sensor_R)
if sensor_L == 1 and sensor_R == 1: #Judge if sensor_L and sensor_R =1
minicar.Motor_L(1, 70) #Advance code
minicar.Motor_R(1, 70)
elif sensor_L == 0 and sensor_R == 1: #Judge if sensor_L =0 and sensor_R=1
minicar.Motor_L(1, 70) #Right turn code
minicar.Motor_R(0, 70)
elif sensor_L == 1 and sensor_R == 0: #Judge if sensor_L=1 and sensor_R=0
minicar.Motor_L(0, 70)
minicar.Motor_R(1, 70)
else:
minicar.Motor_stop()
```
**Resultado de la prueba:** Cargue el código y abra el interruptor de encendido del coche. Coloque el coche en el papel de seguimiento de línea, luego seguirá la línea negra para moverse.
**Ajuste del potenciómetro:**
Cuando el carro no sigue la línea correctamente, ajuste el potenciómetro de la siguiente manera.
1. Cargue el código del curso.
2. Coloque el coche con la parte delantera mirando hacia usted. Gire el potenciómetro izquierdo completamente en sentido antihorario y el potenciómetro derecho completamente en sentido horario.
3. Coloque el coche en el área blanca de la pista como se muestra en el video. Ajuste lentamente cada potenciómetro hasta que la luz indicadora junto a él se ilumine. Levante el coche con la mano; todas las luces indicadoras deberían apagarse.
### 3.5 Seguimiento ultrasónico y evitación de obstáculos
#### 3.