# Esenciales para CircuitPython
## Esenciales para CircuitPython
Ya has pasado por la [guía de Bienvenido a CircuitPython](../../../../bienvenido-a-circuitpython-2). Ya tienes todo listo y CircuitPython corriendo. Excelente. ¿Y ahora que? ¿Los Escenciales para CircuitPython?
Hay una cantidad disponible de módulos núcleo integrados a CircuitPython y librerías comunes. Esta guía te va a introducir a ellos y te va a enseñar con ejemplos como usar cada una.
Cada sección te va a presentar con un pedazo de código diseñado para trabajar con diferentes tarjetas, y a explicar como usar el código con cada tarjeta. Estos ejemplos están diseñados para cualquier tarjeta hecha para correr CircuitPython, incluyendo las **Circuit Playground Express** , **Trinket M0** , **Gemma M0** , **ItsyBitsy M0 Express** , **ItsyBitsy M4 Express,** **Feather M0 Express, Feather M4 Express, Metro M4 Express,** **Metro M0 Express, Trellis M4 Express, y Grand Central M4 Express**.
Algunos ejemplos requieren componentes externos, como switches o sensores. Vas a encontrar diagramas de cableado donde sea necesario, para mostrarte como conectar los componentes necesarios para trabajar con cada ejemplo.
¡Comencemos a aprender los Esenciales para CircuitPython!
# Esenciales para CircuitPython
## Integrados a CircuitPython
CircuitPython viene 'con de todo' - _muchas_ de las cosas que conoces y amas del clásico Python 3 (algunas veces llamado CPython) ya funcionan.
Hay algunas que todavía no, pero ¡vamos a tratar de seguir actualizando esta lista mientras agregamos funcionalidad!
Info:
# Cosas Integradas que Funcionan
## Control de Flujo
Los usuales `if`, `elif`, `else`, `for`, `while` trabajan como se espera.
## Math
`import math` te va a dar un rango de funciones matemáticas.
`>>> dir(math)`
`[' __name__', 'e', 'pi',
'sqrt', 'pow', 'exp', 'log', 'cos', 'sin', 'tan', 'acos', 'asin',
'atan', 'atan2', 'ceil', 'copysign', 'fabs', 'floor', 'fmod', 'frexp',
'ldexp', 'modf', 'isfinite', 'isinf', 'isnan', 'trunc', 'radians',
'degrees']`
CircuitPython trabaja con valores de punto flotante de 30-bits, así que puedes usar `int` y `float` cuando los necesites.
## Tuplas, Listas, Arreglos y Diccionarios
Puedes organizar datos en `()`, `[]`, y `{}` incluyendo hileras, objetos, flotantes, etc.
## Clases, Objetos y Funciones
Podemos usar objetos y funciones extensivamente en nuestras librerías, así que prueba uno de los muchos ejemplos como los ejemplos de clases en la [libería MCP9808](https://github.com/adafruit/Adafruit_CircuitPython_MCP9808/blob/master/adafruit_mcp9808.py).
## Lambdas
¡Sí! Puedes crear funciones con `lambda` en la forma que conoces:
`>>> g = lambda x: x**2`
`>>> g(8)`
`64`
## Números al Azar
Para obetner números al azar:
`import random`
`random.random()` trae un número de punto flotante entre `0` y `1.0`.
`random.randint(min, max)` te trae un número entero entre `min` y `max`.
# Esenciales para CircuitPython
## Entradas y Salidas Digitales en CircuitPython
Lo primero al interactuar con hardware es poder manipular entradas y salidas digitales. Con CircuitPython, ¡es super sencillo!
Este ejemplo muestra como utilizar tanto la salida como la entrada digital. Puedes utilizar un switch de _entrada_ con una resistencia en pullup (viene integrado en la tarjeta) para controlar una _salida_ digital - el LED integrado.
Realiza una copiar y pegar del código en **code.py** utilizando tu editor preferido, y salva el archivo para ejecutar la demostración.
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/CircuitPython_Digital_In_Out/code.py
Note como hicimos el código un poco menos "Pithónico" de lo necesario. El bloque `if/else` se puede reemplazar con un simple `led.value = not switch.value` pero queremos dejar claro como se evalúan las entradas. El interprete va a leer la entrada digital cuando evalúa `switch.value`.
Para **Gemma M0,** **Trinket M0, Metro M0 Express, Metro M4 Express, ItsyBitsy M0 Express, ItsyBitsy M4 Express** , no se requieren cambios al ejemplo inicial.
Info:
Para **Feather M0 Express and Feather M4 Express** , comente `switch = DigitalInOut(board.D2)` (y/o `switch = DigitalInOut(board.D7)` dependiendo de cambios que hayas realizado), y descomenta `switch = DigitalInOut(board.D5)`.
Para **Circuit Playground Express** , necesitas comentar `switch = DigitalInOut(board.D2)` (y/o `switch = DigitalInOut(board.D5)` dependiendo de cambios que hayas realizado), y descomenta `switch = DigitalInOut(board.D7)`.
Para encontrar el pin o pad sugerido en el código, vea la lista abajo. Para tarjetas que requieren cableado, conecte un switch (también conocido como un switch táctil, botón o botón momentáneo), siguiendo el diagrama para ayuda. Presione o mueva el switch, y la luz roja LED se va a prender y a apagar.
Note que en tarjetas M0/SAMD basadas en CircuitPython, al menos, tienes pulldowns internos con **Pull.DOWN** y si quieres apagar el pull up/pull down sólo asigna **switch.pull = None**.
## ¡Encuentra los pines!
La lista abajo muestra cada tarjeta, explica dónde se encuentran los pines Digitales sugeridos para entrada, y dónde se encuentra el LED D13.
**Circuit Playground Express**
Vamos a utilizar el switch, el cual es pin D7, y está situado entre el conector de batería y el switch de reset de la tarjeta. D13 está etiquetado como D13 y se encuentra a la par del puerto micro USB.
Para utilizar D7, comente la línea actual de uso de Pin, y desconecte la línea etiquetada para la Circuit playground Express, ¡vea detalles arriba!
**Trinket M0**
D2 está conectado al cable azul, etiquetado como "2", y está situado entre "3V" y "1" en la tarjeta. D13 está etiquetado como "13" y está situado a la part del puerto micro USB.
**Gemma M0**
D2 es un pad amigable a clips de lagarto, etiquetado tanto "D2" como "A1", se muestra conectado con el cable azul, y está a la par del puerto micro USB. D13 se sitúa a la par de la etiqueta "GND" en la tarjeta, y arriba del switch "On/Off".
¡Utilice clips de lagarto para conectar tu switch a la Gemma M0!
**Feather M0 Express y Feather M4 Express**
D5 se etiqueta "5" y está conectado al cable azul en la tarjeta. D13 está etiquetado como "#13" y se sitúa a la par del puerto micro USB.
Para usar D5, comente la línea de uso de pin, y descomente la línea marcada para Feather M0 Express. ¡Vea los detalles arriba!
**ItsyBitsy M0 Express y ItsyBitsy M4 Express**
D2 se etiqueta "2", situado entre las etiquetas de "MISO" y "EN", y está conectado al cable azul en la tarjeta. D13 está situado a la par del botón de reset, entre las etiquetas "3" y "4" de la tarjeta.
**Metro M0 Express y Metro M4 Express**
D2 está situado cerca de la esquina superior izquierda, y conectado al cable azul. D13 está etiquetado "L" y está situado a la par del puerto micro USB.
## Lea la Documentación
Para mayor profundidad sobre lo que puede hacer `digitalio`, lea [la página sobre DigitalInOut en Read the Docs](https://circuitpython.readthedocs.io/en/latest/shared-bindings/digitalio/DigitalInOut.html).
# Esenciales para CircuitPython
## Entradas Analógicas en CircuitPython
Este ejemplo muestra como puedes leer el voltaje analógico en el pin A1 de tu tarjeta.
Copia y pega el código hacia **code.py** utilizando tu editor favorito, y salvando para ejecutar el código de demostración.
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/CircuitPython_AnalogIn/code.py
Warning:
## Creando la entrada analógica
`analog1in = AnalogIn(board.A1)`
Crea un objeto, y conecta el objeto hacia A1 como una entrada analógica.
## Utilitario `get_voltage`
`getVoltage(pin)` es nuestro pequeño programa utilitario. Por omisión, sus lecturas analógicas van a tener un rango de 0 (mínimo) a 65535 (máximo). Este utilitario convierte la lectura de 0-65535 de `pin.value` y lo convierte en una lectura de voltaje de 0-3.3V.
## Bucle principal
El bucle principal es sencillo. Imprime (`prints`) el voltaje como valores de punto flotante, llamando `get_voltage` sobre nuestro objeto analógico. Conéctese a la consola serial para observar los resultados.
## Realizando algunos cambios
Por omisión los pines están _flotando_ así que los voltajes van a variar. Mientras estamos conectados a la consola serial, trata de tocar el cable de **A1** hacia el pin **GND** o a el pin **3Vo** para ver el voltaje cambiar.
También puedes agregar un potenciómetro para controlar como cambia el voltaje. Del potenciómetro a la tarjeta, conecta el **pin** **izquierdo** hacia **tierra** (GND), el **pin del medio** hacia **A1** , y el **pin derecho** hacia **3V.** Si estás utilizando el editor de Mu, ¡puedes ver los cambios mientras rotas el potenciómetro, en el plotter como en la imagen que se observa arriba! (Has click en el ícono de Plotter en la parte superior de la ventana para abrir el plotter).
Info:
## Cableándolo
La lista que sigue a continuación muestra los diagramas de cableado que te van a ayudar a encontrar los pines correctos y a conectar el potenciómetro, y ¡provee más información sobre los pines analógicos de tu tarjeta!
**Circuit Playground Express**
A1 está situado a la derecha de la tarjeta. Hay múltiples pads o pines de tierra (GND) y 3V.
Tu tarjeta tiene 7 pines analógicos que pueden ser utilizados para este propósito. Para una lista completa, puedes ver la [página con el pinout](../../../../adafruit-circuit-playground-express/pinouts) en la guía principal.
**Trinket M0**
**¡A1 está etiquetado como 2!** Está situado entre "1~" y "3V" en el mismo lado de la tarjeta que el pequeño LED rojo. Tierra (GND) está situado al lado opuesto de la tarjeta. 3V está situado a la par del 2, del mismo lado de la tarjeta que el botón de reset.
Tienes 5 pines analógicos que puedes utilizar. Para ver la lista completa, puedes ver la [página con el pinout](../../../../adafruit-trinket-m0-circuitpython-arduino/pinouts) en la guía principal.
**Gemma M0**
A1 está situado cerca de la parte superior de la tarjeta, del lado izquierdo del puerto Micro USB. Tierra (GND) está del lado opuesto del puerto USB de A1. 3V está situado del lado izquierdo del conector de batería en la parte inferior de la tarjeta.
Tu tarjeta tiene 3 pines analógicos. Para ver la lista completa, puedes ver la [página con el pinout](../../../../adafruit-gemma-m0/pinouts) en la guía principal.
**Feather M0 Express y Feather M4 Express**
A1 está situado en el borde opuesto al conector de batería. Hay múltiples pines de tierra (GND). 3V está situado en el mismo borde que A1, a la par del botón de reset.
Tu tarjeta tiene 6 pines analógicos que puedes usar. Para ver la lista completa, puedes ver la [página con el pinout](../../../../adafruit-feather-m0-express-designed-for-circuit-python-circuitpython/adafruit2-pinouts) en la guía principal.
**ItsyBitsy M0 Express y ItsyBitsy M4 Express**
A1 está situado en la mitad de la tarjeta, cerca de la "A" de "Adafruit". La tierra está etiquetado como "G" a la par de "BAT", cerca del puerto Micro USB. 3V está situado en el lado opuesto del puerto USB de la tierra, a la par de "RST".
Tienes 6 pines analógicos para utilizar. Para ver la lista completa, puedes ver la [página con el pinout](https://learn.adafruit.com/introducing-itsy-bitsy-m0/pinouts) en la guía principal.
**Metro M0 Express y Metro M4 Express**
A1 está situado del mismo lado de la tarjeta que conector de barril. Hay múltiples pines de tierra disponibles. 3V está etiquetado como "3.3" y está situado al centro de la tarjeta, del mismo lado que el conector de barril y de A1.
Tu tarjeta **Metro M0 Express** tiene 6 pines analógicos que puedes utilizar. Para ver la lista completa, puedes ver la [página con el pinout](../../../../adafruit-metro-m0-express-designed-for-circuitpython/pinouts) en la guía principal.
Tu tarjeta **Metro M4 Express** tiene 6 pines analógicos que puedes utilizar. Para ver la lista completa, puedes ver la [página con el pinout](../../../../adafruit-metro-m4-express-featuring-atsamd51/pinouts) en la guía principal.
# Leyendo Valores de Pines Analógicos
El utilitario `get_voltage()` utilizado en el ejemplo anterior del potenciómetro, lee el valor en crudo y lo convierte a un nivel de voltaje. También puedes leer un pin analógico de forma directa en tu código utilizando `pin.value`. Por ejemplo, para simplemente leer el valor analógico del pin, puedes ejecutar el siguiente código:
```
import time
import board
from analogio import AnalogIn
analog_in = AnalogIn(board.A1)
while True:
print(analog_in.value)
time.sleep(0.1)
```
Esto funciona para cualquier pin o entrada analógica. Utiliza el `.value` para leer el valor en crudo y utilizarlo en tu código.
# Esenciales para CircuitPython
## Salidas Analógicas en CircuitPython
Este ejemplo muestra como puedes configuarar el DAC (salida analógica verdadera) en el pin A0.
Info:
Copia y pega el código hacia **code.py** utilizando tu editor favorito, y salva el archivo.
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/CircuitPython_AnalogOut/code.py
## Creando una salida analógica
`analog_out = AnalogOut(A0)`
Esta línea crea un objeto `analog_out` y conecta el objeto con **A0** , el único pin con DAC disponible tanto en tarjeta M0 como M4. (Las M4 tienen dos, A0 y A1)
## Configurando la salida analógica
El DAC en la SAMD21 es una salida de 10-bits, de 0 a 3.3V. Así que en teoría tenemos una resolución de 0.0032 voltios por bit. Para permitirle a CircuitPython que sea lo suficientemente de propósito general para que pueda ser utilizado con DAC de 8 hasta 16 bits, se lee un valor de 16-bits y luego se divide de forma interna.
Por ejemplo, escribiendo 0 es lo mismo que configurando para una salida de 0 voltios.
Escribirle 5000 es lo mismo que configurar una salida para 5000 / 64 = 78, y 78 / 1024 \* 3.3V es 0.25V de salida.
Escribir 65535 es lo mismo que 1023 por lo que es la parte superior del rango y vas a recibir una salida de 3.3V.
## Bucle Principal
El bucle principal es relativamente sencillo, pasa por el rango completo del DAC, desde 0 a 65535, pero con incrementos de 64 a la vez, así que termina subiendo un bit por cada uno de los 10 bits disponibles en el rango.
CircuitPython no es terriblemente rápido, así que el ciclo más rápido que puedes obtener va a ser de 4 Hz. El DAC no es bueno para usar como salida de audio a como viene.
**Tarjetas Express como la CircuitPlayground Express, la Metro M0 Express, la ItsyBitsy M0 Express, la ItsyBitsy M4 Express, la Metro M4 Express, la Feather M4 Express, o la Feather M0 Express tienen más espacio para código y pueden realizar operaciones de salida de audio vía el DAC. ¡La Gemma M0, la Trinket M0 no lo pueden hacer!**
¡Revisa la [sección de Salida de Audio de esta guía](https://learn.adafruit.com/circuitpython-essentials/circuitpython-audio-out) para ejemplos!
## Encuentra el pin
¡Utilice los diagramas a continuación para encontrar el pin A0, marcado con una flecha magenta!
**Circuit Playground Express**
A0 está situado entre VOUT y A1 cerca del puerto de batería
**Trinket M0**
**¡A0 está etiquetado como "1~" en la Trinket!** A0 está situado entre "0" y "2" cerca del medio de la tarjeta en el mismo lado del LED rojo.
**Gemma M0**
A0 está situado en el medio del lado derecho de la tarjeta, a la par del switch On/Off.
**Feather M0 Express**
A0 está situado entre GND y A1 del lado opuesto de la tarjeta al conector de batería, cerca del botón de Reset.
**Feather M4 Express**
A0 está situado entre GND y A1 en el lado opuesto al conector de batería, cerca del botón de Reset, y agujero del pin está marcado con paréntesis izquierdos y derechos.
**ItsyBitsy M0 Express**
A0 está situado entre VHI y A1, cerca de la "A" en "Adafruit", y el agujero del pin está marcado con paréntesis izquierdos y derechos.
**ItsyBitsy M4 Express**
A0 está situado entre VHI y A1, y el agujero del pin está marcado con paréntesis izquierdos y derechos.
**Metro M0 Express**
A0 está situado entre VHI y A1, del mismo lado en la tarjeta que el conector de barril, como en la mitad de los headers, y el agujero del pin está marcado con paréntesis izquierdos y derechos.
**Metro M4 Express**
A0 está situado entre VHI y A1, del mismo lado en la tarjeta que el conector de barril, como en la mitad de los headers.
**En la Metro M4 Express, hay DOS salida analógicas verdaderas, A0 y A1.**
# Esenciales para CircuitPython
## Salida de Audio con CircuitPython
CircuitPython 3.0 y posteriores, vienen con una versión actualizada de `audioio`, la cual provee capacidades de salida de audio. Puedes tocar tonos generados. También puedes tocar, pausar y quitar la pausa de archivos tipo wave. Puedes tener 3V de pico-a-pico de salida analógica o una salida digital I2S. En esta página te vamos a mostrar como usar salida analógica.
Esto es excelente para todo tipo de proyectos que requieren sonido, ¡como un piano de tonos o cualquier cosa a la que desees agregar efectos de sonido!
Danger:
El primer ejemplo que vamos a mostrarte es como generar un tono y que suene al usar un botón. El segundo ejemplo te va a mostrar como tocar, poner en pausa y quitar la pausa de un archivo tipo wave, utilizando un botón para quitar la pausa. Ambos van a tocar el sonido por medio de un conector de audio. El volumen por omisión de ambos ejemplo va a ser dolorosamente alto para tocar con audífonos. Así que hemos agregado un potenciómetro e incluido código en el ejemplo de generación de tono, para controlar el volumen.
En nuestro código, vamos a utilizar el pin A0 para la salida de audio, dado que es el único pin con DAC disponible en todas las tarjetas Express. Las tarjetas M0 Express tienen la salida de audio en A0. Las tarjetas M4 Express tienen dos pines para salida de audio, A0 y A1, sin embargo solo vamos a utilizar A0 en esta guía.
## Tocar un Tono
Copie y pegue el siguiente código dentro de **code.py ** utilizando tu editor favorito, y salva el archivo.
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/CircuitPython_Audio_Out_Tone/code.py
Primero, creamos un objeto botón y lo asignamos al pin `A1`, y lo configuramos como entrada y con un pull-up. Aunque el switch de botón involucra `digitalio`,estamos utilizando un pin-A por lo que el código va a funcionar para todas las tarjetas.
Ya que el volumen por omisión es muy alto, hemos incluido una variable llamada `tone_volume` en el código de onda sinusoide. Usted puede utilizar el código para controlar el volumen aumentando o reduciendo este número para aumentar o reducir el volumen. También puede controlar el volumen, rotando la perilla del potenciómetro.
Para configurar la frecuencia del tono generado, cambie el número asignado en la variable `frequency` para definir la frecuencia en Hz del tono que deseas generar.
Luego, generamos un período de la onda sinusoide con la función `math.sin`, y se lo asignamos a `sine_wave`.
Luego, creamos el objeto de audio, y lo asignamos al pin `A0`.
Creamos un sample de la onda sinusoide utilizando `RawSample` y dándole el `sine_wave` que creamos.
Dentro de nuestro bucle, revisamos si el botón ha sido presionado. El botón tiene dos estados de `True` y `False`(verdadero y falso). Encontramos el valor del botón en `button.value` el cual por omisión retorna el estado `True` cuando no está presionado. Así que para revisar si ha sido presionado, revisamos si está presente el estado de `False`. Entonces, el chequeo que hacemos para ver `if not button.value` es un equivalente de `not True`, o `False`.
Una vez que el botón es presionado, hacemos `play` (o "tocar") con el sample que hemos creado y hacemos un bucle. El comando `time.sleep(1)` le dice que se cicle por un segundo para tocar el sonido. Cuando el segundo se ha cumplido, nos detenemos con `stop`. Puedes aumentar o reducir la duración del tiempo que se toca el sonido, aumentando o bajando la cantidad de segundos que se le piden que haga pausa a `time.sleep()`. Trata de cambiarlo de `1` a `0.5`. Ahora trata de cambiarlo a `2`. ¡Lo puedes cambiar a tu conveniencia!
¡Eso es todo!
## Tocar un Archivo Wave
Puede utilizar cualquier archivo tipo wave que esté soportado. CircuitPython trabaja con formato WAV **mono o estéreo** , a una **taza de sample de** **22 KHz** (o menor) y **16-bits**. Las tarjetas M0 SOLO trabajan en MONO. ¡La razón sobre mono es que solo hay una salida analógica en estas tarjetas! Las tarjetas M4 soportan estéreo porque tienen dos salidas. Lo de 22 KHz o menor es porque CircuitPython no puede manejar más datos que eso (y además no va a sonar mucho mejor) y la salida del DAC es de 10-bits por lo cual cualquier cosa por arriba de 16-bits simplemente va a tomar mayor espacio sin mejor calidad.
Dado que el archivo WAV debe caber en el sistema de archivos de CircuitPython, debe ser menor a 2MB.
Info:
[Hemos creado una guía detallada de como generar archivos WAV aquí](https://learn.adafruit.com/adafruit-wave-shield-audio-shield-for-arduino/convert-files).
Hemos incluido la que usamos aquí. La puedes descargar y copiar a tu tarjeta.
[StreetChicken.wav](https://cdn-learn.adafruit.com/assets/assets/000/057/463/original/StreetChicken.wav?1531255658)
Vamos a tocar el archivo wave por 6 segundos, ponerlo en pausa, esperar a que un botón sea presionado, y luego quitar la pausa al archivo y dejarlo que toque hasta el final. ¡Luego comienza de nuevo desde el principio! Vamos a mirar.
Copia y pega el siguiente código en **code.py** utilizando tu editor favorito, y salva el archivo.
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/CircuitPython_Audio_Out_Wave/code.py
Primero creamos el objeto botón, y lo asignamos al pin `A1`,y lo configuramos para entrada con un pull-up.
Luego abrimos el archivo, `StreetChicken.wav` como un binario para lectura ( **r** eadable **b** inary) y guardamos el objeto archivo en `wave_file` lo cual es lo que usamos para leer el audio de: `wave_file = open("StreetChicken.wav", "rb")`.
Ahora, le pedimos al sistema de audio que cargue los datos del wave del archivo `wave = audiocore.WaveFile(wave_file)` y finalmente solicitamos que el audio sea tocar por medio del pin de salida analógica A0 `audio = audioio.AudioOut(board.A0)`.
¡El archivo de audio ya está listo, y se puede tocar en cualquier momento con `audio.play(wave)`!
Dentro del ciclo, comenzamos por tocar el archivo.
Luego tenemos el bloque que le dice al código que se espere 6 segundo antes de poner el archivo en pausa. Decidimos utilizar `time.monotonic()` dado que es **non-blocking ** que significa que puedes realizar otras cosas mientras el archivo está siendo tocado, ¡como controlar servos o NeoPixeles! En un momento dado, `time.monotonic()` va a ser igual a la cantidad de segundos desde que prendiste tu tarjeta. (El reiniciado-suave que ocurre con el auto cargado cuando salvas archivos en CircuitPython, or al entrar y salir del REPL, no comienza desde cero). Cuando es llamado, retorna un número con un decimal. Cuando le asignas `time.monotonic()` a la variable, la variable es igual al número de segundos a la cantidad de segundos que tuvo `time.monotonic()` al momento de asignar la variable. Lo puedes llamar una y otra vez y restarle la variable a `time.monotonic()` para saber cuanto tiempo ha transcurrido. Para más detalles, puedes ver [este ejemplo](https://learn.adafruit.com/hacking-ikea-lamps-with-circuit-playground-express/passing-time#time-dot-monotonic-example).
Así que asignamos `t = time.monotonic()` para tener un punto de inicio. Luego decimos`pass`, o "no haga nada", hasta que la diferencia entre `t` y `time.monotonic()` sea mayor a `6` segundos. Dicho de otra forma, continuamos tocando hasta que hayan pasado 6 segundos. Recueda, puedes agregar otro código aquí para hacer otras cosas mientras cosas audio por 6 segundos.
Luego ponemos el audio en pausa (`pause`) e imprimimos (`print`) a la consola serial, `"Waiting for button press to continue!"` (o "¡Esperando a que un botón sea presionado para continuar!")
Ahora, vamos a esperar a que un botón presione de la misma forma que lo hicimos cuando tocamos un tono generado. Estamos diciendo `while button.value`, o mientras el botón retorne `True`, `pass`. Una vez que el botón es presionado, el retorna `False`, y esto le dice al código que continúe.
Una vez que el botón es presionado, quitamos la pausa (`resume`) y seguimos tocando el archivo. Le decimos que termine de tocar el archivo con `while audio.playing: pass`.
Finalmente, imprimimos (`print`) a la consola serial, "Done!" (o "¡Listo!)
Puedes realizar esto con cualquier archivo wave soportado, y puedes agregarle todo tipo de cosas al código de tu proyecto, mientras el archivo está tocando. ¡Pruébalo!
## Cableándolo
Además de tu **placa microncontroladora** , vamos a requerir:
### Breadboard-Friendly 3.5mm Stereo Headphone Jack
[Breadboard-Friendly 3.5mm Stereo Headphone Jack](https://www.adafruit.com/product/1699)
Pipe audio in or out of your project with this very handy breadboard-friendly audio jack. It's a stereo jack with disconnect-switches on Left and Right channels as well as a center ground pin. You can use any 3.5mm stereo cable with this jack. The pins are on 0.1" spacing so it plugs...
Out of Stock
[Buy Now](https://www.adafruit.com/product/1699)
[Related Guides to the Product](https://learn.adafruit.com/products/1699/guides)
### Tactile Switch Buttons (12mm square, 6mm tall) x 10 pack
[Tactile Switch Buttons (12mm square, 6mm tall) x 10 pack](https://www.adafruit.com/product/1119)
Medium-sized clicky momentary switches are standard input "buttons" on electronic projects. These work best in a PCB but [can be used on a solderless breadboard as shown in this tutorial](https://learn.adafruit.com/adafruit-arduino-lesson-6-digital-inputs?view=all). The...
In Stock
[Buy Now](https://www.adafruit.com/product/1119)
[Related Guides to the Product](https://learn.adafruit.com/products/1119/guides)
### Panel Mount 10K potentiometer (Breadboard Friendly)
[Panel Mount 10K potentiometer (Breadboard Friendly)](https://www.adafruit.com/product/562)
This potentiometer is a two-in-one, good in a breadboard or with a panel. It's a fairly standard linear taper 10K ohm potentiometer, with a grippy shaft. It's smooth and easy to turn, but not so loose that it will shift on its own. We like this one because the legs are 0.2" apart...
In Stock
[Buy Now](https://www.adafruit.com/product/562)
[Related Guides to the Product](https://learn.adafruit.com/products/562/guides)
### 100uF 16V Electrolytic Capacitors - Pack of 10
[100uF 16V Electrolytic Capacitors - Pack of 10](https://www.adafruit.com/product/2193)
We like capacitors so much we made a [kids' show about them.](https://www.youtube.com/watch?v=sy_G1oYRQmM) They're super handy and it's really helpful to have a variety lying around to pick and choose from.
In Stock
[Buy Now](https://www.adafruit.com/product/2193)
[Related Guides to the Product](https://learn.adafruit.com/products/2193/guides)
### Full Sized Premium Breadboard - 830 Tie Points
[Full Sized Premium Breadboard - 830 Tie Points](https://www.adafruit.com/product/239)
This is a 'full-size' premium quality breadboard, 830 tie points. Good for small and medium projects. It's 2.2" x 7" (5.5 cm x 17 cm) with a standard double-strip in the middle and two power rails on both sides. You can pull the power rails off easily to make the...
In Stock
[Buy Now](https://www.adafruit.com/product/239)
[Related Guides to the Product](https://learn.adafruit.com/products/239/guides)
### Premium Male/Male Jumper Wires - 20 x 6" (150mm)
[Premium Male/Male Jumper Wires - 20 x 6" (150mm)](https://www.adafruit.com/product/1957)
These Male/Male Jumper Wires are handy for making wire harnesses or jumpering between headers on PCB's. These premium jumper wires are 6" (150mm) long and come in a 'strip' of 20 (2 pieces of each of ten rainbow colors). They have 0.1" male header contacts on either...
In Stock
[Buy Now](https://www.adafruit.com/product/1957)
[Related Guides to the Product](https://learn.adafruit.com/products/1957/guides)
Y para que sea más sencillo el cablearlo con la CircuitPlayground Express:
Cuando los interruptores de botón tienen cuatro pines, realmente son solo dos pines. Cuando se cablea un interruptor de botón con cuatro pines, lo más sencillo es verificar que estás cableando los pines correctos, es **conectando esquinas opuestas del interruptor de botón**. Así no hay chance de que accidentalmente conectes el cable al mismo pin dos veces.
Estos son los pasos que hay que seguir para cablear estos componentes:
- Conecte el **pin de tierra de su tarjeta** a el **riel de tierra en la breadboard** porque vamos a conectar los tres componentes a tierra.
- Conect **un pin del interruptor de botón** al **pin A1 de tu tarjeta** , y el **pin opuesto del interruptor de botón** al **riel de tierra de la breadboard.**
- Conecte los **pines izquiero y derecho de la entrada de audio entre ellos.**
- Conecte el **pin central de la entrada de audio** al **riel de tierra de la breadboard**.
- Conecte el **pin izquierdo** al **lado negativo del capacitor de 100mF**.
- Conecte el **lado positivo del capacitor** al **pin central del** **potenciómetro**.
- Conecte el **lado derecho del potenciómetro** al **pin A0 de tu tarjeta**.
- Conecte el **pin izquierdo del potenciómetro** al **riel de tierra de la breadboard.**
La siguiente lista muestra diagramas de cableado para ayudar a encontrar los pines correctos y el cableado con diferentes componentes. Los cables para tierra son negros. El cable para el interruptor de botón es amarillo. Los cables involucrados con audio de color azul.
El cableado es el mismo para las tarjetas versión M4 que para las versión M0. Siga la imagen para ambas.
¡Utilice un breadboard para que el cableado quede limpio y ordenado!
La **Circuit Playground Express** está cableada eléctricamente igual que el ejemplo arriba para una tarjeta tipo ItsyBitsy/Feather/Metro, pero utilizamos cables con clip de lagarto como cables de conexión en lugar de cables tipo jumper.
# Esenciales para CircuitPython
## PWM con CircuitPython
Tu tarjeta tiene soporte de `pulseio`, lo que significa que puedes controlar la intensidad de un LED por medio de PWM, puedes controlar servo motores, hacer sonar bocinas sencillas, y controlar dispositivos de tipo "pulse train" como DHT22 e infrarojos.
_¡Casi_ todos los pines tienen capacidades de PWM! Por ejemplo, todas las tarjetas con ATSAMD21 tiene un pin **A0** el cual es una salida analógica 'verdadera' y _no_ tiene capacidades de PWM.
## **PWM con Frecuencia Fija**
Este ejemplo va a demostrar como utilizar PWM para cambiar la intensidad del LED rojo de tu tarjeta.
Copia y pega el código dentro de **code.py** utilizando tu editor favorito, y salva el archivo.
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/CircuitPython_PWM/code.py
## Creando una Salida PWM
`led = pulseio.PWMOut(board.D13, frequency=5000, duty_cycle=0)`
Como estamos usando el LED que trae la tarjeta, llamamos al objeto `led`, usamos `pulseio.PWMOut` para crear la salida y pasarle el pin `D13` para que use el LED.
## Ciclo Principal
El ciclo principal utiliza `range()` para recorrer el ciclio. Cuando el rango está en menos de 50, le aumenta el brillo al LED vía PWM, y cuando el rango está por arriba de 50, le baja el brillo por medio de PWM. ¡Así es como transiciona el LED entre brillante y oscuro!
El `time.sleep()` es necesario para permitirle al proceso de PWM que ocurra en cierta cantidad de tiempo. ¡De otra forma sucedería muy rápido para poderlo observar!
## **Salida de PWM con Frecuencia Variable**
La salida con frecuencias fijas está bien para pulsar LEDs o controlar servos. Pero si quieres realizar sonidos con un parlante tipo piezo, debes variar la frecuencia.
El siguiente ejemplo utiliza `pulseio` para realizar una serie de tonos sobre un parlante tipo piezo.
Para utilizar con cualquier de las tarjetas con M0, no se necesita realizar cambios al código.
**Para utilizar con las Metro** **M4 Express, ItsyBitsy M4 Express o la Feather M4 Express, debes comentar ** `piezo = pulseio.PWMOut(board.A2, duty_cycle=0, frequency=440, variable_frequency=True)` **y descomentar** `piezo = pulseio.PWMOut(board.A1, duty_cycle=0, frequency=440, variable_frequency=True)` **. ¡A2 no es un pin con capacidades de PWM en las tarjetas con chips M4!**
Info:
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/CircuitPython_PWM_Piezo/code.py
Si tienes la librería de `simpleio` cargada en tu tarjeta, tenemos un bonito utilitario para realizar un tono en el parlante de tipo piezo con un solo comando.
Para utilizar tarjetas M0, no es necesario realizar cambios al código.
**Para utilizar las Metro M4 Express, ItsyBitsy M4 Express o la Feather M4 Express, debes comentar** `simpleio.tone(board.A2, f, 0.25)` **y descomentar** `simpleio.tone(board.A1, f, 0.25)` **. ¡A2 no es un pin con capadades PWM en las tarjetas con chipsM4!**
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/CircuitPython_PWM_Piezo_simpleio/code.py
Como puedes observar, ¡es mucho más sencillo!
## Cableándolo
Utilice los diagramas a continuación como base para cablear tu parlante de tipo piezo. Conecte una pata del piezo al pin **A2** de las tarjetas M0 o **A1** para las tarjetas con M4, y la otra pata a **tierra**. No importa cual pata se conecte al pin. ¡Son intercambiables!
**Circuit Playground Express**
Utilice clips de lagarto para conectar **A2** y uno de las tierras ( **GND** ) a diferentes patas del parlante tipo piezo.
CPX tiene PWM en los siguientes pines: A1, A2, A3, A6, RX, LIGHT, A8, TEMPERATURE, A9, BUTTON\_B, D5, SLIDE\_SWITCH, D7, D13, REMOTEIN, IR\_RX, REMOTEOUT, IR\_TX, IR\_PROXIMITY, MICROPHONE\_CLOCK, MICROPHONE\_DATA, ACCELEROMETER\_INTERRUPT, ACCELEROMETER\_SDA, ACCELEROMETER\_SCL, SPEAKER\_ENABLE.
NO hay NO PWM en: A0, SPEAKER, A4, SCL, A5, SDA, A7, TX, BUTTON\_A, D4, NEOPIXEL, D8, SCK, MOSI, MISO, FLASH\_CS.
**Trinket M0**
**Nota: ¡A2 en la Trinket está etiquetado como Digital "0"!**
Utilice cables para conectar **GND** y **D0** a diferentes patas del parlante tipo piezo.
Las Trinket tienen PWM disponible en los siguientes pines: D0, A2, SDA, D2, A1, SCL, MISO, D4, A4, TX, MOSI, D3, A3, RX, SCK, D13, APA102\_MOSI, APA102\_SCK.
NO hay PWM en: A0, D1.
**Gemma M0**
Utilice cables para conectar **GND** y **A2** a diferentes patas del parlante tipo piezo.
Las Gemma tienen PWM disponible en los siguientes pines: A1, D2, RX, SCL, A2, D0, TX, SDA, L, D13, APA102\_MOSI, APA102\_SCK.
NO hay PWM en: A0, D1.
**Feather M0 Express**
Utilice cables para conectar **GND** y **A2** a diferentes patas del parlante tipo piezo.
Las Feather M0 Express tienen PWM disponible en los siguientes pines: A2, A3, A4, SCK, MOSI, MISO, D0, RX, D1, TX, SDA, SCL, D5, D6, D9, D10, D11, D12, D13, NEOPIXEL.
NO hay PWM en: A0, A1, A5.
**Feather M4 Express**
Utilice cables para conectar **GND** y **A1** a diferentes patas del parlante tipo piezo.
Para utilizar A1, descomente la línea que configura el pin, y descomente la línea que etiquetada para las tarjetas M4. ¡Vea los detalles arriba!
Las Feather M4 Express tienen PWM disponible en los siguientes pines: A1, A3, SCK, D0, RX, D1, TX, SDA, SCL, D4, D5, D6, D9, D10, D11, D12, D13.
NO hay PWM en: A0, A2, A4, A5, MOSI, MISO.
**ItsyBitsy M0 Express**
Utilice cables para conectar **G** y **A2** a diferentes patas del parlante tipo piezo.
Las ItsyBitsy M0 Express tienen PWM disponible en los siguientes pines: D0, RX, D1, TX, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, L, A2, A3, A4, MOSI, MISO, SCK, SCL, SDA, APA102\_MOSI, APA102\_SCK.
NO hay PWM en: A0, A1, A5.
**ItsyBitsy M4 Express**
Utilice cables para conectar **G** y **A1** a diferentes patas del parlante tipo piezo.
Para utilizar A1, descomente la línea que configura el pin, y descomente la línea que etiquetada para las tarjetas M4. ¡Vea los detalles arriba!
Las ItsyBitsy M4 Express tienen PWM disponible en los siguientes pines: A1, D0, RX, D1, TX, D2, D4, D5, D7, D9, D10, D11, D12, D13, SDA, SCL.
NO hay PWM en: A2, A3, A4, A5, D3, SCK, MOSI, MISO.
**Metro M0 Express**
Utilice cables para conectar **GND** y **A2** a diferentes patas del parlante tipo piezo.
Las Metro M0 Express tienen PWM disponible en los siguientes pines: A2, A3, A4, D0, RX, D1, TX, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, SDA, SCL, NEOPIXEL, SCK, MOSI, MISO.
NO hay PWM en: A0, A1, A5, FLASH\_CS.
**Metro M4 Express**
Utilice cables para conectar **GND** y **A1** a diferentes patas del parlante tipo piezo.
Para utilizar A1, descomente la línea que configura el pin, y descomente la línea que etiquetada para las tarjetas M4. ¡Vea los detalles arriba!
Las Metro M4 Express tienen PWM en: A1, A5, D0, RX, D1, TX, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, SDA, SCK, MOSI, MISO
NO hay PWM en: A0, A2, A3, A4, SCL, AREF, NEOPIXEL, LED\_RX, LED\_TX.
## ¿Donde si tengo PWM?
¿Quiere revisar cuales pines tienen PWM por ud mismo? ¡Hemos escrito este útil script! Intenta configurar PWM en cualquier pin disponible, y te hace saber en cuales funciona y en cuales no. ¡Pruébalo!
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/PWM_Test_Script/code.py
# Esenciales para CircuitPython
## Motores Servo con CircuitPython
Para poder utilizar motores tipo servo, vamos a utilizar `pulseio`. En teoría uno puede realizar llamadas directas a `pulseio` para definir una frecuencia de 50 Hz y con eso definir el ancho de los pulsos. ¡Pero preferimos hacerlo un poco más elegante y sencillo!
Así que en cambio, ¡vamos a utilizar `adafruit_motor` la cual te maneja los motores tipo servo de buena manera! `adafruit_motor` es una librería, ¡así que asegúrate de [obtenerla del compilado de liberías si no lo has hecho](https://github.com/adafruit/Adafruit_CircuitPython_Bundle)! Si necesitas ayuda con la instalación puedes revisar [la página de Librerías de CircuitPython](../../../../welcome-to-circuitpython/circuitpython-libraries).
Los servos vienen en dos tipos:
- Un **servo estándar para hobbies** - el puntero se mueve 180 grados (90 grados en cada dirección desde cero grados).
- Un **servo de rotación continua** - el puntero se mueve una rotación completa como un motor DC. En lugar de indicarse un ángulo, se define una velocidad de movimiento donde 1.0 es toda velocidad hacia adelante, 0.5 la mitad de la velocidad hacia adelante, 0 detenido, -1 es toda velovidad en reversa con sus valores intermedios.
## Cableando los Servos
Warning:
Las conecciones para un servo son igual para cualquiera de los dos tipos.
Conecte el cable de tierra **café** o **negro** hacia la tierra de la tarjeta CircuitPython.
Conecte el cable **rojo** del servo hacia alimentación de 5V, donde un alimentado por USB es suficiente para uno o dos servos. Para más de eso, necesitas baterías externas. ¡No utilice 3.3V para alimentar un servo!
Conecte el cable **amarillo** o **blanco** del servo hacia el pin de control/datos, en este caso **A1** o **A2** , pero puedes usar cualquier pin con capacidades de PWM.
Por ejemplo, para cablear un servo a una **Trinket** , conecte el cable de tira a **GND** y el de poder a **USB** , y el de señal a **0**.
Recuerde, **en las Trinket,** **A2 está etiquetado como "0"**.
Para las **Gemma** , utilice cables de lagarto para conectar el cable de tierra a **GND** , el de alimentación a **VOUT** , y el de señal a **A2**.
Para las **Circuit Playground Express y Circuit Playground Bluefruit** , utilice cables de lagarto para conectar el cable de tierra a **GND** , el de alimentación a **VOUT** y el de señal hacia **A2**.
Para tarjetas como las **Feather M0 Express** , **ItsyBitsy M0 Express** y **Metro M0 Express** , conecte el cable de tierra a **GND** , el de alimentación hacia **USB o 5V** , y el de señal hacia **A2**.
Para las **Metro M4 Express** , **ItsyBitsy M4 Express** y las **Feather M4 Express** , conecte el cable de tierra hacia cualquier **G o** **GND** , el de alimentación hacia **USB or** **5V** , y el cable de señal hacia **A1**.
## Código para Servos Estándar
Con este ejemplo el servo va a mover el puntero conectado al pin **A2** desde 0 grados hasta 180 grados (-90 a 90 grados) y de regreso:
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/CircuitPython_Servo/code.py
## Servo de Rotación Continua
Hay dos diferencias entre los servos de Rotación Continua y los servos Estándar:
1. El objeto `servo` se crea de forma `my_servo = servo.ContinuousServo(pwm)` en lugar de `my_servo = servo.Servo(pwm)`
2. En lugar de usar `myservo.angle`, se usa `my_servo.throttle` con un valor de velocidad de 1.0 (toda velocidad) a 0.0 (detenido) y hasta -1.0 (toda velocidad en reversa). Cualquier número intermedio sería la velocidad parcial hacia adelante (valor positivo) o en reversa (valor negativo). Esto es muy similar al uso típico de un motor DC controlado con la librería de **adafruit\_motor**.
Este ejemplo se mueve con toda velocidad hacia adelante durante dos segundos, se detiene por dos segundos, luego en toda velocidad en reversa por dos segundos, y luego se detiene por 4 segundos.
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/CircuitPython_Continuous_Servo/code.py
¡Muy sencillo!
Ahora asumamos que 0 grados es 0.5ms y 180 es un multo de 2.5ms. Esto es más amplio que el valor _oficial_ de 1ms a 2ms de ancho de pulsos. Si tienes un servo que utilice un rango diferente, puedes inicializar el valor en el objeto `servo` con un diferente mínimo (`min_pulse`) y máximo (`max_pulse`). Por ejemplo:
`servo = adafruit_motor.servo.Servo(pwm, min_pulse = 500, max_pulse = 2500)`
Para información más detallada sobre utilizar servos con CircuitPython, ¡puedes visitar la [sección de CircuitPython en la guía de Servos](../../../../using-servos-with-circuitpython/circuitpython)!
# Esenciales para CircuitPython
## Tacto Capacitivo con CircuitPython
Cada tarjeta CircuitPython designada como M0, tiene capacidades de tacto capacitivo. ¡Esto significa que cada tarjeta tiene al menos un pin que funciona como una entrada cuando lo tocas! La función de toque capacitivo se realiza _completamente_ en hardware, por lo que no hacen falta resistencias externas, capacitores o circuitos integrados. ¡Lo cual está muy bien!
Warning:
Este ejemplo te va a mostrar como utilizar un pin de toque capacitivo de tu tarjeta.
Copia y pega el código dentro de **code.py** utilizando tu editor favorito, y salva el archivo.
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/CircuitPython_CapTouch/code.py
## Creando la Entrada Táctil
Primero, asignamos la variable `touch_pad` hacia un pin. Este ejemplo utiliza **A0** , así que asignamos `touch_pad = board.A0`. Usted puede elegir cualquier pin con capacidades táctiles de la lista a continuación si usted desea utilizar otro pin. Luego creamos un objeto táctil, lo nombramos `touch` y lo conectamos a `touch_pad`.
Para utilizar con la Circuit Playground Express, comente `touch_pad = board.A0` y descomente `touch_pad = board.A1`.
## Ciclo Principal
Ahora, creamos un ciclo que revisa si el pin ha sido tocado. Si es así, imprime (`print`) hacia la consola serial. ¡Conéctese a la consola serial para ver impresos el resultado cuando tocas el pin!
Info:
No se requiere hardware adicional, porque puedes tocar el pin directamente. Sin embargo, es posible que quiera conectarles cables de lagarto o cinta de cobre a objetos metálicos o conductivos. ¡Puedes probar con cubiertos metálicos, frutas y otras comidas, líquidos, papel aluminio y otros materiales que tengas a mano!
Es posible que sea necesario recargar tu código o reiniciar tu tarjeta luego de cambiar un objeto conectado, porque el toque capacitivo se "calibra" basado en lo que observa el arranque. Así que si tienes muy poquitas respuestas o demasiadas, ¡recarga tu código desde la consola serial o expulsa la tarjeta y presiona el botón de reset!
## Encuentre el pin o pines
Es posible que tu tarjeta tenga pines con capacidades táctiles además de A0. Hemos incluído un alista que ayuda a encontrar A0 (o A1 en el caso de la CPX) para este ejemplo, identificado con una flecha magenta. ¡La lista también incluye información sobre otros pines que podrían funcionar en cada tarjeta!
Para utilizar otros pines, simplemente cambie el número en **A0** al pin que desea utilizar. Por ejemplo si desea utilizar **A3** , su código debería inciar con `touch_pad = board.A3`.
Si desea utilizar más de un pin a la vez, su código va a ser similar al a continuación. Si lo necesita, puede modificar este código para incluir los pines que funcionen para tu tarjeta.
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/CircuitPython_CapTouch_2Pins/code.py
Info:
Utilice la lista a continuación para conocer cuales pines puede utilizar con su tarjeta. ¡Luego, trate de agregarlos a su código y diviértase!
**Trinket M0**
Hay tres pines con capacitades táctiles en la Trinket: **A0** , **A3** , y **A4**.
Recuerde, **A0 está etiquetado como "1~" en las Trinket M0!**
**Gemma M0**
Hay tres pines en las Gemma, con forma de pads amigables con clips de lagarto, que funcionan para entrada táctil: **A0** , **A1** y **A2**.
**Feather M0 Express**
Hay seis pines en las Feather con capacidades táctiles: **A0 - A5**.
**ItsyBitsy M0 Express**
Hay seis pines en las ItsyBitsy con capacidades táctiles: **A0 - A5**.
**Metro M0 Express**
Hay seis pines en las Metro con capacidades táctiles: **A0 - A5**.
**Circuit Playground Express**
¡Las Circuit Playground Express tienen siete pines con capacidad táctil! Tienes **A1 - A7** disponibles, con forma de pads amigables a clips de lagarto. Puedes ver la [guía de CPX en la sección de Toque Capacitivo](../../../../adafruit-circuit-playground-express/adafruit2-circuitpython-cap-touch) para más información de como utilizar estos pads para toque!
**Recuerde:** A0 **NO** tiene capacidades táctiles en las CPX.
# Esenciales para CircuitPython
## RGB LED Interno con CircuitPython
Todas las tarjetas tienen un LED RGB integrado. Puedes utilizar a CircuitPython para controlar el color y la intensidad de este LED. Hay dos tipos diferentes de LEDs RGB integrados, los [DotStar](../../../../adafruit-dotstar-leds/overview) y los [NeoPixel](../../../../adafruit-neopixel-uberguide/the-magic-of-neopixels). Esta sección los cubre a ambos y explica cual tarjeta tiene cual tipo de LED.
Este primer ejemplo de muesta como cambiar de color e intensidad en el LED RGB integrado.
Copia y pega el código dentro de **code.py** utilizando tu editor favor y salva el archivos.
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/CircuitPython_Internal_RGB_LED_colors/code.py
## Creando el objeto LED
Primero, creamos el objeto LED y lo conectamos con el pin o pines correctos. En el caso del NeoPixel, solo es necesario un pin, y lo hemos llamado `NEOPIXEL` para facilidad de uso. Sin embargo, para el caso de un DotStar es necesario dos pines, así vamos a usar los pines nombrados como `APA102_MOSI` y `APA102_SCK` para configurarlo. Ya que estamos usando un solo LED integrado, ¡lo siguiente que queremos es decirle que la cantidad de LEDs es `1`!
En las **Trinket M0** , **Gemma M0** , **ItsyBitsy M0 Express** , y las **ItsyBitsy M4 Express** tienen su propio LED **Dotstar** integrado, por lo que **no se requieren cambios** a la versión inicial de este ejemplo.
Para las **Feather M0 Express, Feather M4 Express, Metro M0 Express, Metro M4 Express, y Circuit Playground Express** tienen su propio LED **NeoPixel** integrado, así que debes **comentar** `import adafruit_dotstar` **y** `led = adafruit_dotstar.DotStar(board.APA102_SCK, board.APA102_MOSI, 1)`, y **descomentar** `import neopixel` **y** `led = neopixel.NeoPixel(board.NEOPIXEL, 1)`.
Info:
## Brillo
Para definir el brillo, simplemente utilice el atributo`brightness`. El brillo se define con un número entre `0` y `1`, que representa un porcentaje de 0% a 100%. Así que, `led.brightness = (0.3)` ajusta el brillo del LED a un 30%. El brillo por omisión es `1` o 100%, y ¡en su máximo el LED es demasiado brillante! Lo puedes bajar si así lo deseas.
## Ciclo Principal
Los colores del LED se definen con una combinación de rojo ( **r** ed), verde ( **g** reen), y azul ( **b** lue), en la forma de una tupla ( **R** , **G** , **B** ). Cada miembro de la tupla es un número entre 0 y 255 que determina la cantidad de color presente. ¡Rojo, verde y azul en diferentes combinaciones pueden crear todos los colores del arcoiris! Así que por ejemplo, para prender el LED en rojo, la tupla sería (255, 0, 0), lo cual es el máximo de color para el rojo, y nada de verde o azul. Verde sería (0, 255, 0) y así. Para los colores intermedios, puedes definir una combinación como cían sería (0, 255, 255), con cantidades iguales de verde y azul.
El ciclo principal es muy sencillo. Define el primer LED en **rojo** utilizando `(255, 0, 0)`, luego **verde** usando `(0, 255, 0)`, y finalmente **azul** usando `(0, 0, 255)`. Luego hacemos un llamado a `time.sleep()` para que se quede en cada color un periodo de tiempo. Escogemos `time.sleep(0.5)`, o medio segundo. ¡Sin el `time.sleep()` va a parpadear los colores demasiado rápido y va a ser difícil de ver!
Observe que definimos `led[0]`. Esto quiere decir el primero, en el caso de la mayoría de tarjetas, el único LED. En CircuitPython, los contadores inician en 0. ¡Así que el primero objeto de por ejemplo una lista, va a ser `0`!
Trata cambiando los números en las tuplas, para cambiar tu LED a cualquier color del arcoiris. O, puedes agregar más líneas con diferentes tuplas de color para agregar más colores a la secuencia. Siempre agrega `time.sleep()`, ¡pero trata cambiando la cantidad de tiempo para crear diferentes animaciones de ciclo!
## Haciendo Arcoiris (¿a quién no le gustan?)
Programar efectos de arcoiris involucra un poquito de matemática y una función llamada `wheel`. Para detalles de como funciona wheel, ¡observa [esta explicación!](../../../../hacking-ikea-lamps-with-circuit-playground-express/generate-your-colors#wheel-explained)!
El último ejemplo muestra como agregar la animación de arcoiris al LED RGB integrado.
Copia y pega el código en **code.py** utilizando tu editor favorito y salva el archivo. **Recuerda comentar y descomentar las líneas apropiadas para tu tarjeta** , según se [explicó arriba](../../../../circuitpython-essentials/circuitpython-internal-rgb-led#create-the-led).
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/CircuitPython_Internal_RGB_LED_rainbow/code.py
Vamos a agregar la función `wheel` luego de setup, pero antes de nuestro ciclo principal.
Y justo antes de nuestro ciclo principal, asignamos a la variable `i = 0`, así que está listo para usarse dentro del ciclo.
El ciclo principal contiene algo de matemática que cicla `i` de `0` a `255` y de vuelta de nuevo de forma repetida. ¡Usamos esto para ciclar `wheel()` alrededor del arcoiris!
El `time.sleep()` determina la velocidad con la que el arcoiris cambia. ¡Trata un número mayor para un arcoiris más lento, y un número menor para uno más rápido!
## Arcoiris en la Circuit Playground Express
Note que aquí usamos `led.fill` en lugar de `led[0]`. Esto significa que prendemos todo los LEDs, que en nuestro código actual es solo uno. ¿Para que preocuparnos con `fill`? Bueno, es posible que tengas una Circuit Playground Express, la cual tiene DIEZ LEDs NeoPixel integrados. Los ejemplos hasta el momento solo han prendido el primero. Si deseas realizar un arcoiris con todos los diez LEDs, cambie el `1` en:
`led = neopixel.NeoPixel(board.NEOPIXEL, 1)`
por `10` para que lea:
` led = neopixel.NeoPixel(board.NEOPIXEL, 10)`.
Esto le dice al código que busque 10 LEDs, en lugar de solo 1. Ahora salve el código y ¡observe como se mueve el arcoiris! Puede cambiar el mismo `1` por `10` en los ejemplos anteriores, y ¡utilizar `led.fill` para prender los LEDs con los colores que escoja! Para más detalles, revise la [sección de NeoPixel en la guía de CPX](../../../../adafruit-circuit-playground-express/circuitpython-neopixel)!
# Esenciales para CircuitPython
## NeoPixeles en CircuitPython
Los NeoPixeles son una forma revolucionaria y muy popular para agregarle luces y color a tu proyecto. Estas tiras de luces RGB tienen controladoras dentro de cada LED, así que solo le envías los datos RGB y los LEDs realizan todo el trabajo por ti. ¡Son la combinación perfecta para CircuitPython!
Puedes controlar 300 LEDs tipo NeoPixel con control de brillo (se le define `brightness=1.0` a la hora de crear el objeto) y 1000 LEDs sin control de brillo. Esto porque el ajustar el brillo requiere que se regenere dinamicamente los datos a enviar, con cada escritura.
¡Vas a necesitar la librería **neopixel.mpy** si no las tienes ahorita en tu carperta /lib! La puedes obtener del [Compilado de Librerías para CircuitPython](https://github.com/adafruit/Adafruit_CircuitPython_Bundle/releases/latest). Si necesitas ayuda instalando la librería, puedes revisar la [página de Librerías para CircuitPython](../../../../welcome-to-circuitpython/circuitpython-libraries).
## Cableándolo
Primero, vas a necesitar soldar tus NeoPixeles. Verifica que tu conexión sea hacia el lado de **DATA INPUT** o **DIN**. ¡Conectarse a DATA OUT o a DOUT es un error común! Estas conexiones están etiquetadas y algunas tienen flechas para resaltar hacia donde deben fluir los datos.
Para alimentar los pixeles desde la tarjeta, el regulador de salida de 3.3V puede manejar picos de alrededor de 500mA, lo cual es suficiente para 50 pixeles de uso 'promedio'. Si quieres luces realmente brillantes y muchos pixeles, recomendamos alimentar directamente de una fuente externa.
- En las Gemma M0 y las CircuitPlayground Express es con el pad de Vout - el pad tiene conexión directa de USB o de la batería, dependiendo de cual sea el voltaje mayor.
- En las Trinket M0, Feather M0 Express, Feather M4 Express, ItsyBitsy M0 Express y ItsyBitsy M4 Express los pines de **USB** o **BAT** te van a dar alimentación directa del puerto USB o de la batería.
- En las Metro M0 Express y las Metro M4 Express, utilice el pin de **5V** sin importar si estás conectado por USB o por el conector de barril para DC.
Si la alimentación a los NeoPixeles es mayor a 5.5V vas a tener dificultar con algunas tiras, en cuyo caso puede que sea necesario que bajes el voltaje a 4.5V-5V o utilizar un level shifter.
Warning:
Info:
## El Código
Este ejemplo incluye múltiples efectos visuales. Copie y pegue el código en **code.py** utilizando tu editor favorito, y salve el archivo.
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/CircuitPython_NeoPixel/code.py
## Creando el LED
Lo primero que tenemos que hacer es instanciar al objeto LED. El objeto para NeoPixel tiene dos parámetros que son requeridos y dos más que son opcionales. Vas a tener que indicarle cual es el pin que estás utilizando para controlar tus NeoPixeles y también decirle el número de pixeles que vas a utilizar en la tira. De forma opcional puedes definirle `brightness` y `auto_write`.
**Los NeoPixeles se pueden manejar con cualquier pin.** Hemos escogido **A1**. Para configurar el pin, asigne la variable `pixel_pin` hacia el pin que desea utilizar, en nuestro caso `board.A1`.
Para definir la cantidad de pixeles en la tira, asigne a la variable `num_pixels` el número de pixeles que desea utilizar, en nuestro ejemplo una tira de`8`.
Hemos escogido definir el brillo en un 30% con `brightness=0.3`.
Para omisión, `auto_write=True`, que quiere decir que cualquier cambio que realices a los pixeles, se envía de forma automática. Como `True` es el valor por omisión, si quieres que sea de esta forma, no debes agregarle nada a tu objeto LED. Hemos escogido el definir `auto_write=False`. Si usted define `auto_write=False`, debe incluir `pixels.show()` cada vez que deseas enviar datos a tus pixeles. Esto hace que el código sea más complicado, ¡pero puede hacer que las animaciones sean más rápidas!
## Utilitarios para NeoPixeles
Hemos incluído algunas funciones utilitarias para crear efectos visuales muy divertidos, que puedes encontrar en este código. El primero es `wheel()` de la cual acabamos de aprender en [LED RGB Integrado](../../../../circuitpython-essentials/circuitpython-internal-rgb-led). Luego tenemos `color_chase()` (persecución de color) la cual pide que le digas un `color` y la cantidad de segundos que deseas entre cada paso de la persecución. Luego tenemos a `rainbow_cycle()`(ciclo de arcoiris), la cual pide que le indices el tiempo en segundos que deseas que tome la animación. Por último, hemos incluído una lista de variables para nuestros colores. Esto hace mucho más sencillo reutilizar colores en cualquier lado del código, así como agregar más colores para usar en múltiples lugares. El asignar colores RGB ha sido explicado en [esta sección sobre el LED RGB Integrado en CircuitPython](../../../../circuitpython-essentials/circuitpython-internal-rgb-led#main-loop).
## Ciclo Principal
Gracias a nuestros utilitarios, el ciclo principal es muy sencillo. Hemos incluido el código para configurar todos los NeoPixeles que estamos usando a rojo, verde y azul por un segundo cada uno. Luego llamamos a `color_chase()`, una vez para cada `color` de nuestra lista, con una pausa de `0.1` segundos antes de cambiar el LED en la persecución. Por último llamamos a `rainbow_cycle(0)`, lo que quiere decir que la animación es tan rápida como sea posible. ¡Aumente ambos números para bajar la velocidad de cada animación!
Tome nota que si utiliza una tira con más LEDs, va a tomar más tiempo para que las animaciones completen.
Info:
## NeoPixeles RGBW
Los NeoPixeles se pueden conseguir en RGB que quiere decir que contiene tres LEDs, uno rojo, uno verde y uno azul. También se pueden conseguir RGBW, que quiere decir que contiene cuatro LEDS, rojo, verde, azul y blanco. El código para manejar NeoPixeles tipo RGBW es un poco diferente al de RGB.
_Si trata de correr código de RGB con NeoPixeles de tipo RGBW, aproximadamente ¾ de los LEDs van a prender, y van a ser de un color incorrecto aunque se vea que están cambiando._ Esto porque los NeoPixeles requieren que se les envíe un pedazo de información para cada color disponible (rojo, verde, azul y probablemente blanco).
De esta manera, los LEDs RGB requiere tres pedazos de información mientras que los LEDs RGBW requieren CUATRO piezas de información. Así que cuando cree un objeto de LED para trabajar con LEDs de tipo RGBW, les vas a agregar `bpp=4`, lo cual define la cantidad de pedazos de información por bit a cuatro (¡las cuatro piezas de información!).
Luego, debes incluir un número adicional en cada tupla de color que crees. Por ejemplo, rojo va a ser `(255, 0, 0, 0)`. Así es como envías las cuarta pieza de información. ¡Revise el ejemplo a continuación para observar como se ve nuestro código usando LEDs de tipo RGBW!
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/CircuitPython_NeoPixel_RGBW/code.py
## Lea la Documentación
Para un vistazo a mayor profundidad de lo que `neopixel` puede hacer, revise [NeoPixel en "Read the Docs"](https://circuitpython.readthedocs.io/projects/neopixel/en/latest/).
# Esenciales para CircuitPython
## DotStar en CircuitPython
Los DotStars utilizan dos cables, a diferencia de los NeoPixeles que usan un solo cable. Son muy similares, pero se les puede escribir a los DotStars mucho más rápido con SPI por hardware, y tienen ciclos de PWM mucho más rápidos, por lo que son mejores para pintar con luz.
Cualquiera de los pines puede ser usado **pero** si hay dos pines que puedan formar un puerto de SPI por hardware, la librería automáticamente se va a cambiar a SPI por hardware. Si usted utiliza SPI por hadware vas a tener una frecuencia de reloj de 4 MHz (eso significa actualizar una tira de 64 pixeles en por ahí de 500uS - o sea 0.0005 segundos). Si utilizas pines sin capacidad de SPI por hardware, nos baja la velocidad a 3 KHz, ¡mil veces mas lento!
Puedes manejar 300 LEDs DotStar con control de brillo (definiendo `brightness=1.0` al crear el objeto) y 1000 LEDs sin control de brillo. Esto es porque al ajustar el brillo debemos recrear de forma dinámica la información con cada escritura.
¡Vas a necesitar la librería de **adafruit\_dotstar.mpy** si no la tienes todavía en tu carpeta de /lib ! La puedes conseguir del [Compilado de Librerías para CircuitPython](https://github.com/adafruit/Adafruit_CircuitPython_Bundle/releases/latest). Si necesitas ayuda instalando la librería, puedes revisar [la página de Librerías para CircuitPython](../../../../welcome-to-circuitpython/circuitpython-libraries).
## Cableándolo
Primero vas a necesitar soldar tus DotStars. Verifica que tu conexión sea hacia la dirección de **DATA INPUT** o **DI** y **CLOCK INPUT** o **CI**. ¡Realizar la conexión hacia el lado de DATA OUT/DO o CLOCK OUT/CO es un error común! Los conectores están etiquetados y algunas versiones incluyen flechas para indicar la dirección que debe seguir el flujo de datos. Siempre realice una inspección visual, ¡ya que el orden de los conectores puede variar de tira a tira!
Para alimentar los pixeles desde la tarjeta, el regulador de salida de 3.3V puede manejar picos de cerca de 500mA lo cual es como 50 pixeles de uso "promedio". Si deseas luces realmente brillantes o muchos pixeles, le recomendamos alimentar directamente de una fuente externa de alimentación.
- En las Gemma M0 y las CircuitPlayground Express es con el pad de Vout - el pad tiene conexión directa de USB o de la batería, dependiendo de cual sea el voltaje mayor.
- En las Trinket M0, Feather M0 Express, Feather M4 Express, ItsyBitsy M0 Express y ItsyBitsy M4 Express los pines de **USB** o **BAT** te van a dar alimentación directa del puerto USB o de la batería.
- En las Metro M0 Express y las Metro M4 Express, utilice el pin de **5V** sin importar si estás conectado por USB o por el conector de barril para DC.
Si la alimentación a los DotStars es mayor a 5.5V vas a tener dificultar con algunas tiras, en cuyo caso puede que sea necesario que bajes el voltaje a 4.5V-5V o utilizar un level shifter.
Warning:
Info:
## El Código
Este ejemplo incluye múltiples efectos visuales. Copie y pegue el código en **code.py** utilizando tu editor favorito, y salve el archivo.
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/CircuitPython_DotStar/code.py
Info:
## Create the LED
Lo primero que tenemos que hacer es instanciar al objeto LED. El objeto para DotStars tiene dos parámetros que son requeridos y dos más que son opcionales. Vas a tener que indicarle cual es el pin que estás utilizando para enviar datos a tus DotStars y cual para el reloj, así como también decirle el número de pixeles que vas a utilizar en la tira. De forma opcional puedes definirle `brightness` y `auto_write`.
**Los NeoPixeles se pueden manejar con cualquieras dos pines.** Hemos escogido **A1** para reloj y **A2** para datos. Para configurar los pines, incluya el nombre de los pines en la creación del objeto, al inicio, en este caso `board.A1` y `board.A2`.
Para definir la cantidad de pixeles en la tira, asigne a la variable `num_pixels`el número de pixeles que desea utilizar, en nuestro ejemplo una tira de`72` **.**
Hemos escogido definir el brillo en un 10% con `brightness=0.1`.
Para omisión, `auto_write=True`, que quiere decir que cualquier cambio que realices a los pixeles, se envía de forma automática. Como `True` es el valor por omisión, si quieres que sea de esta forma, no debes agregarle nada a tu objeto LED. Hemos escogido el definir `auto_write=False`. Si usted define `auto_write=False`, debe incluir `pixels.show()` cada vez que deseas enviar datos a tus pixeles. Esto hace que el código sea más complicado, ¡pero puede hacer que las animaciones sean más rápidas!
## Utilitarios para DotStar
Hemos incluído algunas funciones utilitarias para crear efectos visuales muy divertidos, que puedes encontrar en este código.
El primero es `wheel()` del cual acabamos de aprender en la [LED RGB Integrado](../../../../circuitpython-essentials/circuitpython-internal-rgb-led). Luego tenemos llenado de color (`color_fill()`) el cual solicita que se le pase un `color` y la cantidad de tiempo que desea que se despliegue. Luego tenemos parte alternado (`slice_alternating()`), parte en arcoiris (`slice_rainbow()`), y ciclo en arcoiris (`rainbow_cycle()`) las cuales solicitan la cantidad de tiempo que deben esperar entre cada paso de la animación.
Por último, hemos incluído una lista de variables para nuestros colores. Esto hace mucho más sencillo reutilizar colores en cualquier lado del código, así como agregar más colores para usar en múltiples lugares. El asignar colores RGB ha sido explicado en [esta sección sobre el LED RGB Integrado en CircuitPython](https://learn.adafruit.com/circuitpython-essentials/circuitpython-internal-rgb-led#main-loop).
Dos de los utilitarios utilizan una bonita característica de la librería de DotStar que permite utilizar matemática para prender los LEDs en patrones repetidos. `slice_alternating()` primero prende los LEDs que son número par, y luego los LEDs que son número impar, y lo repite una y otra vez. `slice_rainbow()` prende cada sexto LED con uno de los seis colores del arcoiris hasta que se llena la tira. Ambos permite usar nuestros útiles nombres de color. Este código para partir solo funciona si la cantidad de LEDs se puede dividir por el tamaño de la partición, en nuestro caso 2 y 6. Los DotStars vienen en tiras de 30, 60, 72 y 144, lo cuales son todos divisibles tanto por 2 como por 6. Si necesitas cortar las tiras para tener una tira resultante de diferente tamaño, el código en este ejemplo te va a ayudar pero podría no funcionar sin modificación. Sin embargo, siempre y cuando le envíes un número de LEDs que sea divisible por el tamaño de partición, el código va a funcionar.
## Ciclo Principal
Nuestro ciclo principal comienza llamando a `color_fill()` una vez por cada `color` en nuestra lista y se espera `0.5` segundos. Usted puede cambiar este número para cambiar que tan rápido se despliega cada color. Luego, llamamos a `slice_alternating(0.1)`, que quiere decir que tiene una pausa de 0.1 segundos entre los cambios de la animación. Luego, llenamos la tira de blanco para tener un fondo limpio para que se despliegue el arcoirirs. Luego llamamos a `slice_rainbow(0.1)`, con una pausa de 0.1 segundos en la animación. Luego llamaos a `rainbow_cycle(0)`, que quiere decir que la va a ejecutar tan rápido como sea posible. ¡Aumente o baje este valor de cualquiera de estos números, para ver como sube o baja la velocidad de las animaciones!
Tome nota que si utiliza una tira con más LEDs, va a tomar más tiempo para que las animaciones completen.
Info:
## ¿Es SPI?
Explicamos al principio de esta sección que los LEDs van a responder más rápido si está utilizando un SPI por hardware. En algunas de las tarjetas, hay pines de SPI por HW (hardware) directamente disponibles en forma de MOSI y SCK. Sin embargo, el hardware por SPI está disponible en muchos más puertos que estos. ¿Pero como saber cuales? ¡Fácil! Hemos escrito un utilitario sencillo.
Escogemos a los pines **A1** y **A2** para nuestro código de ejemplo. Para ver si estos pines con SPI por hardware en la tarjeta que estás utilizando, copia y pega el código dentro de **code.py** utilizando tu editor favorito, y salva el archivo. Luego conéctese a la consola serial para ver el resultado.
Para revisar si otras combinaciones de pines tienen SPI por hardware, cambia los nombres de los pines en la línea que dice: `if is_hardware_SPI(board.A1, board.A2):` por los pines que desea usar. Luego revise el resultado en la consola serial. ¡Muy simple!
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/SPI_Test_Script/code.py
## Lea la Documentación
Para un vistazo a mayor profundidad de lo que `dotstar` puede hacer, revise [DotStar en "Read the Docs"](https://circuitpython.readthedocs.io/projects/dotstar/en/latest/).
# Esenciales para CircuitPython
## UART Serial en CircuitPython
Además de la conexión USB-serial que usamos para el REPL, también existe un UART por _hardware_ que puedes utilizar. ¡Esto es útil para hablar con dispositivos como GPSs, algunos sensores y otras microcontrladoras!
Este ejemplo para iniciar muestra como puede crear un dispositivo UART para comunicarse por hardware con dispositivos seriales.
Para utilizar este ejemplo, necesita algo que pueda generar datos UART. ¡Nosotros hemos usado un GPS! Note que el GPS va a enviar datos UARL sin necesidad de tener fija tu ubicación. ¡Ustedes puede probar este ejemplo desde su escritorio! Vas a tener datos para poder leer, simplemente que puede que no incluyan tu ubicación.
¡Vas a necesitar a la librería **adafruit\_bus\_device** copiada a la carpeta /lib si no lo has hecho todavía! La puedes conseguir del [Compilador de Librerías para CircuitPython](https://github.com/adafruit/Adafruit_CircuitPython_Bundle/releases/latest). Si necesita ayuda instalando las librerías, puedes revisar [la página sobre Librerías para CircuitPython](../../../../welcome-to-circuitpython/circuitpython-libraries).
Copie y pegue el código dentro de **code.py** utilizando su editor favorito y salve el archivo.
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/CircuitPython_UART/code.py
## El Código
Primero creamos un objeto UART. Le enviamos los pines que vamos a utilizar, `board.TX` and `board.RX`, y le configuramos `baudrate=9600`. Mientras estos pines están etiquetados en la mayoría de las tarjetas, tenga cuidado que RX y TX no están etiquetados en las Gemma, y están etiquetados por debajo de las Trinket. Vea los diagramas a continuación para ayuda encontrando los pines correctos para su tarjeta.
Una vez que el objeto ha sido creado, usted leer los datos de entrada con`read(numbytes)` donde se le puede especificar el número máximo de bytes a leer. Va a retornar un objeto de arreglo de bytes si ha recibido algo. ¡Note que siempre va a retornar inmediatamente porque hay un buffer interno! Así que lea tantos datos como pueda procesar.
Si no hay datos disponibles, `read()` va a retornar `None`, así que revise esto antes de continuar.
Los datos retornados vienen en un arreglo de bytes, si lo quieres convertir a una cadena, puede utilizar este útil código que ejecuta `chr()` en cada byte:
`datastr = ''.join([chr(b) for b in data]) # convert bytearray to string`
Sus resultados se van a ver algo como esto:
Info:
## Cableándolo
Vas a necesitar un par de cosas para conectar tu GPS a tu tarjeta.
Para las Gemma M0 y las CircuitPlayground Express, usted puede utilizar cables de lagarto para conectarse al Flora Ultimate GPS Module.
Para las Trinket M0, Feather M0 Express, Metro M0 Express y ItsyBitsy M0 Express, vas a necesitar una tabla de prototipado y cables para conectarse al Ultimate GPS Breakout.
Hemos incluido diagramas para mostrarte como conectar el GPS a tu tarjeta. En estos diagramas, el color de los cables son los mismos pines en todas las tarjetas:
- El cable **negro** conecta entre los pines de **tierra** (ground).
- El cable **rojo** conecta los pines de **alimentación** (power) entre el GPS y tu tarjeta.
- El cable **azul** conecta **TX** del GPS al **RX** en tu tarjeta.
- El cable **blanco** conecta **RX** del GPS al **TX** en tu tarjeta.
¡Revise la lista a continuación para un diagrama específico para tu tarjeta!
Warning:
**Circuit Playground Express y Circuit Playground Bluefruit**
- Conecte **3.3v** en su CPX a **3.3v** en su GPS.
- Conecte **GND** en su CPX a **GND** en su GPS.
- Conecte **RX/A6** en su CPX a **TX** en su GPS.
- Conecte **TX/A7** en su CPX a **RX** en su GPS.
**Trinket M0**
- Conecte **USB** de la Trinket hacia **VIN** del GPS.
- Conecte **Gnd** de la Trinket hacia **GND** del GPS.
- Conecte **D3** de la Trinket hacia **TX** del GPS.
- Conecte **D4** de la Trinket hacia **RX** del GPS.
**Gemma M0**
- Conecte **3vo** de la Gemma a **3.3v** del GPS.
- Conecte **GND** de la Gemma a **GND** del GPS.
- Conecte **A1/D2** de la Gemma a **TX** del GPS.
- Conecte **A2/D0** de la Gemma a **RX** del GPS.
**Feather M0 Express y Feather M4 Express**
- Conecte **USB** de la Feather a **VIN** del GPS.
- Conecte **GND** de la Feather a **GND** del GPS.
- Conecte **RX** de la Feather a **TX** del GPS.
- Conecte **TX** de la Feather a **RX** del GPS.
**ItsyBitsy M0 Express y ItsyBitsy M4 Express**
- Conecte **USB** de la ItsyBitsy a **VIN** del GPS
- Conecte **G** de la ItsyBitsy a **GND** del GPS.
- Conecte **RX/0** de la ItsyBitsy a **TX** del GPS.
- Conecte **TX/1** de la ItsyBitsy a **RX** del GPS.
**Metro M0 Express y Metro M4 Express**
- Conecte **5V** de la Metro a **VIN** del GPS.
- Conecte **GND** de la Metro a **GND** del GPS.
- Conecte **RX/D0** de la Metro a **TX** del GPS.
- Conecte **TX/D1** de la Metro a **RX** del GPS.
## ¿Donde está mi UART?
En las SAMD21, tenemos la flexibilidad de poder usar una gama de pines para UART. Compare esto a algunos chips como los ESP8266 con pines _fijos_ para UART. La buenas noticia es que puedes usar muchos pero no _todos_ los pines. Por la gran cantidad de tarjetas con chips SAMD que tenemos, es imposible garantizar cualquier otra cosa que el uso de los etiquetados en 'TX' y 'RX'. Así que si requiere usar otra combinación, o múltiples UARTs, ¿como vas a encontrar esos pines? ¡Sencillo! Hemos escrito una script útil.
Todo lo que necesitas hacer es copiar este archivo a tu tarjeta, renombrarlo como **code.py** , conectar a la consola serial, ¡y ver la salida! El resultado imprime una bonita lista de pares de pines TX y RX que puedes utilizar.
Así es como se ven los resultados en una Trinket M0, tu salida puede variar y puede que sea _muy_ larga. [Para más detalles sobre UARTs y comunicaciones seriales revise nuestra guía detallada, aquí](../../../../using-atsamd21-sercom-to-add-more-spi-i2c-serial-ports)
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/UART_Test_Script/code.py
## Trinket M0: Crear UART antes de I2C
En las Trinket M0 (solamente), si estás utilizando tanto `busio.UART` y `busio.I2C`, debes crear el objeto de UART primero, de esta forma:
```
>>> import board,busio
>>> uart = busio.UART(board.TX, board.RX)
>>> i2c = busio.I2C(board.SCL, board.SDA)
```
Si creas primero `busio.I2C` no funciona:
```
>>> import board,busio
>>> i2c = busio.I2C(board.SCL, board.SDA)
>>> uart = busio.UART(board.TX, board.RX)
Traceback (most recent call last):
File "", line 1, in
ValueError: Invalid pins
```
# Esenciales para CircuitPython
## I2C en CircuitPython
I2C es un protocolo de dos cables para comunicarse con sensores simples y dispositivos, lo que quiere decir que usa dos conexiones para transmitir y recibir datos. Existen muchos dispositivos I2C disponibles y son muy sencillos de utilizar con CircuitPython. Tenemos librerías para muchos dispositivos I2C en nuestro [compilado de librerías](https://github.com/adafruit/Adafruit_CircuitPython_Bundle/releases). (Si no ves tu sensor, sigue revisando cada tanto, ¡escribimos más todo el tiempo!)
En esta sección, vamos a aprender como escanear el bus I2C para buscar dispositivos conectados. Luego vamos a aprender como interactuar con un dispositivo I2C.
Vamos a utilizar el TSL2561, un sensor de luz muy común y de bajo costo. Mientras que el código que ejecutamos es específico para el TSL2561, el proceso general es el mismo para cualquier sensor o dispositivo I2C.
¡Vas a necesitar la librería **adafruit\_tsl2561.mpy** y la librería **adafruit\_bus\_device** en tu carpeta /lib si no los has copiado todavía! Los puedes conseguir del [compilado de Librerías para CircuitPython](https://github.com/adafruit/Adafruit_CircuitPython_Bundle/releases/latest). Si necesita ayuda instalando la librería, revise la [página de Librerías para CircuitPython](../../../../welcome-to-circuitpython/circuitpython-libraries).
Estos ejemplos van a utilizar el sensor de lux TSL2561 versión Flora y versión breakout. Lo primero que quieres hacer es conectar el sensor I2C para que tu tarjeta tenga con quién hablar.
## Cableándolo
Vas a necesitar un par de cosas para conectar el TSL2561 a tu tarjeta.
Para las Gemma M0 y las Circuit Playground Express, puede utilizar cables de lagarto para conectarse a la versión Flora del sensor de lux TSL2561.
Para las Trinket M0, Feather M0 Express, Metro M0 Express y las ItsyBitsy M0 Express, vas a necesitar una tabla de prototipo y cables para conectarse a la versión Breakout del sensor de lux TSL2561.
Hemos incluido diagramas para mostrarte como conectar la TSL2561 a tu tarjeta. En estos diagramas el color de los cables es el mismo para los pines de cualquier tarjeta.
- El cable **negro** conecta entre los pines de **tierra** (ground).
- El cable **negro** conecta entre los pines de alimentación de la TSL2561 y tu tarjeta.
- El cable **amarillo** conecta del **SCL** de tu TSL2561 a **SCL** de tu tarjeta.
- El cable **azul** conecta de **SDA** de tu TSL2561 a **SDA** de tu tarjeta.
¡Revisar la lista a continuación para el diagrama de tu tarjeta!
Warning:
**Circuit Playground Express y Circuit Playground Bluefruit**
- Conecte **3.3v** de la CPX a **3.3v** del TSL2561.
- Conecte **GND** de la CPX a **GND** del TSL2561.
- Conecte **SCL/A4** de la CPX a **SCL** del TSL2561.
- Conecte **SDL/A5** de la CPX a **SDA** del TSL2561.
**Trinket M0**
- Conecte **USB** de la Trinket a **VIN** del TSL2561.
- Conecte **Gnd** de la Trinket a **GND** del TSL2561.
- Conecte **D2** de la Trinket a **SCL** del TSL2561.
- Conecte **D0** de la Trinket a **SDA** del TSL2561.
**Gemma M0**
- Conecte **3vo** de la Gemma a **3V** del TSL2561.
- Conecte **GND** de la Gemma a **GND** del TSL2561.
- Conecte **A1/D2** de la Gemma a **SCL** del TSL2561.
- Conecte **A2/D0** de la Gemma a **SDA** del TSL2561.
**Feather M0 Express and Feather M4 Express**
- Conecte **USB** de la Feather a **VIN** del TSL2561.
- Conecte **GND** de la Feather a **GND** del TSL2561.
- Conecte **SCL** de la Feather a **SCL** del TSL2561.
- Conecte **SDA** de la Feather a **SDA** del TSL2561.
**ItsyBitsy M0 Express y ItsyBitsy M4 Express**
- Conecte **USB** de la ItsyBitsy a **VIN** del TSL2561.
- Conecte **G** de la ItsyBitsy a **GND** del TSL2561.
- Conecte **SCL** de la ItsyBitsy a **SCL** del TSL2561.
- Conecte **SDA** de la ItsyBitsy a **SDA** del TSL2561.
**Metro M0 Express y Metro M4 Express**
- Conecte **5V** de la Metro a **VIN** del TSL2561.
- Conecte **GND** de la Metro a **GND** del TSL2561.
- Conecte **SCL** de la Metro a **SCL** del TSL2561.
- Conecte **SDA** de la Metro a **SDA** del TSL2561.
## Encontrando tu Sensor
Lo primero que quieres hacer luego de cablear tu sensor, es asegurarse que esté conectado correctamente. Vamos a realizar un escaneo del bus I2C para ver si la tarjeta está conectada, y si lo está, imprima su dirección I2C.
Copie y pegue el código hacia **code.py** utilizando su editor favorito, y salve el archivo.
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/CircuitPython_I2C_Scan/code.py
Primero creamos un objeto `i2c` y le enviamos los pines I2C: `board.SCL` y `board.SDA`.
Para poder escanearlo, debemos amarrar a I2C para que la única cosa que lo acceda sea este código. Luego incluimos un ciclo que se espera hasta que I2C esté amarrado y luego continúa a la función de escaneado.
Por último, tenemos un ciclo que ejecuta el escaneo como tal, `i2c_scan()`. Dado que I2C normalmente se refiere a sus direcciones en formato hexadecimal, hemos incluido un poco de código para retornar los resultados en este formado:`[hex(device_address) for device_address in i2c.scan()]`.
¡Abra la consola serial para ver los resultados! El código imprime un arreglo de direcciones. Hemos conectado el TSL2561 el cual tiene una dirección de 7-bits de I2C de 0x39. El resultado para este sensor es `I2C addresses found: ['0x39']`. Si no retornan direcciones, revise los diagramas de cableado para verificar que ha cableado su sensor de forma correcta.
## Datos del Sensor I2C
Ahora tenemos certeza de que nuestro sensor se encuentra conectado y listo para usar. ¡Ahora vamos a aprender como leer los datos del sensor!
Copie y pegue este código dentro de **code.py** utilizando su editor favorito y salve el archivo.
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/CircuitPython_I2C_TSL2591/code.py
Este código comienza de la misma forma que el código de escaneo. Hemos incluido el código de escaneo para que tengas verificación de que tu sensor está conectado correctamente y es detectado. Imprime su dirección una vez. Luego del escaneo, deamarramos el bus I2C con `i2c_unlock()` para que podamos usar el sensor para datos.
Creamos un objeto sensor utilizando la librería del sensor. Lo llamamos `tsl2561` y nos provee el objeto `i2c`.
Luego tenemos un simple ciclo que imprime la lectura de lux usando el objeto de sensor que hemos creado. Agregamos un `time.sleep(1.0)`, para que solo imprima una vez por segundo. Saque la consola serial para ver los resultados. Trate alumbrando una luz al sensor para que vea como cambian los resultados.
## ¿Donde está mi I2C?
En las SAMD21, SAMD51 y nRF52840, tenemos la flexibilidad de poder usar una gama de pines para I2C. En las nRF52840, ¡cualquier pin puede ser usado para I2C! Algunos chips como las ESP8266, requieren uso de bitbangio, pero también puedes usar cualquier pin para I2C. Algunos otros chips tienen sus pines de I2C fijos.
La buena noticia es que puedes usar muchos, pero no _todos_ los pines. Por la gran cantidad de tarjetas SAMD que tenemos, es imposible garantizar con otros pines que no sean los etiquetados como 'SDA' y 'SCL'. Así que si desea otra configuración o múltiples interfaces I2C, ¿como encontramos esos pines? ¡Sencillo! Hemos escrito un script bien útil.
Todo lo que tiene que hacer es copiar este archivo a su tarjeta, renombrarlo como **code.py** , conectarse a la consola serial y ver el resultado. En la salida vemos una bonita lista con los pares de pines de SCL y SDA que puede utilizar.
Esto son los resultados para una ItsyBitsy M0 Express. Tu salida puede variar y puede ser muy larga. Para más detalles sobre I2C y comunicaciones seriales, [revise nuestra guía detallada, aquí](../../../../using-atsamd21-sercom-to-add-more-spi-i2c-serial-ports).
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/I2C_Test_Script/code.py
# Esenciales para CircuitPython
## Teclado y Ratón HID en CircuitPython HID
Warning:
Una de las cosas que hemos integrado a CircuitPython es 'HID' o Dispositivo control para Interfaces Humanas - lo que quiere decir, capacidades de teclado y de mouse. Esto significa que tu tarjeta de CircuitPython puede trabajar como un dispositivo de teclado, presionando teclas y comandos, o como un mouse que mueve su puntero y presiona botones. Esto puede ser muy útil porque incluso si no puedes adaptar tu software para trabajar con hardware, siempre hay una interface de teclado - así que si deseas una interfaz de toque capacitivo para un juego, por ejemplo, ¡el emular un teclado es algo que tienes funcionando en momento!
Esta sección te guía sobre el código necesario para crear un emulador de teclado o mouse. Primero, vamos a recorrer un ejemplo que utiliza pines en tu tarjeta para emular una entrada de teclado. Luego, vamos a mostrarte como cablear un joystick para que funcione como mouse, y analizar el código que hace que esto sea posible.
Vas a necesitar la librería de **adafruit\_hid** en tu carpeta /lib si no las has copiado todavía. Puedes conseguirla en el [compilado de Librerías de CircuitPython](https://github.com/adafruit/Adafruit_CircuitPython_Bundle/releases/latest). Si necesitas ayuda instalando esta librería, revisa la [página de Librerías para CircuitPython](../../../../welcome-to-circuitpython/circuitpython-libraries).
## Emulador de Teclado con CircuitPython
Copia y pega el código hacia **code.py** utilizando tu editor favorito y salva el archivo.
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/CircuitPython_HID_Keyboard/code.py
Conecta el pin **A1** o **A2** hacia tierra, usando un cable de lagarto, y luego lo desconectas para presionar la tecla "A" o para escribir el texto "Hello world!" (o ¡Hola mundo!)
Este ejemplo de cableado muestra A1 y A2 conectados a tierra.
Recuerde, ¡en las Trinket, A1 y A2 están etiquetados como 2 y 0! En otras tarjetas, si vas a tener a A1 y A2 etiquetadas de forma esperada.
## Creando los Objetos y las Variables
Primero, vamos a asignar unas variables para utilizar más tarde. Vamos a crear tres arreglos asignados a variables: `keypress_pins`, `key_pin_array`, y `keys_pressed`. El primero es los pines que vamos a utilizar. El segundo está vacío porque lo vamos a rellenar luego. El tercero lo que queremos que nuestro teclado escriba - en este caso la letra "A" y la frase "Hello World!". Creamos nuestra última variable, asignada a `control_key` el cual permite usar la tecla de "shift" cuando presionamos teclas. Nosotros vamos a utilizar hasta dos teclas de forma simultánea, pero es posible tener hasta seis teclas presionadas a la vez.
Luego creamos los objetos de `keyboard` y `keyboard_layout`. Por ahora solo tenemos US (si usted crea otro diseño de teclado, ¡favor envíe un Pull Request en Github!). Con `time.sleep(1)` nos evitamosun error que puede suceder si el programa comienza a trabajar apenas se conecta la tarjeta, antes de que la computadora pueda inicializar a la tarjeta como un teclado.
Luego tomamos los pines que seleccionamos arriba, y creamos los objetos de pin, definimos la dirección y les damos a cada uno un pull-up. Luego aplicamos los objetos de pin hacia `key_pin_array` para poderlos utilizar más tarde.
Luego, configuramos el LED rojo para poder utilizarlo como una luz de estado.
¡La última cosa que realizamos antes de comenzar el ciclo es imprimir (`print`) el texto "Waiting for key pin..." (o "Esperando a pin de tecla...") para que sepas que tu código está listo y esperando!
## El Ciclo Principal
Dentro del ciclo, vamos a revisar cada pin para verificar que el estado haya cambiado, por ejemplo, si has conectado el pin hacia tierra. Una vez que cambie, imprime "Pin # grounded." para indicar que se ha detectado el estado en tierra. Luego prendemos el LED rojo. El código espera que el estado cambie de nuevo, por ejemplo, que desconectes el pin conectado a tierra.
Luego, el código recibe las teclas que debe presionar correspondientes al pin manipulado. Si conectaste a tierra y luego desconectaste A1, el código recibe para presionar la tecla de `a`, y si conectaste a tierra y luego desconectaste A2 el código recibe para presionar el texto de `"Hello world!"`.
Si el código encuentra que ha recibido una cadena de texto, imprime la cadena usando el `keyboard_layout` para determinar las teclas que debe presionar. De otra forma, el código presiona las teclas de `control_key` y se presioa "a", lo que resulta en "A". Luego hace una llamada a `keyboard.release_all()` (para soltar todas las teclas presionadas). ¡Siempre quieres hacer este llamado tan pronto como presionas teclas o te va a ocasionar una tecla pegada que es realmente molesto!
En lugar de utilizar un cable para conectar los pines hacia tierra, puede tratar de cablear los botones como hicimos en [Entradas y Salidas Digitales con CircuitPython](../../../../circuitpython-essentials/circuitpython-digital-in-out). ¡Trata de modificar el código para agregar más pines para mayor opción de teclas para presionar!
# Emulador de Ratón con CircuitPython
Copie y pegue el código dentro de **code.py** utilizando su editor preferido y salve el archivo.
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/CircuitPython_HID_Mouse/code.py
Para este ejemplo, hemos conectado un joystick de pulgar de 2 ejes con botón de selección. Usamos esto para emular el movimiento de un ratón y para realizar un click izquierdo. Para cablear este joystick:
- Conecte **VCC** en el joystick a **3V** de tu tarjeta. Conecte **tierra** a **tierra** (GND).
- Conecte **Xout** en el joystick al pin **A0** de tu tarjeta.
- Conecte **Yout** en el joystick al pin **A1** de tu tarjeta.
- Conecte **Sel** en el joystick al pin **A2** de tu tarjeta.
Recuerda, en las Trinket los pines están etiquetados de forma diferente. Revisa la [página de pines para las Trinket](../../../../adafruit-trinket-m0-circuitpython-arduino/pinouts#unique-pad-capabilities) para verificar tu cableado.
Para utilizar esta demostración, simplemente mueva el joystick un poco. El puntero del ratón se va a mover lentamente si mueves el joystick un poco fuera del centro y más rápido si lo alejas más del centro. Presiona hacia abajo el joystick para realizar un click del ratón. ¡Asombroso! Ahora vamos a revisar el código.
## Creando los Objetos y las Variables
Primero creamos el objeto mouse o ratón.
Luego, asociamos los ejes con `x_axis` y `y_axis` a los pines `A0` y `A1`. Luego asociamos `select` con `A2`, lo definimos como una entrada y le asignamos un pull-up.
Los ejes "x" y "y" del joystick funcionan como 2 potenciómetros. Los vamos a usar de forma similar a como lo hicimos en [Entradas Analógicas con CircuitPython](../../../../circuitpython-essentials/circuitpython-analog-in). Definimos `pot_min` y `pot_max` para ser los valores mínimos y máximos que leen los potenciómetros. Asignamos `step = (pot_max - pot_min) / 20.0` para usar en la función utilitario.
## Utilitarios para Ratón HID en CircuitPython
Primero debemos obtener el voltaje con el utilitario `get_voltage()` para recibir lecturas correctas de los potenciómetros. ¿Le parece familiar? Aprendimos a utilizarlo en [en Entradas Analógicas](../../../../circuitpython-essentials/circuitpython-analog-in#get-voltage-helper).
Segundo, tenemos `steps(axis)`. Para usarlo, le damos el eje que vas a leer. Aquí es donde vamos a usar la variable `step` que asignamos anteriormente. El rango del potenciómetro es de 0-3.29. Esto es un rango pequeño. Es todavía más pequeño con el joystick porque el joystick está en el centro de su rango, 1.66, y la parte positiva o negativa de cada eje está por abajo o encima de este número. Ya que requerimos de umbrales en nuestro código, vamos a mapear el rango de 0-3.29 a números entre 0-20.0 utilizando esta función utilitario. De esta forma podemos simplificar nuestro código y utilizar rangos más grandes para nuestros umbrales en lugar de tratar de entender cambios decimales muy pequeños.
## Ciclo Principal
Primero asignamos `x` y `y` para leer los voltajes de `x_axis` y `y_axis`.
Luego, revisamos si el estado del botón de select es `False`. Por omisión es `True` cuando no está presionado, así que si el estado es `False`, el botón ha sido presionado. Cuando es presionado, envía el comando para realizar un click izquierdo del puntero. `time.sleep(0.2)` previene que leamos múltiples clicks cuando solo se presionó una vez.
Ahora utilizamos la función de `steps()` para poner el puntero de nuestro ratón en movimiento. Tenemos unas parejas de `if` para cada eje. Recuerde que `10` es la posición central dado que la hemos mapeado a un rango de `0-20`. Las primeras parejas le dicen a cada eje que si el joystick se mueve un paso fuera del centro (a la izquierda o a la derecha para el eje x y arriba o abajo para el eje y), mueva el puntero del ratón en la dirección apropiada por 1 unidad. Las segundas parejas para cada eje le dicen que si el joystick se mueve lo más lejos del centro como es posible, mueva el puntero del mouse en la dirección apropiada 8 unidades. ¡De esta manera tienes la opción de mover el ratón rápido o despacio!
Para ver cual `step` (o paso) está el joystick cuando lo mueves, descomenta las líneas con `print` removiendo el `# ` de las líneas que se vean como `# print(steps(x))`, y conectando la consola serial para que puedas ver la salida. ¡Considera descomentarlas una a la vez, o vas a terminar con mucha información que tienes que navegar en la pantalla y puede que sea difícil de leer!
Info:
# Esenciales para CircuitPython
## Almacenamiento en CircuitPython
Las tarjetas CircuitPython aparecen como una unidad de disco USB, permitiéndote editar el código directamente en la tarjeta. Ya hasta estado haciendo esto por un buen rato. Es posible que te hayas preguntado, "¿Puedo escribir datos _de CircuitPython_ hacia la unidad de disco para que funcione para bitácoras de datos (o un datalogger)?" ¡La respuesta es **sí**!
Sin embargo, tiene algo de truco. Necesitas agregar un código especial a **boot.py** , no solo en **code.py**. Esto es porque hay que definir que el sistema de archivos va a ser de solo lectura cuando necesitas editar el código desde tu computadora, pero lo define para escritura cuando deseas que el núcleo de CircuitPython pueda escribir.
Danger:
A continuación es como se va a ver tu archivo boot.py. Copia y pega el código hacia **boot.py** utilizando tu editor preferido. Es posible que tengas que crearlo como un archivo nuevo.
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/CircuitPython_Logger/boot.py
Para las **Gemma M0,** **Trinket M0, Metro M0 Express, Metro M4 Express, ItsyBitsy M0 Express y ItsyBitsy M4 Express** , no es necesario realizar cambios al código inicial.
Para las **Feather M0 Express y Feather M4 Express** , comente `switch = digitalio.DigitalInOut(board.D2)`, y descomente `switch = digitalio.DigitalInOut(board.D5)`.
Para las **Circuit Playground Express y Circuit Playground Bluefruit** , comente `switch = digitalio.DigitalInOut(board.D2)`, y descomente `switch = digitalio.DigitalInOut(board.D7)`. Recuerde, D7 es el interruptor integrado, así que no se requieren cables extra o clips de lagarto.
Info:
A continuación está el código para tu **code.py**. Copia y pega el código hacia **code.py** utilizando tu editor favorito.
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/CircuitPython_Logger/code.py
## Bitácora de Temperatura
La forma en como trabaja **boot.py** es revisando si el pin que dijiste a la hora de definir el interruptor en tu código, está conectado a tierra. Si lo está, cambia el estado de lectura-escritura del sistema de archivos, de forma que el núcleo de CircuitPython puede comenzar a escribir la temperatura en la tarjeta.
Como ayuda para encontrar los pines correctos, observe los diagramas e información en [la sección de Encuentre los Pines de la guía de Entradas y Salidas Digitales con CircuitPython](../../../../adafruit-trinket-m0-circuitpython-arduino/circuitpython-digital-in-out#find-the-pins). En lugar de conectar un swtich, vas a conectar el in a tierra directamente con un cable de lagarto o con cables.
Warning:
Una vez que haz copiado los archivos a la tarjeta, la expulsas y desconectas de tu computadora. Si está utilizando una Circuit Playground Express, todo lo que tienes que hacer es asegurarte que el interruptor esté del lado derecho. De otra manera, utilizar clips de lagarto o cables para conectar el pin designado hacia tierra. Ahora, conectar la tarjeta de nuevo a tu computadora.
¡Ya no vas a poder editar código en CIRCUITPY!
El LED rojo debería parpadear una vez por segundo, y vas a ver un nuevo archivo llamado **temperature.txt** en la unidad de disco CIRCUITPY.
El archivo se actualiza una vez por segundo, pero no vas a ver los datos escribiéndose en vivo. En cambio, cuando estés listo para obtener los datos, expulsa y desconecta tu tarjeta. Para CPX, mueva el interruptor hacia la izquierda, de otra forma desconecte el cable que has conectado hacia tierra. Ahora va a ser posible escribir al sistema de archivos de nuevo, pero no vas a poder grabar datos.
Tenemos una guía más detallada sobre este proyecto disponible aquí: [Grabadora de Bitácoras de CPU con CircuitPython.](../../../../cpu-temperature-logging-with-circuit-python) Si te gustaría conocer más detalles, ¡revísela!
# Esenciales para CircuitPython
## Temperatura de CPU en CircuitPython
Hay un sensor de temperatura del CPU integrado en todos los chips ATSAMD21, ATSAMD51 y nRF52840. CircuitPython hace que sea muy sencillo leer datos de este sensor. Esto funciona con las microcontroladoras usadas en las tarjetas de Adafruit para CircuitPython.
Los datos se lee utilizando dos comandos sencillo. Vamos a digitarlos en el REPL. Conecte su tarjeta a la [consola serial](../../../../bienvenido-a-circuitpython-2/conectandose-a-la-console-serial), y [entre al REPL](../../../../bienvenido-a-circuitpython-2/el-repl). Luego, ejecute los siguientes comandos en el REPL:
```
import microcontroller
microcontroller.cpu.temperature
```
¡Listo! Has impreso las temperatura en Celsius al REPL. Tome nota que no es exáctamente la temperatura ambiente y no es super preciso. ¡Pero se le acerca!
Si lo deseas imprimir en Fahrenheit, utilice esta fórmula sencilla: Celsius \* (9/5) + 32. Es muy sencillo hacer matemática en CircuitPython. ¡Observa!
Info:
# Esenciales para CircuitPython
## ¿Qué Esperar de CircuitPython?
Danger:
# Siempre Corra la Última Versión de CircuitPython y sus Librerías
Mientras seguimos desarrollando CircuitPython y creando nuevas version, vamos a dejar de darle mantenimiento a versiones anterior. **Necesita** **[actualizarse a la última versión de CircuitPython](https://circuitpython.org/downloads).**
Necesita actualizar el compilado de Librerías para CircuitPython acorde a su versión de CircuitPython. **Favor actualice CircuitPython y luego** **[descargue la última versión del compilado](https://circuitpython.org/libraries)**.
Mientras seguimos sacando nuevas versiones de CircuitPython, vamos a dejar de proveer compilados de librerías que puedes descargar del repositorio de Adafruit CircuitPython Library Bundle. Si debe seguir utilizando una versión anterior, todavía puede descargar la versión apropiada de `mpy-cross` para su versión particula de CircuitPython del repositorio de CircuitPython y crear sus propios archivos de librería de tipo .mpy. **Sin embargo, es mejor actualizar a ambas la última versión de CircuitPython y del compilado de librerías.**
# Debo seguir usando CircuitPython 3.x o 2.x, ¿donde puedo encontrar librerías compatibles?
**Ya no le estamos dando mantenimiento o construyendo compilados de Librerías para CircuitPython 2.x y 3.x. Lo alentamos fuertemente a [actualizar CircuitPython a la última versión](https://circuitpython.org/downloads) y a utilizar una [versión actualizada de las librerías](https://circuitpython.org/libraries).** Sin embargo, si por alguna razón no puede actualizar, puede encontrar la última construcción del [compilado de Librerías para 2.x, aquí](https://github.com/adafruit/Adafruit_CircuitPython_Bundle/releases/download/20190903/adafruit-circuitpython-bundle-2.x-mpy-20190903.zip) y la [última versión del compilado para 3.x, aquí](https://github.com/adafruit/Adafruit_CircuitPython_Bundle/releases/download/20190903/adafruit-circuitpython-bundle-3.x-mpy-20190903.zip).
# Cambiando entre CircuitPython y Arduino
Muchas de las tarjetas que corren CircuitPython, también corren Arduino. ¿Como me puedo cambiar entre las dos? Cambiar entre CircuitPython y Arduino es muy sencillo.
Si está utilizando Arduino y desea comenzar a utilizar CircuitPython, siga los pasos de [Bienvenido a CircuitPython: Instalando CircuitPython](https://learn.adafruit.com/welcome-to-circuitpython/installing-circuitpython).
Si ya está utilizando CircuitPython y desea comenzar a utilizar Arduino, conecte su tarjeta y cargue el sketch de Arduino. Si tiene problemas, puede darle doble click al botón de reset para entrar en modo de bootloader, y luego tratar de subir su sketch. Siempre respalde cualquier archivo que estaba utilizando con CircuitPython, ya que pueden ser borrados.
¡Eso es todo! Es muy sencillo cambiar entre los dos lenguajes.
# La Diferencia entre Tarjetas Express y Tarjetas No-Express
Comúnmente hacemos referencia a tarjetas "Express" y a tarjetas "No-Express" cuando hablamos de CircuitPython. ¿Esto que quiere decir?
Express se refiere a que se ha agregado un chip extra para tener un flash de 2MB que te da mayor espacio para CircuitPython y para tu código. Esto significa que puedes incluir más funcionalidad en CircuitPyhon, y que puedes hacer más con tu código en una tarjeta Express de lo que puedes hacer en una tarjeta No-Express.
Las tarjetas Express incluyen a las Circuit Playground Express, ItsyBitsy M0 Express, Feather M0 Express, Metro M0 Express y las Metro M4 Express.
Las tarjetas No-Express incluyen a las Trinket M0, Gemma M0, Feather M0 Basic, y otras variantes de tarjeta M0 No-Express.
# Tarjetas No-Express: Gemma y Trinket
CircuitPython corre bien en las Gema M0 y las Trinket M0, pero hay algunas limitaciones.
### Poco Espacio en Disco
Como estamos utilizando el flash interno como disco, es compartido con código de ejecución, ¡y es limitado! Solo tenemos como 50KB de espacio.
### Sin Audio o NVM
Parte de tener que dar algo de FLASH para usarlo como disco, quiere decir que no nos cabe todo. O sea, no hay capacidades para usar el audio por hardware o al 'eeprom' NVM. Módulos como `audioio` y `bitbangio` no se incluyen. Para tener estas capacidades, revise las tarjetas CircuitPlayground Express y otras tarjetas Express.
¡Sin embargo, I2C, UART, toque capacitivo, NeoPixeles, DotStar, PWM, entrada y salida analógica, IO digitales, bitácoras a almacenamiento y HID funcionan! Revise los Esenciales de CircuitPython para ejemplos de todos estos.
# Diferencias entre CircuitPython y MicroPython
Para las diferencias entre CircuitPython y MicroPython, revise la [documentación de CircuitPython](https://circuitpython.readthedocs.io/en/latest/README.html#differences-from-micropython).
# Diferencias entre CircuitPython y Python
Python (también conocido como CPython) es el lenguaje en que tanto MicroPython como CircuitPython se basan. Existen muchas similaridades, pero también muchas diferencias. Esta es una lista de algunas de las diferencias.
### Librerías de Python
Python es anunciado que tiene "baterías incluidas", que quiere decir que muchas de las librerías estándar vienen incluidas. Desafortunadamente, por razones de espacio, muchas librerías de Python no están disponibles. Así que por ejemplo, mientras nos gustaría poder ejecutar un `import numpy`, la librería `numpy` no está disponible. ¡Así que puede que te toque portar código!
### Integers en CircuitPython
En las tarjetas no-Express, los números de tipo integer solo pueden tener una longitud de 31 bits. Números de tipo integer de tamaño ilimitado no están soportados. El número positivo más grande que puede ser representado es 230-1, 1073741823, y el número más negativo posible es -230, -1073741824.
Desde CircuitPython 3.0, las tarjetas Express tienen números tipo integer de longitud arbitraria como en Python.
### Números de Punto Flotante y Digitos de Precisión para Float en CircuitPython
Los números de punto flotante son de precisión sencilla en CircuitPython (a diferencia de precisión doble como en Python). El número de punto flotante más grande que se puede representar es de +/-3.4e38. La magnitud más pequeña que puede ser representada con precisión completa es +/-1.7e-38, aunque número tan pequeños como +/-5.6e-45 pueden ser representados con precisión reducida.
Los float de CircuitPython tienen 8 bits para el exponente y 22 bits para mantissa (no 24 como los puntos flotantes de precisión sencilla), que es como cinco seis dígitos decimales de precisión.
### Diferencias entre MicroPython y Python
Para una lista más detallada entre las diferencias entre CircuitPython y Python, puedes revisar la documentación de MicroPython. [Nosotros nos mantenemos actualizados con las versiones estables de MicroPython, así que revise el documento de diferencias en el núcleo, aquí](http://docs.micropython.org/en/latest/pyboard/genrst/index.html)
# Esenciales para CircuitPython
## Controladores y Librerías para CircuitPython
# Esenciales para CircuitPython
## Librerías para CircuitPython
Tenemos una tonelada de liberías para CircuitPython que pueden ser utilizadas por tarjetas con microcontroladoras o por computadoras de una sola tarjeta como las RaspberryPi. Aquí hay una lista rápida que es generada automáticamente.
https://github.com/adafruit/Adafruit_CircuitPython_Bundle/blob/master/circuitpython_library_list.md
# Esenciales para CircuitPython
## Audio MP3 con CircuitPython
Warning:
https://youtu.be/zDq1XEL-eBc?loop=1
El audio comprimido puede ser una bonita alternativa a los archivos WAV que no tienen compresión, especialmente cuando tienes un sistema de archivo pequeño como pasa en muchas de las tarjetas con CircuitPython: ¡los archivos WAV terminan ocupando mucho de tu espacio! Gracias a que han expirado las patentes sobre MP3, ahora podemos incluir decodificación de MP3 como una funcionalidad del núcleo de CircuitPython, y ¡hasta _puedes tocar varios archivos MP3 de forma simultánea_!
CircuitPython tiene capacidad para cualquier tipo de archivo MP3 que desees. Hemos encontrado que archivos tanto **mono como estereo** desde **32kbit/s** hasta **128kbit/s** funcionan, con tazas de muestreo desde **16kHz** hasta **44.1kHz**. La salida de DAC de las SAMD51 M4 es de tan solo 12-bits por lo que no tiene sentido usar tazas de muestreo más altas.
Vamos a tocar un archivo mp3 corto, esperar a que un botón sea presionado, y luego tocar otro segundo archivo mp3. Utilice el mismo cableado que en los [otros ejemplos de audio](https://learn.adafruit.com/circuitpython-essentials/circuitpython-audio-out).
Ya que crear un objeto `MP3Decoder` requiere mucha memoria, lo mejor es hacer esto solo una vez cuando inicia tu programa, y luego actualizar la propiedad `.file` del objeto `MP3Decoder` cuando quieres tocar un archivo diferente. De otra forma, puede que te topes el temido error de `MemoryError`.
Descarga estos dos archivos mp3 y cópialos a tu tarjeta:
[begins.mp3](https://cdn-learn.adafruit.com/assets/assets/000/093/257/original/begins.mp3?1595002296)
[xfiles.mp3](https://cdn-learn.adafruit.com/assets/assets/000/093/258/original/xfiles.mp3?1595002302)
Copia y pega el siguiente código hacia **code.py** utilizando tu editor preferido, y salva el archivo:
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_Essentials/CircuitPython_Audio_Out_MP3/code.py
## Featured Products
### Circuit Playground Express
[Circuit Playground Express](https://www.adafruit.com/product/3333)
**Circuit Playground Express** is the next step towards a perfect introduction to electronics and programming. We've taken the original Circuit Playground Classic and made it even better! Not only did we pack even more sensors in, we also made it even easier to...
In Stock
[Buy Now](https://www.adafruit.com/product/3333)
[Related Guides to the Product](https://learn.adafruit.com/products/3333/guides)
### Adafruit Metro M4 feat. Microchip ATSAMD51
[Adafruit Metro M4 feat. Microchip ATSAMD51](https://www.adafruit.com/product/3382)
Are you ready? Really ready? Cause here comes the fastest, most powerful Metro ever. The **Adafruit Metro M4** featuring the **Microchip ATSAMD51**. This Metro is like a bullet train, with its 120MHz Cortex M4 with floating point support. Your code will zig and zag...
In Stock
[Buy Now](https://www.adafruit.com/product/3382)
[Related Guides to the Product](https://learn.adafruit.com/products/3382/guides)
### Adafruit METRO M0 Express - designed for CircuitPython
[Adafruit METRO M0 Express - designed for CircuitPython](https://www.adafruit.com/product/3505)
Metro is our series of microcontroller boards for use with the Arduino IDE. This new **Metro M0 Express** board looks a whole lot like our [original Metro 328](https://www.adafruit.com/product/2488), but with a huge upgrade. Instead of the ATmega328, this Metro...
In Stock
[Buy Now](https://www.adafruit.com/product/3505)
[Related Guides to the Product](https://learn.adafruit.com/products/3505/guides)
### Adafruit ItsyBitsy M4 Express featuring ATSAMD51
[Adafruit ItsyBitsy M4 Express featuring ATSAMD51](https://www.adafruit.com/product/3800)
What's smaller than a Feather but larger than a Trinket? It's an **Adafruit ItsyBitsy M4 Express** featuring the **Microchip ATSAMD51**! Small, powerful, with a ultra fast ATSAMD51 Cortex M4 processor running at 120 MHz - this microcontroller board is perfect...
Out of Stock
[Buy Now](https://www.adafruit.com/product/3800)
[Related Guides to the Product](https://learn.adafruit.com/products/3800/guides)
### Adafruit ItsyBitsy M0 Express - for CircuitPython & Arduino IDE
[Adafruit ItsyBitsy M0 Express - for CircuitPython & Arduino IDE](https://www.adafruit.com/product/3727)
What's smaller than a Feather but larger than a Trinket? It's an **Adafruit ItsyBitsy M0 Express**! Small, powerful, with a rockin' ATSAMD21 Cortex M0 processor running at 48 MHz - this microcontroller board is perfect when you want something very compact, but still...
In Stock
[Buy Now](https://www.adafruit.com/product/3727)
[Related Guides to the Product](https://learn.adafruit.com/products/3727/guides)
### Adafruit Trinket M0 - for use with CircuitPython & Arduino IDE
[Adafruit Trinket M0 - for use with CircuitPython & Arduino IDE](https://www.adafruit.com/product/3500)
The Adafruit Trinket M0 may be small, but do not be fooled by its size! It's a tiny microcontroller board, built around the Atmel ATSAMD21, a little chip with _a lot_ of power. We wanted to design a microcontroller board that was small enough to fit into any project, and low...
Out of Stock
[Buy Now](https://www.adafruit.com/product/3500)
[Related Guides to the Product](https://learn.adafruit.com/products/3500/guides)
### Adafruit GEMMA M0 - Miniature wearable electronic platform
[Adafruit GEMMA M0 - Miniature wearable electronic platform](https://www.adafruit.com/product/3501)
The **Adafruit Gemma M0** is a super small microcontroller board, with just enough built-in to create many simple projects. It may look small and cute: round, about the size of a quarter, with friendly alligator-clip sew pads. But do not be fooled! The Gemma M0 is incredibly...
In Stock
[Buy Now](https://www.adafruit.com/product/3501)
[Related Guides to the Product](https://learn.adafruit.com/products/3501/guides)
### Adafruit Feather M0 Express
[Adafruit Feather M0 Express](https://www.adafruit.com/product/3403)
At the Feather M0's heart is an ATSAMD21G18 ARM Cortex M0+ processor, clocked at 48 MHz and at 3.3V logic, the same one used in the new [Arduino Zero](https://www.adafruit.com/products/2843). This chip has a whopping 256K of FLASH (8x more than the Atmega328 or 32u4) and...
Out of Stock
[Buy Now](https://www.adafruit.com/product/3403)
[Related Guides to the Product](https://learn.adafruit.com/products/3403/guides)
## Related Guides
- [Adafruit Feather M0 Express](https://learn.adafruit.com/adafruit-feather-m0-express-designed-for-circuit-python-circuitpython.md)
- [Adafruit Metro M0 Express](https://learn.adafruit.com/adafruit-metro-m0-express.md)
- [Adafruit Trinket M0](https://learn.adafruit.com/adafruit-trinket-m0-circuitpython-arduino.md)
- [Adafruit Circuit Playground Express](https://learn.adafruit.com/adafruit-circuit-playground-express.md)
- [Adafruit Metro M4 Express featuring ATSAMD51](https://learn.adafruit.com/adafruit-metro-m4-express-featuring-atsamd51.md)
- [Introducing ItsyBitsy M0 Express](https://learn.adafruit.com/introducing-itsy-bitsy-m0.md)
- [Adafruit Feather M4 Express](https://learn.adafruit.com/adafruit-feather-m4-express-atsamd51.md)
- [Glitter Positioning System](https://learn.adafruit.com/glitter-positioning-system.md)
- [LED Trampoline](https://learn.adafruit.com/led-trampoline.md)
- [Adafruit Ultimate GPS with gpsd](https://learn.adafruit.com/adafruit-ultimate-gps-on-the-raspberry-pi.md)
- [CircuitPython with Jupyter Notebooks](https://learn.adafruit.com/circuitpython-with-jupyter-notebooks.md)
- [Edit CircuitPython Code on iOS with Runestone](https://learn.adafruit.com/editing-circuitpython-on-ios-with-runestone.md)
- [CircuitPython displayio Setup for TFT FeatherWings](https://learn.adafruit.com/using-circuitpython-displayio-with-a-tft-featherwing.md)
- [Playa Festival Bike](https://learn.adafruit.com/playa-festival-bike.md)
- [Which CircuitPython Board is Right for You?](https://learn.adafruit.com/choose-your-circuitpython-board.md)
- [Welcome to CircuitPython!](https://learn.adafruit.com/welcome-to-circuitpython.md)
- [Stand-alone programming AVRs using CircuitPython](https://learn.adafruit.com/stand-alone-programming-avrs-using-circuitpython.md)
- [MakeCode Course for Circuit Playground Express](https://learn.adafruit.com/makecode-circuit-playground-express-course.md)
- [Using MCP23008 & MCP23017 with CircuitPython](https://learn.adafruit.com/using-mcp23008-mcp23017-with-circuitpython.md)
- [CircuitPython Basics: Digital Inputs & Outputs](https://learn.adafruit.com/circuitpython-digital-inputs-and-outputs.md)
- [CircuitPython Sound Box](https://learn.adafruit.com/circuitpython-sound-box.md)
- [CircuitPython Hardware: ILI9341 TFT & FeatherWing](https://learn.adafruit.com/micropython-hardware-ili9341-tft-and-featherwing.md)