La Circuit Playground Express, o CPX, y la Circuit Playground Bluefruit, o CPB, tienen todo tipo de sensores, botones, interruptores y LEDs integrados en ellas. Y lo mejor que es trabajan con CircuitPython. Normalmente, usar CircuitPython con un botón o un sensor requiere configuración en tu código. Esto algunas veces significa una línea de código. Otras veces puede significar varias. ¿No sería bonito saltarse todo eso y comenzar a jugar con la tarjeta? Te ayudamos con esto. Ya sea que seas nuevo programando CircuitPython, o quieres una manera sencilla para incluir la funcionalidad de la Circuit Playground en tu código, la Librería Circuit Playground es exactamente lo que estás buscando.

Hemos diseñado una librería para CircuitPython que hace muy sencillo el iniciar con la Circuit Playground Express y la Bluefruit. Toda la configuración normalmente requerida para mucho de lo que viene incluido en la CPX y CPB se hace de tu parte. Todo lo que necesita hacer es importar esta librería e inmediatamente comenzar a decirle a la tarjeta que hacer. Esta guía te va a acompañar por cada característica disponible en la librería y te da algunos ejemplos de como usarla.

Para el propósito de esta guía, nos vamos a referir tanto a la Circuit Playground Express como a la Circuit Playground Bluefruet como "Circuit Playground", ya que la mayoría del código aquí presentado funciona con ambas tarjetas sin necesidad de cambios. Donde sea necesario, lo vamos a dejar muy claro que una sección en particular solo funciona para una tarjeta específica.

La mayoría de las imágenes son de la Circuit Playground Express porque la mayoría de la características de la Express y la Bluefruit está en el mismo lugar. Las imágenes de ambas se incluyen donde una característica está en un lugar diferente en la Bluefruit.

Hay un par de cosas que deberías saber antes de seguir con esta guía para asegurarnos que tengas todo listo.

¡Vamos a ver!

Antes de Comenzar

Si eres nuevo en programación y a CircuitPython, revisa la guía de Bienvenido a CircuitPython.

Nosotros recomendamos utilizar Mu como tu editor de código, ya que tiene una consola serial integrada, y puedes recibir retroalimentación de tu código desde dentro del editor. Para ayuda sobre como alistar Mu, revisa la página de Instalando el editor Mu. Algunas otras características de esta librería funcionan realmente bien con la función de trazador gráfico disponible en el editor de Mu. Asegúrate de instalar la última versión para asegurarte de tener acceso a esta característica de Mu.

circuitpython_CP_Made_Easy_Mu_Serial_Plotter.png
Serial and Plotter features of Mu!

Conectarse a la consula serial en Mu, es tan simple como darle click al botón Serial, mostrado arriba en magenta. Para activar la función de trazador gráfico, haces click en el botón de Plotter, mostrado arriba en verde.

Si ya tienes un editor preferido, siéntete en libertad de usarlo para esta guía. Muchos de los ejemplos utilizarán la consola serial, así que si optas por no usar Mu, y nunca te has toncectado a la consola serial antes, lea antes Consola Serial Avanzada en Mac y Linux o la Consola Serial Avanzada en Windows si necesitas ayuda para conectarte.

Instalando y Actualizando CircuitPython

Este proceso ha sido cubierto en la Sección de Instalando CircuitPython de la guía Bienvenido a CircuitPython. Incluso si tu tarjeta viene instalada con CircuitPython, puede que no sea la última versión. Siempre vas a querer tener la versión más actualizada de CircuitPython en tu tarjeta - esto te asegura que tener las últimas características y la mejor funcionalidad. Por favor tómate el tiempo de revisar la página Bienvenido a CircuitPython - Instalando CircuitPython (si no lo has hecho todavía) y asegúrate que tengas CircuitPython instalado y actualizado.

Actualizar CircuitPython es especialmente importante para la Circuit Playground Express, porque la Librería Circuit Playground está integrada a CircuitPython para la Express, y esta guía espera que tengas una versión actualizada de la librería.

La Librería Circuit Playground y sus dependencias están integrados en CircuitPython para la Circuit Playground Express. Para utilizar la librería, no se necesita hacer nada más.

Instalando la Librería Circuit Playground en la Circuit Playground Bluefruit

Para utilizar la Librería Circuit Playground con una Circuit Playground Bluefruit, debes instalar la Librería Circuit Playground y sus dependencias.

Antes de que puedas usar la Librería Circuit Playground con una Circuit Playground Bluefruit, debes instalar la librería y los módulos de los que depente. Siga los siguientes pasos encontrados en la sección Instalando Librerías CircuitPython en la Circuit Playground Bluefruit de la guía de la Circuit Playground Bluefruit para obtener todas las librerías necesarias instaladas.

La Librería Circuit Playground requiere las siguientes librerías adicionales:

  • adafruit_bus_device
  • adafruit_lis3dh
  • adafruit_thermister
  • neopixel

Si tratas de correr el código encontrado en esta guía sin seguir estos pasos, el código va a fallar con el siguiente error o uno similar:

Si recibes el error ImportError: no module named 'module_name` ,verifica que tienes instaladas todas las librerías, revisando los pasos en la sección Instalando Librerías para CircuitPython Libraries en la Circuit Playground Bluefruit de nuevo hasta que tu carpeta lib se vea similar a la encontrada en la página.

Creando y Editando Código

Esto se cubre en más detalle en la guía Bienvenido a CircuitPython. Sin embargo, ya que el flujo de trabajo es parte clave para entender esta guía, te vamos a dar una breve explicación aquí.

Tu Circuit Playground aparece en tu tarjeta como una unidad de disco USB llamada CIRCUITPY. Puede que ya hayas visto algunos archivos en la unidad de disco CIRCUITPY. CircuitPython buscar archivos específicos para correr el código que contienen, incluyendo code.py. Vamos a poner cada pedazo de código de esta guía hacia code.py en tu unidad de disco CIRCUITPY. Esto es sencillo de recordar: code.py es donde vive tu código. Mientras progresas por la guía, vas a tener un par de opciones para obtener el código de la guía y correrlo en tu tarjeta.

  1. Puedes descargar el archivo, renombrarlo a code.py y copiar el archivo a tu unidad de disco CIRCUITPY, reemplazando el código actual en code.py si es que existe alguno.
  2. Puedes copiar y pegar el contenido del código de esta guía a tu code.py actual en tu unidad de disco CIRCUITPY uitlizando tu editor. Asegúrate de reemplazar todo el código actual de tu code.py. No lo agregues al final.

Ambas de estas opciones funcionan. Tu decides cual deseas utilizar. Si estás inseguro de cual escoger, ¡prueba con ambas y decide cual flujo de trabajo es mejor para ti!

Utilizando la Librería Circuit Playground

Sin importar de cual tipo de tarjetas estés utilizando, para utilizar la Librería Circuit Playground, simplemente incluya la siguiente línea al inicio de tu code.py:

from adafruit_circuitplayground import cp

¡Eso es todo! Despues de esto, ya puedes comenzar a decirle a tu tarjeta que hacer.

Ahora, vamos a revisar diferentes cosas que puedes hacer con esta librería. ¡Vamos a comenzar!

 

 

La Circuit Playground Express y la Bluefruit tienen un pequeño LED rojo a la par del puerto USB. Está etiquetado como D13. Aunque las imágenes son de una Circuit Playground Express, el LED está en la misma ubicación en la Bluefruit. Lo primero que vamos a hacer es prender ese LED rojo.

Primero, necesitamos agregar el siguiente código a code.py. Recuerda, si necesitas ayuda con esto, revisa 

First, we need to add the following code to code.py. Remember, if you need help with this, check aquí.

"""This example turns on the little red LED."""
from adafruit_circuitplayground import cp

while True:
    cp.red_led = True

¡LED Rojo!

Ahora, vamos a revisar el código.

Primero importamos la librería con from adafruit_circuitplayground import cp.

Luego tenemos un while. while True: básicamente significa: "Por siempre, haga:". while True: crea un ciclo. Cuando hay un ciclo, el código a repasar por siempre el código dentro del ciclo. Todo el código que está identado bajo while True: está "dentro" del cliclo.

Para el LED rojo, los estados de "prendido" y "apagado" los vamos a referenciar como True y False respectivamente. Así que, si quieres prender el LED, lo vas a definir como True. Si lo quieres apagar, lo vas a definir como False. Nosotros queremos prender el LED. Así que lo vamos a definir como  True diciéndole cp.red_led = True.

¡Y eso es todo! ¡Vas a recibir de recompensa que el LED rojo a la par de tu conector USB se prenda! ¿Pero porqué detenernos ahí? Vamos a probar algo un poco más divertido.

¡Blinky!

En cualquier lenguaje de programación, la primera pieza de código que cualquier programador escribe, es un programa llamado "¡Hola Mundo!" que imprime exáctamente eso. La idea es que es una excelente introducción al lenguaje y al entorno de programación. En CircuitPython nuestro ¡Hola mundo! se llama Blinky. En lugar de simplemente escribir código que imprima hola, ¡el código parpadea un LED! Así que, bienvenido al mundo de la programación, vamos a hacer parpadear al LED rojo. ¡Vamos a ver!

Agregue el siguiente código a tu code.py:

"""This is the "Hello, world!" of CircuitPython: Blinky! This example blinks the little red LED on
and off!"""
import time
from adafruit_circuitplayground import cp

while True:
    cp.red_led = True
    time.sleep(0.5)
    cp.red_led = False
    time.sleep(0.5)

¡Parpadea!

En este programa, necesitamos de otra librería: time. Así que, importando time y cp.

La primera línea dentro de nuestro ciclo while True: es la misma que la primera línea de nuestro programa anterior. Estamos prendiendo el LED con cp.red_led = True. Luego tenemos un  time.sleep(0.5).Esto le dice al código que haga una pausa en el estado actual por 0.5 segundos. En otras palabras, estamos prendiendo el LED y esperando por 0.5 segundos. Luego la línea cp.red_led = False, apaga el LED. Y la última línea, time.sleep(0.5), de nuevo le dice al código que espere, esta vez con el LED apagado. Esto se repite para siempre; recuerda, ¡estamos dentro de nuestro ciclo while! Y luego, el LED se prende por 0.5 segundos y se apaga por 0.5 segundos, ¡tenemos un LED que parpadea!

Trate de cambiar los números en las líneas de time.sleep(0.5) para cambiar la velocidad del parpadeo. Puedes lerdear el parpadeo reemplazando ambos 0.5 con un número más grande como 1: time.sleep(1). O puedes acelerarlo reemplazando ambos0.5con un número menor, como 0.1: time.sleep(0.1). ¡O trata de definirles diferentes tiempos de espera para tener un ritmo interesante!

LED Rojo Prendido = Led Rojo Apagado

Hay una forma más corta de hacer lo mismo. Agrega el siguiente código a tu code.py:

"""This is the "Hello, world!" of CircuitPython: Blinky! This example blinks the little red LED on
and off! It's a shorter version of the other Blinky example."""
import time
from adafruit_circuitplayground import cp

while True:
    cp.red_led = not cp.red_led
    time.sleep(0.5)

Este código simplemente le dice a LED que esté brincando entre prendido y apagado, o True y False, cada 0.5 segundos. Puedes cambiar el time.sleep(0.5) a un valor mayor o menor para lerdear o acelerar la velocidad del parpadeo. ¡Eso es todo!

La Circuit Playground Express y la Bluefruit tienen un interruptor deslizante en ellas, encima del conector de batería. Aunque las imágenes son de la Circuit Playground Express, el switch se encuenta en el mismo lugar en la Bluefruit. El interruptor deslizante no controla la alimentación eléctrica de la tarjeta. Es un interruptor que responde Verdadero (True) o Falso (False) dependiendo si está a la izquierda o a la derecha. ¡Así que puedes usarlo como interruptor en tu código! Vamos a ver como.

Agregue el siguiente código a tu code.py. Recuerda que si necesitas ayuda, puedes revisar aquí.

"""This example prints the status of the slide switch. Try moving the switch back and forth to see
what's printed to the serial console!"""
import time
from adafruit_circuitplayground import cp

while True:
    print("Slide switch:", cp.switch)
    time.sleep(0.1)

Abre la consola serial para que se imprima el estado del interruptor. ¡Trata de moverlo de un lugar a otro y ver como cambia su estado!

Vamos a observar el código. Primero importarmos time y cp.

Luego, dentro de nuestro ciclowhile loop, imprimimos (print) el estado del interruptor hacia la consola serial. Esto imprime True si el switch está a la izquierda y False si el interruptor está a la derecha. Nosotros incluimos un time.sleep(0.1) para bajar la velocidad de lo que se imprime. Para ver los resultados, realiza click en el botón Serial de Mu, o conectándote a la consola serial si no estás en Mu. Si el switch está a la izquierda, vas a ver impreso en la consola serialSlide switch: True . Si el interruptor está a la derecha, vas a ver impreso en la consola serialSlide switch: False.

circuitpython_SlideSwitchIsRight.jpg
El interruptor deslizante se encuentra a la derecha. ¡Muévelo a la izquierda!

¿Sencillo, no? ¡Ahora vamos a hacer algo con eso!

Blinky con Interruptor

Acabamos de aprender como prender y apagar el pequeño LED rojo. Ahora vamos a incorporar una entrada para controlarlo. Ya que el switch retorna True o False, lo podemos usar como una entrada.

Agrega el siguiente código a tu code.py.

"""This example uses the slide switch to control the little red LED."""
from adafruit_circuitplayground import cp

# This code is written to be readable versus being Pylint compliant.
# pylint: disable=simplifiable-if-statement

while True:
    if cp.switch:
        cp.red_led = True
    else:
        cp.red_led = False

Luego de importar cp, nuestro ciclo comienza con un if. El if dice, "si este evento sucede, haga lo siguiente". En nuestro código dice, si el interruptor está hacia la izquierda, o True, prenda el LED rojo.

Note que no tenermos que decir if cp.switch == True:. El True es lo que evalua un if.

A esto le sigue un else. Unelse lo que dice es, "De otra forma, haga lo siguiente". Un else típicamente va después de un if. Juntos lo que dicen es, "Si esto sucede, haga esto, pero de lo contrario haga esta otra cosa" En nuestro código dice que si el interruptor está a la derecha, o  False, apague el LED rojo.

Ahora, trate de mover el interruptor de un lado al otro. ¡Su LED rojo debería prenderse y apagarse!

Verdadero es Verdadero

Puede que hayas notado que si el interruptor está a la derecha, es verdadero (True), y cuando el LED está prendido, también es verdadero (True). Podemos usar esto para que nuestro código sea más pequeño. Comenzamos con el bloque de if/else porque es más sencillo de entender que es lo que sucede cuando vemos el código escrito. Sin embargo, el siguiente código es otra forma de hacer lo mismo. Agrega este código a tu code.py.

"""This example uses the slide switch to control the little red LED. When the switch is to the
right it returns False, and when it's to the left, it returns True."""
from adafruit_circuitplayground import cp

while True:
    cp.red_led = cp.switch

Lo que sea que el interruptor nos retorne es lo que le vamos a definir al LED. Así que si el switch retorna True, el LED es True. Si el interruptor retorna False, el LED va a ser False. True es True, False es False. ¡Mueva el interruptor de un lado al otro y todavía vas a estar prendiendo y apagando el LED con este código más corto!

La Circuit Playground Express y la Bluefruit tienen un acelerómetro integrado el cual abre muchas oportunidades para usarlo como entradas. Una de esas entradas es un golpe ligero. Tienes la habilidad de darle un golpe ligero ("tap") para decirle algo a la tarjeta. Tenemos dos opciones, un solo golpe ligero, o doble golpe ligero. Un solo golpe ligero espera por un golpe ligero antes de reaccionar. El doble golpe ligero espera a dos golples ligeros antes de reaccionar. ¡Vamos a ver!

Agregue el siguiente código a su code.py. Si necesita ayuda, recuerde revisar aquí.

"""This example prints to the serial console when the board is double-tapped."""
import time
from adafruit_circuitplayground import cp

# Change to 1 for single-tap detection.
cp.detect_taps = 2

while True:
    if cp.tapped:
        print("Tapped!")
    time.sleep(0.05)

Abra la consola serial para ver cuando la tarjeta recibe un doble golpe ligero. ¡Trate de darle un par de golpes ligeros a la tarjeta para ver que imprime!

Primero importamos a time y acp.

Luego definimos cp.detect_taps = 2.Esto le dice al código que detecte un doble golpe ligero o dos golpes ligeros antes de responder.

Dentro de nuestro ciclo tenemos if cp.tapped:. El código le dijo a cp.tapped que estamos esperando por 2 golpes antes de responder. Así que si la tarjeta recibe dos golples ligeros, la respuesta es imprimir (print) el texto "Tapped!" hacia la consola serial. Para ver esto, abra la consola serial, y dele dos golpes ligeros a su tarjeta. Hemos incluido un time.sleep(0.05) para evitar que por error se detecten varios golpes dobles a la vez.

Tratar cambiando cp.detect_taps a 1. ¡Dale un solo golple ligero a la tarjeta para ver la misma respuesta!

Ahora, ¡vamos a realizar algo con eso! Agregue el siguiente código a su code.py:

"""This example turns on the little red LED and prints to the serial console when you double-tap
the Circuit Playground!"""
import time
from adafruit_circuitplayground import cp

# Change to 1 for detecting a single-tap!
cp.detect_taps = 2

while True:
    if cp.tapped:
        print("Tapped!")
        cp.red_led = True
        time.sleep(0.1)
    else:
        cp.red_led = False

Trata con doble golpe ligero. ¡LED rojo!

Vamos aver el código. Primero importamos a time y acp.

Vamos a mantener cp.detect_taps = 2 para decirle al código que espere por un doble golpe ligero.

Dentro de nuestro ciclo, vamos a revisar si (if) la tarjeta ha recibido un doble golpe ligero. Aún vamos a imprirmir (print) a la consola serial, para que podamos ver cuando hemos realizado un doble golpe ligero con éxito. Pero ahora, le hemos agregado el prender el LED rojo. Ya que el evento de un doble golpe ligero es extremadamente rápido, también hemos incluido un time.sleep(0.1) para que el LED rojo tenga más chance de ser visto por nosotros. Sin eso, sería un flash muy rápido. Y tenemos nuestroelse para apagar el LED rojo cuando no estamos haciendo golpes sobre la tarjeta; de otra forma se prendería y nunca se apagaría.

Sencillo o Doble

No puedes detectar golpes ligeros de tipo sencillos y dobles a la vez; es una limitante del hardware. Puedes incluir detección para golpes ligeros tanto sencillos como dobles en un solo pedazo de código si creas una separación entre ellos de alguna forma. Vamos a ver como. Agrega el siguiente código a tu code.py.

"""This example shows how you can use single-tap and double-tap together with a delay between.
Single-tap the board twice and then double-tap the board twice to complete the program."""
from adafruit_circuitplayground import cp

# Set to check for single-taps.
cp.detect_taps = 1
tap_count = 0

# We're looking for 2 single-taps before moving on.
while tap_count < 2:
    if cp.tapped:
        tap_count += 1
print("Reached 2 single-taps!")

# Now switch to checking for double-taps
tap_count = 0
cp.detect_taps = 2

# We're looking for 2 double-taps before moving on.
while tap_count < 2:
    if cp.tapped:
        tap_count += 1
print("Reached 2 double-taps!")
print("Done.")
while True:
    cp.red_led = True

El código espera por dos golpes ligeros sencillos, y luego dos golpes ligeros dobles, para terminar la sencuencia. Así que si le haces dos veces golpes ligeros sencillos, y luegos dos veces golpes ligeros dobles, ¡vas a ver como el código imprime los mensajes mientras lo haces!

Vamos a observar el código. Primero importamos a cp y luego le definimos que espere por golpes ligeros sencillos con cp.detect_taps = 1.

Luego creamos la variable tap_count y la asignamos un valor de 0 contap_count = 0. Vamos a utilizar esto para llevar la cuenta de cuantas veces hemos hecho golpes ligeros en la tarjeta. Así sabremos cuando avanzar a la siguiente parte del código.

Nuestro ciclo es un poco diferente a ciclos anteriores. Este comienza con while tap_count < 2:. Esto dice, "siga en el bloque de código identado que pertenece al ciclo hasta que tap_count sea mayor que 2." Ya que tap_count ahorita está en 0, vamos a comenzar en el ciclo. El código dentro del ciclo dice, "Si la tarjeta ha recibido un golpe ligero sencillo, aumente tap_count por1."Cada vez que le haces un golpe ligero sencillo a la tarjeta, ella imprime (prints) hacia la consola serial, Single-tap! La primera vez que le haces un golpe ligero sencillo a la tarjeta,  tap_count = 1. La segunda vez, tap_count = 2. 2 no es menor que 2, así que luego del segundo tap, el código deja de trabajar dentro del ciclo, y continuar con la siguiente sección. Lo último que hace antes de continuar es imprimir (print) a la consola serial, Reached 2 single-taps! así que sabemos que hemos llegado al final de esta sección.

Luego, definimos tap_count = 0 de nuevo ya que vamos a detectar un nuevo tipo de golpe ligero. Para esperar golpes ligeros dobles, le decimos cp.detect_taps = 2.

En nuestro siguiente ciclo, es igual que el anterior. Mientras tap_count sea menor que 2, revise a ver si la tarjeta ha recibido el golpe ligero doble, y si es así imprima (print) Double tapped!y aumente tap_count por 1. Una vez que alcance 2, el código continúa. Luego imprimimos (print) a la consola serial Reached 2 double-taps!.

Lo último que hacemos es imprimir Done, y prender el LED rojo para saber que nuestro código terminó.

Este tipo de código es lo que hemos utilizado para crear una caja fuerte de combinación, donde la combinación es una serie de golpes ligeros. ¡Deja fluir la creatividad con esto y trata de buscar nuevas formas de como usarlo!

El acelerómetro de la Circuit Playground Express y la Bluefruit puede detectar otros tipos de acciones además de golpes ligeros. Una de ellas es una acción de agitado. Tienes la capacidad de agitar tu tarjeta en el aire, para decirle algo. ¡Vamos a probar!

Agrega el siguiente código a tu code.py. Recuerda, si necesitas ayuda con esto, revisa aquí.

"""This example prints to the serial console when the Circuit Playground is shaken."""
from adafruit_circuitplayground import cp

while True:
    if cp.shake():
        print("Shake detected!")

Abre la consola serial y dale una buena agitada a la tarjeta. Shake detected!

Vamos a ver el código. Primero importamos cp.

Dentro de nuestro ciclo, revisamos si la tarjeta ha sido agitada con if cp.shake():. Si la tarjeta es agitada, entonces imprimimos (print) a la consola serial: Shake detected!

Nótese que hay unos paréntesis luego de cp.shake. Estos son necesarios para que la detección del agitado funcione correctamente. Sin ellos, tu código va a correr, pero no va a correr bien. ¡Asegúrate de incluirlos!

Agítalo un Poco

Vamos a agitar la tarjeta para prender el LED rojo. Agregar el siguiente código a tu code.py.

"""This example flashes the little red LED when the Circuit Playground is shaken."""
from adafruit_circuitplayground import cp

while True:
    if cp.shake(shake_threshold=20):
        print("Shake detected!")
        cp.red_led = True
    else:
        cp.red_led = False

Agita la tarjeta. ¡LED rojo!

Vamos a ver el código. Primero importamos cp.

Dentro de nuestro ciclo, revisamos si la tarjeta ha sido agitada. Sin embargo, hemos agregado algo a esta línea, un shake_threshold=20. Algunas veces puede que notes que tu tarjeta no responde cuando la agitas. O que responde con un movimiento muy ligero. Tienes la opción de modificar el umbral para que tengas que agitar la tarjeta más suave o más duro. El umbral por omisión es de 30. Bajar el umbral por omisión hace que sea más sencillo que se detecte un agitado. Bajar el umbral hace que sea más difícil de detectar ese agitado. El valor mínimo permitido es de 10. 10 es el valor cuando la tarjeta no está en movimiento. Si le pones un umbral de menos de 10, el código va a retornar que detectó un agitado incluso si la tarjeta no se está moviendo. Cambia el umbra a un número entero por encima de 10 y lo puedes ajustar a tus necesidades.

En este caso hemos incluido if cp.shake(shake_threshold=20): el cual cual baja el umbral, haciando que sea más sencillo el agitar la tarjeta. Si se detecta un agitado por encima de 20, imprimimos (print) Shake Detected!y prendemos el LED rojo. De otra forma, apagamos el LED rojo desde el bloque de else.

Trata de cambiar el umbral a 40 para ver que pasa. Eso si, si pones el umbral muy alto, el agitado nunca se va a detectar. ¡Debes jugar con estos valores para ver que funciona para ti!

La Circuit Playground Express y la Bluefruit tienen diez NeoPixeles RGB integrados. Aunque las imágenes son de la Circuit Playground Express, los LEDs están en la misma ubicación en la Bluefuit. Está situados en un anillo alrededor de la tarjeta, justo dentro del anillo exterior de pads amigables con cables de lagarto. RGB significa rojo (R), verde (G) y azul (B), y ¡eso significa que puedes crear cualquier color del arcoiris con estos LEDs!

Los colores del LED se definen con una combinación de rojo, verde y azul en la forma de una tupla (RG, B). Una tupla es típicamente un grupo de números. Cada miembro de la tupla RGB se define con un número entre 0 y 255 que determina la cantidad de cada color presente. ¡Rojo, verde y azul en diferentes combinaciones pueden crear todos los colores del arco iris! Así que por ejemplo, para poner el LED en rojo, la tupla sería (255, 0, 0), lo cual es el máximo de rojo, si nada de verde ni azul. Verde sería (0, 255, 0), y similar con azul. Para los colores intermedios, puedes hacer una combinación, como cían que es (0, 255, 255) con cantidades iguales de verde y azul.

No queremos hacerte esperar más. ¡Así que comencemos!

Agregue el  siguiente código a tu code.py. Recuerda que si necesitas ayuda puedes revisar aquí.

"""This example lights up all the NeoPixel LEDs red."""
from adafruit_circuitplayground import cp

while True:
    cp.pixels.fill((50, 0, 0))

¡Luces rojas!

Primero importamos cp.

Dentro de nuestro ciclo, tenemos cp.pixels.fill((50, 0, 0)) el cual prende todos los pixeles de color rojo con un aproximado del 20% de su brillo. Recuerda, el color máximo para rojo es 255. ¡Eso es muy brillante! Así que lo hemos puesto en un nivel menor para que no sea cegador, al definir le con un valor de 50. Los otros dos son 0, porque no hay verde ni azul agregados a la mezcla. ¡Eso es todo!

Ahora, tratar de cambiar los números de los otros valores. Por ejemplo, trata cp.pixels.fill((50, 50, 0)). ¡Mira que pasa!

¡Pixel Uno, Pixel Dos, Pixel Rojo, Pixel Azul!

Hemos prendido todos los pixeles del mismo color. Pero, ¿que si quieres controlar cada uno de forma individual? ¡Podemos hacer eso!

Agregar el siguiente código a tu code.py:

"""This example lights up the first NeoPixel red."""
from adafruit_circuitplayground import cp

cp.pixels.brightness = 0.3

while True:
    cp.pixels[0] = (255, 0, 0)

¡Ahora solo el primer pixel es rojo!

Veamos el código.

Primero importamos cp.

Luego tenemos la línea: cp.pixels.brightness = 0.3. Recuerda, nosotros controlamos el brillo utilizando un número menor en la tupla de color en el primer código. También es posible controlar el brillo de forma separada utilizando cp.pixels.brightness. El brillo es definido por un número entre 0 y 1 que representa un porcentaje. Así que cuando lo definimos en 0.3, lo estamos definiendo a un 30% del brillo.

Dentro de nuestro ciclo, tenemos cp.pixels[0] = (255, 0, 0). Como hemos definido el brillo de forma separada del color, ahora podemos usar el máximo nivel de color rojo o 255.

Observe como hemos definido el pixel número 0, pero esto ha prendido el primer pixel. Esto es porque CircuitPython comienza contando desde el 0. Así que lo primero que numeres en CircuitPython siempre será 0.

Vamos a tratar de definir el segundo pixel en azul. Recuerda, el segundo pixel va a ser el pixel 1. Agregue el siguiente código a su code.py.

"""This example lights up the first and second NeoPixel, red and blue respectively."""
from adafruit_circuitplayground import cp

cp.pixels.brightness = 0.3

while True:
    cp.pixels[0] = (255, 0, 0)
    cp.pixels[1] = (0, 0, 255)

Ahora tu segundo pixel es azul.

¡Eso es todo lo que hay que hacer! Puedes seguir agregando más pixeles hasta el 9, y definirlos todos de colores diferentes.

¡Intentalo!

La Circuit Playground Express y la Bluefruit tienen un sensor de luz al lado derecho, cerca del ojo que está impreso en la tarjeta. Aunque las imágenes son para la Circuit Playground Express, el sensor está básicamente en el mismo lugar en la Bluefruit. Siente la cantidad de luz en el ambiente y retorna un nivel según dicha cantidad. Lo hemos hecho muy sencillo de usar. ¡Mira!

Agregar el siguiente código en tu code.py. Y si tienes algún problema recuerda revisar aquí.

"""This example uses the light sensor on your Circuit Playground, located next to the picture of
the eye. Try shining a flashlight on your Circuit Playground, or covering the light sensor with
your finger to see the values increase and decrease."""
import time
from adafruit_circuitplayground import cp

while True:
    print("Light:", cp.light)
    time.sleep(0.2)

Abre la consola serial y trata alumbrando con un foco hacia tu Circuit Playground. ¡Los valores que se imprimen van a subir! Si en cambio tapas con tu mano la tarjeta para bloquear la luz, los valores bajan.

Vamos a ver el código. Primero importamos time y cp.

Dentro de nuestro ciclo, imprimimos (print) a la consola serial Light: seguido por el valor de luz , cp.light. Luego tenemos atime.sleep(1) para bajar la velocidad a la que se imprime en la consola serial. Si es demasiado rápido, ¡es muy difícil de leer!

Graficando la Luz

¡Vamos a observar estos valores con el traazador gráfico de Mu! Agregar el siguiente código a tu code.py:

"""If you're using Mu, this example will plot the light levels from the light sensor (located next
to the eye) on your Circuit Playground. Try shining a flashlight on your Circuit Playground, or
covering the light sensor to see the plot increase and decrease."""
import time
from adafruit_circuitplayground import cp

while True:
    print("Light:", cp.light)
    print((cp.light,))
    time.sleep(0.1)

El código es casi identico, pero hemos agregado una línea print((cp.light,)).

Nótese que el trazador gráfico de Mu busca a valores de tipo tupla para poderlos graficar. Las tuplas de Python vienen en paréntesis() y separados por coma. Si tienes dos valores, una tupla se va a ver algo como (1.0, 3.14).Pero como solo tenemos un valor, necesitamos imprimirlo así:  (1.0,) - con paréntesis alrededor del número, y con una coma luego del número. Por eso los paréntesis extras y la coma en print((cp.light,)).

Así mismo, el trazador gráfico de Mu requiere el valor de la tupla esté solo en una línea. De esta forma no podemos simplemente agregarle paréntesis y la coma a la línea print("Light:", cp.light). El trazador gráfico no sabe que hacer con toda esa información ahí.

Has click en el botón de Plotter arriba en Mu para ver el trazador gráfico. ¡Trata alumbrando con un foco a tu Circuit Playgroud y observa la línea del trazador gráfico como sube! Remueve o bloquea la luz con tu mano para ver como baja. ¡Diviértete con esto!

Medidor de Luz con NeoPixeles

También puedes usar los valores de luz para crear un medidor divertido utilizando los NeoPixeles de tu Circuit Playground. Agrega el siguiente código a tu code.py:

"""
This example uses the light sensor on the Circuit Playground, located next to the picture of the
eye on the board. Once you have the library loaded, try shining a flashlight on your Circuit
Playground to watch the number of NeoPixels lit up increase, or try covering up the light sensor
to watch the number decrease.
"""

import time
from adafruit_circuitplayground import cp

cp.pixels.auto_write = False
cp.pixels.brightness = 0.3


def scale_range(value):
    """Scale a value from 0-320 (light range) to 0-9 (NeoPixel range).
    Allows remapping light value to pixel position."""
    return round(value / 320 * 9)


while True:
    peak = scale_range(cp.light)
    print(cp.light)
    print(int(peak))

    for i in range(10):
        if i <= peak:
            cp.pixels[i] = (0, 255, 255)
        else:
            cp.pixels[i] = (0, 0, 0)
    cp.pixels.show()
    time.sleep(0.05)

Ahora, ¡trata alumbrando a tu Circuit Playgroud para ver como los LEDs se prenden!

Lentamente, remueve la luz para observar como el número de LEDs comienza a bajar lentamente.

Vamos a ver el código. Primero, importamos atime y a cp.

Luego, definimos cp.pixels.auto_write = False.Esto significa que cualquier cosa que le decimos a los LEDs no aparece inmediatamente. Por omisión, esto está definido en True. Esto significa que le decimos a los LEDs que se prendan y ellos se prenden. Si está en False, esto significa que ahora debemos incluir cp.pixels.show() luego de cualquier cosa que le digamos a los LEDs que hagan. Esto es requerido para que este código pueda prender los LEDs basado en los valores de luz.

Definimos el brillo (brightness) a 0.3, o 30%.

Luego tenemos una función utilitaria llamada scale_range. El valor de luces es de aproximadamente 0-320, pero solo hay 10 NeoPixeles. Así que incluimos una función utilitaria que escala de 0-320 a 0-9 para tener reciprocidad con los niveles de luz y la posición del pixel.

Nuestro ciclo comienza definiendo peak = scale_range(cp.light). Luego imprimimos los vvalores de cp.light y los valores de peak.

La siguiente sección toma al valor peak y le dice que para el número total de LEDs, sin importar el número al que peak sea mayor o igual a, prenda esta cantidad de LEDs o de otra manera, apáguelos. Así que si el pico es 4, ¡prenda 4 LEDs!

Luego tenemos a cp.pixels.show()para que se muestren los LEDs. Y un time.sleep(0.05) para crear un poco de letargo.

Puedes cambiar los valores numéricos en cp.pixels[i] = (0, 255, 255) para cambiar el color que muestra el medidor de luz. ¡Pruébalo!

La Circuit Playground Express y la Bluefruit ambas trae un acelerómetro cerca del centro de la tarjeta. Este sensor puede darnos valores de aceleración para los ejes x, y, z además de detección de toques ligeros y de agitado. Los valores que responde son en m/s2 (metros por segundo cuadrado). Un eje es una línea invisible que va a través del acelerómetro en el centro de tu tarjeta. El eje x va a través de la tarjeta de izquierda a derecha. El eje y pasa a través de la tarjeta de arriba hacia abajo. El eje z para a través de la tarjeta del frente hacia atrás. Los valores pueden ser agrugados en una tupla de Python: (x, y, z).

Un acelerómetro mide aceleración. Puedes leer más sobre aceleración aquí. Cuando la tarjeta se sostiene en una posición, esta es afectada por la gravedad. La gravedad es -9.8m/s2. Así que en un momento dado en el tiempo, esta fuerza se está aplicando hacia abajo. Por ejemplo, si los valores que te retorna mientras la tarjeta está acostada a nivel, y viendo hacia arriba, serían (0, 0, 9.8), porque la gravedad está jalando el sensor sobre el eje z. Si agarras la tarjeta y la agitas, vas a ver valores mucho más grandes. Esto es porque la fuerza con que mueves la tarjeta, crea una aceleración que se le aplica al sensor en cualquier dirección que sea que lo estés moviendo.

Agrega el siguiente código a tu code.py. Recuerda que si necesitas ayuda con esto, puedes revisar aquí.

"""
This example uses the accelerometer on the Circuit Playground. It prints the values. Try moving
the board to see the values change. If you're using Mu, open the plotter to see the values plotted.
"""
import time
from adafruit_circuitplayground import cp

while True:
    x, y, z = cp.acceleration
    print((x, y, z))

    time.sleep(0.1)

Abra la consola serial para ver donde se imprimen los valores de x, y, z. ¡Trata de mover la tarjeta para ver como los valores cambian!

Vamos a revisar el código. Primero importamos (import) atime y a cp.

Dentro de nuestro ciclo, asignamos x, y, z = cp.acceleration. Ya que nuestros valores de aceleración son una tupla con 3 valores (x, y, z) necesitas asignar cp.acceleration hacia tres variables para poder asignar esos tres valores. Hemos escodigo x, y ,z porque estos son los tres ejes que representa cp.acceleration.

Luego imprimimos con print ((x, y, z)). Incluimos un time.sleep(0.1) para bajar la velocidad de los valores que se imprimen, si se imprimen muy rápido, sería difícil de leer.

Ya que (x, y, z) ya es una tupla, y no imprimimos ninguna etiqueta para los valores, podemos usar el trazador gráfico de Mu en nuestro código, sin necesidad de cambios. Realiza click en el botón de Plotter en la parte superior de Mu para ver las trazas gráficas. ¡Trata de mover la tarjeta para que veas como cambian las líneas en el trazador gráfico!

Acelerómetro que Brilla en Colores

Puedes utilizar los valores de aceleración para crear proyectos divertidos que usen los NeoPixeles Como hay tres valores de aceleración, y los LEDs tienen tres valores de color, ¡vamos a ver que podemos hacer con esto!

Agregue el siguiente código a su code.py.

"""If the switch is to the right, it will appear that nothing is happening. Move the switch to the
left to see the NeoPixels light up in colors related to the accelerometer! The Circuit Playground
has an accelerometer in the center that returns (x, y, z) acceleration values. This program uses
those values to light up the NeoPixels based on those acceleration values."""
from adafruit_circuitplayground import cp

# Main loop gets x, y and z axis acceleration, prints the values, and turns on
# red, green and blue, at levels related to the x, y and z values.
while True:
    if not cp.switch:
        # If the switch is to the right, it returns False!
        print("Slide switch off!")
        cp.pixels.fill((0, 0, 0))
        continue
    R = 0
    G = 0
    B = 0
    x, y, z = cp.acceleration
    print((x, y, z))
    cp.pixels.fill(((R + abs(int(x))), (G + abs(int(y))), (B + abs(int(z)))))

Mueva el interruptor deslizante hacia la derecha si no se encuentra ahí en este momento. ¡Luces! ¡Ahora mueva la tarjeta en diferentes direcciones para ver los cambios de color!

Vamos a ver el código. Primero importamos a cp.

Dentro de nuestro ciclo, comenzamos por revisar si (if) el interruptor se encuentra hacia la izquierda. Si lo está, imprimimos con print el texto Slide switch off! y apagamos todos los LEDs. Esto crea un interruptor de "apagado" para el proyecto, en caso de que lo dejes por ahí, para que no tenga las luces prendidas todo el tiempo.continue le dice al código que siga revisando el interruptor hasta que tenga un cambio de estado, e.g. cuando mueves el interruptor hacia la derecha. Una vez que esto sucede, seguimos hacia el resto del código.

Ahora tenemos un bloque else. Primero, creamos tres variables, R, G y B. Las vamos a utilizar para definir los colores. Para iniciar las definimos en 0 to start. Luego, asignamos  x, y, z = cp.acceleration e imprimimos los valores. Si ves la salida serial, puedes observar como estos valores pasan por la pantalla muy rápido. Por esto es que normalmente incluimos un  time.sleep() en el código, para bajar la velocidad a la que se imprimen los valores para que se puedan leer. Sin embargo, este proyecto trabaja mejor si un sleep, por lo cual no se lo hemos agregado.

La útima línea llena los LEDs con los valores RGB basados en la aceleración, usando la línea:

cp.pixels.fill(((R + abs(int(x))), (G + abs(int(y))), (B + abs(int(z)))))

Esto requiere algo de matemática especial para que funcione. ¡Vamos a revisar!

Primero vamos a ver el valor para rojo. Inciamos con R que creamos al inicio del ciclo. Le vamos a agregar el valor x hacia el valor R.Sin embargo, hay mucho sobre aceleración básica que no va a funcionar con valores de color, como que podemos recibir un valor decimal, o hasta un número negativo. Por suerte, Python tiene maneras sencillas de lidiar con esto.

Vas a nota que el valor de x es modificado un poco con abs(int(x)). Esto retorna el valor absoluto (nunca negativo) del valor entero de x. Los valores absolutos se explican aquí. Ya que nuestros valores de color son todos números enteros, usamos int(x) para retornar el número entero más cercano al valor x, en lugar de un decimal largo que es lo que normalmente retorna la aceleración. Y como los valores de color son siempre positivos, le tomamos un valor absoluto de int(x) para eliminar números negativos que puedan venir potencialmente entre los datos.

Nosotros le asignamos abs(int(x)) a R y luego usamos el valor de R para definir el rojo. Luego hacemos lo mismo para y y para z, excepto que abs(int(y)) se asignado a G y abs(int(z)) es asignado a B. ¡Esto no da tres valores correctos que podemos usar para color!

Mientras mueves la tarjeta, los valores de aceleración van a cambiar, y esto causa que cada uno de los valores de color sea diferente. Ahora, dependiendo del ángulo en que sostienes la tarjeta, ¡vas a recibir una combinación diferente de color!

Recuerda el ejemplo anterior, donde explicamos que si la tarjeta está acostada a nivel, los valores que retorna son (0, 0, 9.8). Esto quiere decir que si la tarjeta está acostada a nivel, los valores de color van a ser(0, 0, 9.8). Así que si está acostada a nivel en tu escritorio, ¡va a ser azul!

Si la sostienes del cable USB de la parte superior apuntando hacia abajo, los valores van a ser (0, 9.8, 0), así que los NeoPixeles serán verdes.

Si la sostienes con el cable USB de lado, apuntando hacia izquierda o derecha, los valores van a ser (9.8, 0, 0) así que los NeoPixeles van a ser rojos.

Mientras mueves la tarjeta a diferentes ángulos, ¡vas a encontrar todos los colores intermedios!

También hemos explicado que si agitas la tarjeta, vas a recibir valores más altos del acelerómetro. Esto significa que los NeoPixeles van a ser más brillantes, entre más duro la agites. ¡Realiza la prueba!

La Circuit Playground Express y la Bluefruittienen dos botones. El botón A está la izquierda, y el botón B está a la derecha. Aunque las imágenes son de la Circuit Playground Express, los botones están en el mismo lugar en la Bluefruit. Estos botones pueden ser usados como entradas, lo que significa que le puedes decir a tu tarjeta que haga algo cuando los presionas.

Vamos a comenzar con el botón A. Agregue el siguiente código a su code.py. Recuerde, si necesita ayuda con eso revise aquí.

"""This example turns on the little red LED when button A is pressed."""
from adafruit_circuitplayground import cp

while True:
    if cp.button_a:
        print("Button A pressed!")
        cp.red_led = True

Ahora, presiona el botón A. ¡LED Rojo!

Vamos a ver el código. Primero, importamos cp.

Dentro de nuestro ciclo, revisamos si el botón A ha sido presionado con if cp.button_a:. Luego, si está siendo presionado, ¡imprimimos Button A pressed! hacia la consola serial, y prendemos el LED rojo!

Note que el LED se queda prendido una vez que el botón A es presionado. Esto es porque nunca le dijimos al código que lo apagara. Así que vamos a probar algo diferente.

Agregue el siguiente código a su code.py:

"""This example turns the little red LED on only while button B is currently being pressed."""
from adafruit_circuitplayground import cp

# This code is written to be readable versus being Pylint compliant.
# pylint: disable=simplifiable-if-statement

while True:
    if cp.button_b:
        cp.red_led = True
    else:
        cp.red_led = False

# Can also be written as:
#    cp.red_led = cp.button_b

Ahora presiona el botón B. ¡LED Rojo! Pero ahora solo mientras está siendo presionado. ¡Bien!

Vamos a observar el código. Primero importamos cp.

Dentro de nuestro ciclo, revisamos si el botón B ha sido presionado con if cp.button_b:. Si está siendo presionado, prendemos el LED rojo. Luego, en nuestroelse:, le decimos al código "de otra manera, apague el LED rojo". Así que cuando el botón no está siendo presionado, ¡el LED se apaga!

Puedes usar ambos botones en el mismo programa. Vamos a cambiar un poco las cosas.

Agregue el siguiente código a su code.py:

"""This example lights up the third NeoPixel while button A is being pressed, and lights up the
eighth NeoPixel while button B is being pressed."""
from adafruit_circuitplayground import cp

cp.pixels.brightness = 0.3
cp.pixels.fill((0, 0, 0))  # Turn off the NeoPixels if they're on!

while True:
    if cp.button_a:
        cp.pixels[2] = (0, 255, 0)
    else:
        cp.pixels[2] = (0, 0, 0)

    if cp.button_b:
        cp.pixels[7] = (0, 0, 255)
    else:
        cp.pixels[7] = (0, 0, 0)

Ahora presione el botón A o B. O presione ambos al mismo tiempo. ¡NeoPixeles verdes y azules!

Nuestro código está revisando si (if) cada botón está siendo presionado. Si está siendo presionado, prende el LED a la par del botón con un color específico. El botón A prende su LED a la par en verde. El botón B prende su botón a la par en azul. Y si ambos botones no están siendo presionados, los LEDs se apagan con cp.pixels.fill((0, 0, 0)).

Mitad y Mitad

Vamos a hacer algo más elegante. Agregue el siguiente código a su code.py:

"""This example lights up half the NeoPixels red while button A is being pressed, and half the
NeoPixels green while button B is being pressed."""
from adafruit_circuitplayground import cp

cp.pixels.brightness = 0.3
cp.pixels.fill((0, 0, 0))  # Turn off the NeoPixels if they're on!

while True:
    if cp.button_a:
        cp.pixels[0:5] = [(255, 0, 0)] * 5
    else:
        cp.pixels[0:5] = [(0, 0, 0)] * 5

    if cp.button_b:
        cp.pixels[5:10] = [(0, 255, 0)] * 5
    else:
        cp.pixels[5:10] = [(0, 0, 0)] * 5

Ahora presiona el botón A o el B. Los NeoPixeles se partieron por la mitad, ¡donde su lado es respectivo al lado donde se encuentra el botón!

Aquí estamos utilizando un concepto llamado partición. Una partición te permite indicar un punto de inicio y de finalizado y nos permite decirle al código que prenda las luces que están dentro de la partición. Así que en lugar de especificarle un solo LED con [0], le decimos a la tarjeta que prenda la primera mitad de los LEDs al presionar el botón A con cp.pixels[0:5] = [(255, 0, 0)] * 5. El  [0:5] es el punto de inicio y de final, y el * 5 es el tamaño de la partición (5 de 10 LEDs) Hacemos lo mismo para el botón B y la segunda mitad de los LEDs con cp.pixels[5:10]. Y luego le decimos a los LEDs que de otra forma se apaguen si no hay botones presionados.

Note que los puntos de terminado son normalmente 1 número más alto que el valor de numerado de los LEDs; esto porque la matemática de particiones es un poco diferente a como cuenta CircuitPython. Trata de jugar con esto un poco. Cambie el primer conjunto de valores a cp.pixels[1:4] = [(255, 0, 0)] * 3. ¡Observe cuales LEDs se prenden ahora!

Si usted trata de especificar un conjunto de LEDs que es diferente al tamaño de partición, su código no va a poder correr y un error se va a imprimir en la consola serial. Por ejemplo cp.pixels[1:4] = [(255, 0, 0)] * 4 va a fallar dado que el tamaño de partición debería ser 3. ¡Asegúrate de combinarlos correctamente!

La Circuit Playground Express y la Bluefruit tienen un sensor de temperatura integrado, a la par del símbolo de un termómetro que está impreso en la tarjeta. Aunque las imágenes son de la Circuit Playground Express, el sensor se encuentra básicamente en el mismo lugar en la Bluefruit. Se encuentra cerca de una etiqueta de A9 en la tarjeta. Responde la temperatura en Celsius.

Agregue el siguiente código a su code.py. Recuerda, si necesitas ayuda con esto, haz click aquí.

"""This example uses the temperature sensor on the Circuit Playground, located next to the image of
a thermometer on the board. It prints the temperature in both C and F to the serial console. Try
putting your finger over the sensor to see the numbers change!"""
import time
from adafruit_circuitplayground import cp

while True:
    print("Temperature C:", cp.temperature)
    print("Temperature F:", cp.temperature * 1.8 + 32)
    time.sleep(1)

Abra la consola serial para ver donde se imprime la temperatura. Trata de acercar tu dedo al símbolo de termómetro que está impreso en la tarjeta, ¡a ver si los valores cambian!

Vamos a observar el código. Importamos a time y a cp.

Dentro de nuestro ciclo, imprimimos Temperature C:, seguido del valor de temperatura, cp.temperature. Esto imprime la temperatura en Celsius.

¿Pero y que si necesitas la temperatura en Fahrenheit? Esto se logra con un poco de matemática para poderlo mostrar de esta forma. Luego de imprimir la temperatura en C, imprimimos Temperature F:, seguido de cp.temperature de nuevo, pero esta vez modificada con * 1.8 + 32, para convertirlo a Fahrenheit.

Luego tenemos un time.sleep(1) para bajar la velocidad de las lecturas, ya se si son muy rápidas, ¡se vuelven difícil de leer!

Graficando la Temperatura

¡Vamos a observar los valores en el trazador gráfico de Mu! Agregue el siguiente código a tu code.py:

"""If you're using Mu, this example will plot the temperature in C and F on the plotter! Click
"Plotter" to open it, and place your finger over the sensor to see the numbers change. The
sensor is located next to the picture of the thermometer on the CPX."""
import time
from adafruit_circuitplayground import cp

while True:
    print("Temperature C:", cp.temperature)
    print("Temperature F:", cp.temperature * 1.8 + 32)
    print((cp.temperature, cp.temperature * 1.8 + 32))
    time.sleep(0.1)

El código es casi idéntico, pero hemos agregado una línea: print((cp.temperature, cp.temperature * 1.8 + 32)).

Note que el trazador gráfico de Mu, busca por valores en forma de tupla para poderlos graficar. Las tuplas en Python vienen en paréntesis() con comas de separador. Así que si tienes dos valores, una tupla se va a ver así (1.0, 3.14) - observe los paréntesis rodeando a ambos números, y la coma entre ellos. Por eso es que hay unos paréntesis extra y una coma entre los valores de temperatura enprint((cp.temperature, cp.temperature * 1.8 +32)).

Así mismo, el trazador gráfico de Mu requiere que los valores de tuplas estén solos. Por eso es que no podemos simplemente agregarle paréntesis al mensaje anterior de print("Temperature C:", cp.temperature) . El trazador gráfico no sabe que hacer si hay información adicional ahí.

Haga click en el botón de Plotter en la parte superior de Mu para ver el trazador gráfico. Trate de respirar en su Circuit Playground para ver como las trazas suben. ¡Trata de ponerle cerca algo frío para ver como las trazas bajan!

Medidor de Temperatura

También puedes usar los valores de temperatura para crear un divertido medidor con luz, ¡usando los NeoPixeles en tu Circuit Playground! Agrega el siguiente código a tu code.py:

"""
This example use the temperature sensor on the Circuit Playground, located next to the picture of
the thermometer on the board. Try warming up the board to watch the number of NeoPixels lit up
increase, or cooling it down to see the number decrease. You can set the min and max temperatures
to make it more or less sensitive to temperature changes.
"""
import time
from adafruit_circuitplayground import cp

cp.pixels.auto_write = False
cp.pixels.brightness = 0.3

# Set these based on your ambient temperature in Celsius for best results!
minimum_temp = 24
maximum_temp = 30


def scale_range(value):
    """Scale a value from the range of minimum_temp to maximum_temp (temperature range) to 0-10
    (the number of NeoPixels). Allows remapping temperature value to pixel position."""
    return int((value - minimum_temp) / (maximum_temp - minimum_temp) * 10)


while True:
    peak = scale_range(cp.temperature)
    print(cp.temperature)
    print(int(peak))

    for i in range(10):
        if i <= peak:
            cp.pixels[i] = (0, 255, 255)
        else:
            cp.pixels[i] = (0, 0, 0)
    cp.pixels.show()
    time.sleep(0.05)

Ahora trata de sostener tu dedo cerca del símbolo de termómetro que está impreso en tu Circuit Playground y ¡observa como la cantidad de luces LED aumenta! Quita el dedo para ver como la cantidad de luces prendidas cambia.

Vamos a ver el código. Primero importamos a time, y a cp.

Luego, definimos cp.pixels.auto_write = False. Esto significa que lo que le digamos a los LEDs no va a suceder inmediatamente. Por omisión esto está definido en True. O sea, cuando le decimos a los LEDs que se prendan, se prenden de inmediato. Si está definido en False, quiere decir que vamos a tener que incluir cp.pixels.show() luego de que le digamos que haga algo con los LEDs. Esto es necesario porque queremos prender los LEDs como reacción a los valores de temperatura.

Definimos el brillo (brightness) a 0.3, o un 30%.

Deberías poder ver cambios cuales son los cambios de temperatura por ejemplo si pones tu Circuit Playground en tu escritorio, y le acercas un dedo encima del sensor. Para mejores resultados, puedes ajustar minimum_temp y maximum_temp a valores que tengan sentido para tu ambiente. De otra forma, no vas a obtener los mejores resultados del lector de temperatura. Con la tarjeta sobre el escritorio la temperatura fue de 24 grados, y cuando le pones un dedo encima del sensor el máximo fue de unos 30. Así es como escogimos los valores que están ahorita en el código.

Luego tenemos una función utilitaria llamada scale_range. La temperatura es actualmente de 24 a 30, pero solo hay 10 NeoPixeles. Así que incluimos esta función utilitaria que escala el rango de 24-30 hacia 0-9 para que podamos ser recíprocos con los niveles de luz y la posición de los pixeles.

Nuestro ciclo comienza definiendo peak = scale_range(cp.temperature).  Luego imprimimos los valores de cp.temperature y los valores de peak.

En la siguiente sección tomamos el valor de peak y cualquier número sea igual o menor que peak, es la cantidad de LEDs que vamos a prender, o de lo contrario, lo apagamos. Así que si el pico es 4, ¡prendemos 4 LEDs!

Luego tenemos cp.pixels.show() para que los LEDs prendan. Y luego un time.sleep(0.05) para crear algo de pausa.

Puedes cambiar el número de valores en cp.pixels[i] = (0, 255, 255) para cambiar el color en el medidor de temperatura. ¡Prueba tu mismo!

La Circuit Playground Express y la Bluefruit tienen siete pads capacitivos alrededor del exterior de la tarjeta, etiquetados como A1 - A6 y TX. Aunque las imágenes son de una Circuit Playground Express, los pads táctiles se encuentran en el mismo lugar en una Bluefruit. Estos pads devuelve True si los tocas. ¡Los puedes usar como entradas para hacer todo tipo de cosas divertidas!

Ya que los pads son capacitivos, también les puedes conectar cables de lagarto y ¡un sin fin de cosas capacitivos, y tocarlos para activarlos! Por ejemplo, les puedes conectar un lado de un cable de lagarto y el otro lado hacia una manzana o un limón. O puedes conectar la otra parte en un vaso con agua. Luego tocas la fruta o el agua en el vaso. ¡Con esto activas el pad!

Agrega el siguiente código a tu code.py. Recuerda, si necesitas ayuda, revisa aquí.

"""This example prints to the serial console when you touch capacitive touch pad A1."""
from adafruit_circuitplayground import cp

while True:
    if cp.touch_A1:
        print("Touched pad A1")

Abra la consola serial. Ahora, toque el pad etiquetado en la Circuit Playground como A1. ¡Touched pad A1!

Vamos a ver el código. Primero, importamos a time y a cp.

Dentro de nuestro enlace, revisamos si el pad A1 es tocado con if cp.touch_A1:. Si lo es, imprimimos conprintel texto Touched pad A1 hacia la consola serial. Luego tenemos un  time.sleep(0.1) para dar un poco de pausa cuando imprimimos.

¡Bien! ¿Pero que pasa con el resto de los pads? Agrega el siguiente código en tu code.py.

"""This example prints to the serial console when you touch the capacitive touch pads."""
from adafruit_circuitplayground import cp

while True:
    if cp.touch_A1:
        print("Touched pad A1")
    if cp.touch_A2:
        print("Touched pad A2")
    if cp.touch_A3:
        print("Touched pad A3")
    if cp.touch_A4:
        print("Touched pad A4")
    if cp.touch_A5:
        print("Touched pad A5")
    if cp.touch_A6:
        print("Touched pad A6")
    if cp.touch_TX:
        print("Touched pad TX")

Ahora, veamos la consola serial y toque algunos de los pads. ¡Touched pad...!

El código comienza de la misma forma. Pero, hemos agregado un par de líneas para el toque de cada pad. Primero revisamos si (if) cada pad está siendo tocado, y si lo es, entonces imprimimos Touched pad y el número del pad que tocamos, hacia la consola serial.

Hemos incluido a todos los pads táctiles. ¡Ahora hagamos algo con ellos!

Tocar el Arco Iris

Agregue el siguiente código a tu code.py.

"""This example uses the capacitive touch pads on the Circuit Playground. They are located around
the outer edge of the board and are labeled A1-A6 and TX. (A0 is not a touch pad.) This example
lights up the nearest NeoPixel to that pad a different color of the rainbow!"""
import time
from adafruit_circuitplayground import cp

cp.pixels.brightness = 0.3

while True:
    if cp.touch_A1:
        print("Touched A1!")
        cp.pixels[6] = (255, 0, 0)
    if cp.touch_A2:
        print("Touched A2!")
        cp.pixels[8] = (210, 45, 0)
    if cp.touch_A3:
        print("Touched A3!")
        cp.pixels[9] = (155, 100, 0)
    if cp.touch_A4:
        print("Touched A4!")
        cp.pixels[0] = (0, 255, 0)
    if cp.touch_A5:
        print("Touched A5!")
        cp.pixels[1] = (0, 135, 125)
    if cp.touch_A6:
        print("Touched A6!")
        cp.pixels[3] = (0, 0, 255)
    if cp.touch_TX:
        print("Touched TX!")
        cp.pixels[4] = (100, 0, 155)
    time.sleep(0.1)

Ahora toque cada pad. ¡Vas a tener un LED en cada uno de los de colores del arco iris para cada pad!

Ahora vamos a ver el código. Importamos a time y a cp. Definimos el brillo de los LEDs a un 30%. Revisamos si (if) cada uno de los pads es tocado, y si lo es imprimimos (print) a la consola serial. Esta vez sin embargo, también prendemos un LED específico a cada pad con cp.pixels[#] = (r, g, b) donde # es el número del pixel y r, g, b son los valores de color. Nosotros no hemos incluído ningún código para que se apaguen, por lo que una vez que los prendas se van a quedar prendidos.

¡Ahora vamos a agregar más luz! Agrega el siguiente código a tu code.py.

"""This example uses the capacitive touch pads on the Circuit Playground. They are located around
the outer edge of the board and are labeled A1-A6 and TX. (A0 is not a touch pad.) This example
lights up all the NeoPixels a different color of the rainbow for each pad touched!"""
import time
from adafruit_circuitplayground import cp

cp.pixels.brightness = 0.3

while True:
    if cp.touch_A1:
        print("Touched A1!")
        cp.pixels.fill((255, 0, 0))
    if cp.touch_A2:
        print("Touched A2!")
        cp.pixels.fill((210, 45, 0))
    if cp.touch_A3:
        print("Touched A3!")
        cp.pixels.fill((155, 100, 0))
    if cp.touch_A4:
        print("Touched A4!")
        cp.pixels.fill((0, 255, 0))
    if cp.touch_A5:
        print("Touched A5!")
        cp.pixels.fill((0, 135, 125))
    if cp.touch_A6:
        print("Touched A6!")
        cp.pixels.fill((0, 0, 255))
    if cp.touch_TX:
        print("Touched TX!")
        cp.pixels.fill((100, 0, 155))
    time.sleep(0.1)

Toque cada pad. ¡Ahora has logrado que cada LED se prenda en un color del arco iris para cada uno de ellos!

El código es casi exáctamente el mismo, pero en lugar de cp.pixels[#], estamos usando cp.pixels.fill((r, g, b)) para prender todos los LEDS en lugar de solo uno.

Puedes cambiar los valores a lo que desees y crear tu arco iris personalizado. ¡Realiza la prueba!

La Circuit Playground Express y la Bluefruit tienen un parlante integrado, encima de la nota musical impresa en la tarjeta. Es una cajita gris con un símbolo de + en ella, debajo del botón A y a la izquierda del interruptor deslizante. Aunque la imagen es de una Circuit Playground Express, el parlante está en la misma ubicación en una Bluefruit. El parlante es capaz de muchas cosas, incluida la habilidad para tocar tonos.

Agregue el siguiente código a su code.py. Recuerda, si necesitas ayuda con eso revisa aquí.

"""This example plays two tones for 1 second each. Note that the tones are not in a loop - this is
to prevent them from playing indefinitely!"""
from adafruit_circuitplayground import cp

cp.play_tone(262, 1)
cp.play_tone(294, 1)

Cuando salves el código, ¡vas a tener dos tonos!

Primero importamos a cp. Luego, tocamos un tono, seguido de otro con cp.play_tone(262, 1) y con cp.play_tone(294, 1).

Nótese que no hemos incluído un ciclo para este código. Esto es porque el código está en un ciclo, el cual va a continuar de forma indefinida. Esto no siempre es deseable, pero hemos diseñado el código para que toque cada nota una vez.

cp.play_tone() requiere de ti, dos cosas: la frecuencia en hercios y la longitud del tiempo en segundos. Así que cuando lo desees utilizar, vas a agregar cp.play_tone(frequency, seconds) a tu código, donde frequency es el tono en hertz que deseas tocar y seconds es el tamaño de tiempo que deseas que se toque.

Hay muchos generadores de tonos disponibles en Internet que te van a decir los hercios de un tono específico. Las dos notas que hemos agregado en el código actual corresponden a un Do medio y al Re encima del Do medio. Trata de agregar otro tono. ¡Diviértete!

Botones para Doble Tono

Puedes utilizar cualquiera de las entradas de las que hemos hablado para tocar tonos. Vamos a probar usando los botones. Agregar el siguiente código a tu code.py.

"""This example plays a different tone for a duration of 1 second for each button pressed."""
from adafruit_circuitplayground import cp

while True:
    if cp.button_a:
        cp.play_tone(262, 1)
    if cp.button_b:
        cp.play_tone(294, 1)

Ahora, presiona cada botón. ¡Cada uno toca un tono por un segundo!

Este código es el mismo que hemos usado anteriormente con los botones. Dentro del ciclo preguntamos si (if) cada botón es presionado. Esta vez, si el botón A es presionado, toca un tono de 262Hz por 1 segundo, y si el botón B es presionado, tocar un tono de 294Hz por 1 segundo.

Puedes utilizar cualquiera de las entradas que hemos discutido en esta guía para disparar un tono. Trata de remplazar el presionado de botones por los pads táctiles. ¡Diviértete!

La Circuit Playground Express y la Bluefruit tienen un parlante integrado encima del símbolo de nota musical, impreso en la tarjeta. Es la caja gris con un + en ella, debajo del botón A, a la izquiera el interruptor deslizante. Aunque la imagen es de una Circuit Playground Express, se encuentra en el mismo lugar en la Bluefruit. Este parlante es capaz de muchas cosas incluida la habilidad para tocar tonos.

¿Que si, en lugar de tocar un tono específico por una cantidad de tiempo (usando play_tone()), quieres que solo toque el tono cuando presionas un botón? ¿O cuando tocas un pad? ¡Puedes hacerlo!

Agrega la siguiente línea de código en tu code.py. Recuerda, si necesita ayuda con esto, revisa aquí.

"""This example plays a different tone for each button, while the button is pressed."""
from adafruit_circuitplayground import cp

while True:
    if cp.button_a:
        cp.start_tone(262)
    elif cp.button_b:
        cp.start_tone(294)
    else:
        cp.stop_tone()

Presiona el botón A. Ahora presiona el botón B. Cada botón toca un tono, ¡pero solo mientras son presionados!

Vamos a revisar el código. Primero, importamos cp.

Dentro de nuestro ciclo, revisamos si (if) los botones están siendo presionados. Si el botón A es presionado, comenzamos un tono con cp.start_tone(262). Y si el botón B es presionado, iniciamos un tono con cp.start_tone(294). De otra forma, si no están siendo presionados, detenemos el tono. ¡Eso es!

cp.start_tone() requiere que le pases un dato, la frecuencia en hercios del tono que deseas iniciar. Así que cuando desees usarlo, vas a agregar cp.start_tone(frequency) a tu código, donde frequency es la frecuencia, en hercios del tono que deseas iniciar.

cp.start_tone() requiere a cp.stop_tone() para dejar de sonar. Sin él, vas a iniciar el tono y se va a tocar indefinidamente. ¡Te vas a dar cuenta bien rápido cuando se te olvide poner cp.stop_tone()!

Trata remplazando los botones A y B por los pads de toque A1 y A2, y cambiando las frecuencias para obtener diferentes tonos. ¡Trata usando todas las entradas de toque para tener más opciones tonales!

La Circuit Playground Express y la Bluefruit tienen un parlante integrado, encima de la nota musica impresa en la tarjeta. Es la cajita gris con un símbolo de + en ella, debajo del botón A y a la izquierda del interruptor deslizante. Aunque la imagen es de una Circuit Playground Express, el parlante está en el mismo lugar en la Bluefruit. ¡El parlante es capaz de tocar música mono, codificada en archivos de un formato especial llamados archivos wav!

Los archivos de sonido para la Librería Circuit Playground deberían ser archivos WAV de 22,050 kHz, 16-bit, mono (o de menor calidad) para poderse tocar en estas tarjetas. Si tienes un MP3 o un archivo que has descargado, debes asegurarte que si codificación se la correcta, o puedes seguir esta guía sobre conversión de audio para llevar a tus archivos al formato apropiado.

Para pruebas, hemos preparado dos archivos WAV en el formato adecuado. Puedes descargar los siguientes dos archivos .wav y copiarlos a la unidad de disco CIRCUITPY de la Circuit Playground

Agrega el siguiente código a tu code.py. Y recuerda que si necesitas ayuda puedes revisar aquí.

"""THIS EXAMPLE REQUIRES A WAV FILE FROM THE examples FOLDER IN THE
Adafruit_CircuitPython_CircuitPlayground REPO found at:
https://github.com/adafruit/Adafruit_CircuitPython_CircuitPlayground/tree/master/examples

Copy the "dip.wav" file to your CIRCUITPY drive.

Once the file is copied, this example plays a wav file!"""
from adafruit_circuitplayground import cp

cp.play_file("dip.wav")

¡Dip!

Vamos a observar el código. Primero importamos cp.

Luego, tocamos un archivo llamado dip.wav con cp.play_file("dip.wav"). ¡Eso es todo!

Nótese que no hemos incluido un ciclo en este código. Esto es porque si el código está en un ciclo, va a continuar sonando de forma indefinida. Esto no siempre es deseable, así que hemos diseñado el código para que suene solo una vez.

cp.play_file() requiere que le digas una cosa: el nombre del archivo wav que quieres tocar, encerrado entre comillas. Así es como el sabe lo que tiene que tocar. En cualquier momento que lo desees utilizar, vas a agregar un cp.play_file("Filename.wav") a tu código, reemplazando el Filename.wav por el nombre de tu archivo wav. Es sensible a las mayúsculas, así que las debes escribir exáctamente.

Vamos a agregar algunas entradas y otro archivo wav. Agrega el siguiente código a tu code.py.

"""THIS EXAMPLE REQUIRES A WAV FILE FROM THE examples FOLDER IN THE
Adafruit_CircuitPython_CircuitPlayground REPO found at:
https://github.com/adafruit/Adafruit_CircuitPython_CircuitPlayground/tree/master/examples

Copy the "dip.wav" and "rise.wav" files to your CIRCUITPY drive.

Once the files are copied, this example plays a different wav file for each button pressed!"""
from adafruit_circuitplayground import cp

while True:
    if cp.button_a:
        cp.play_file("dip.wav")
    if cp.button_b:
        cp.play_file("rise.wav")

Ahora presiona el botón A. ¡Dip! Presiona el botón B. ¡Rise!

Dentro del ciclo, revisamos si (if) cada botón está siendo presionado. Si el botón A está siendo presionado, tocamos "dip.wav". Si el botón B es el presionado, tocamos "rise.wav".

Nótese que cuando presionas el botón B e inmediatamente tratas de presionar el botón A, el archivo rise.wav completa antes de que puedas hacer un dip de nuevo. Esto es porque no puedes comenzar a tocar un archivo hasta que el primero haya completado. Así que si tienes un archivo muy largo, vas a ver que no puedes hacer nada más hasta que el archivo haya finalizado de tocar. Ten eso en mente cuando vas a incluir archivos en tu código.

Puedes utilizar cualquiera de las entradas que hemos discutido, para dispara el tocar un archivo. Trata de reemplazar las presiones de botón por las entradas táctiles. ¡Trata de agregar diferentes archivos a usar!

Si tu código está corriendo pero tu archivo no suena bien o no toca del todo, asegúrate de revisar la codificación del archivo, siguiendo esta guía de Adafruit.

Esta característica de la Librería Circuit Playground está solo disponible en la Circuit Playground Bluefruit.

La Circuit Playground Bluefruit tiene un sensor de sonido situado al lado derecho de la tarjeta, encima de un símbolo de oreja impreso en la tarjeta, y debajo del botón B. Este sensor puede ser utilizado para detectar niveles de sonido.

Mientras que la Circuit Playground Express tiene un sensor de sonido, esta característica de la Librería Circuit Playground no está disponible en la Express. La Express y la Bluefruit tienen chips de microcontroladora diferentes. En la SAM21 de la Express no es capaz de manejar las funcionalidades de sonido de la Librería Circuit Playground.

Agregue el siguiente código a su code.py. Recuerde que si necesita ayuda, puede revisar aquí.

"""
This example prints out sound levels using the sound sensor on a Circuit Playground Bluefruit.
Try making sounds towards the board to see the values change.

NOTE: This example does NOT support Circuit Playground Express.
"""
import time
from adafruit_circuitplayground import cp

while True:
    print("Sound level:", cp.sound_level)
    time.sleep(0.1)

Abra la consola serial para ver como se imprimen los niveles de sonido. ¡Trate de hacerle sonidos a su Circuit Playground para ver los valores cambiar!

Vamos a observar el código. Primero, vamos a importa a time y a cp.

Dentro de nuestro ciclo, imprimimos hacia la consola serial Sound level: seguido del valor del nivel de sonido, cp.sound_level. Luego tenemos un time.sleep(0.1) para dar una pausa a la velocidad con que se imprime en la consola serial. Si va muy rápido, ¡es difícil de leer!

Grafiando el Nivel de Sonido

¡Vamos a observar estos valores en el trazador gráfico de Mu! Agregue el siguiente código en su code.py:

"""
This example prints out sound levels using the sound sensor on a Circuit Playground Bluefruit. If
you are using Mu, open the plotter to see the sound level plotted. Try making sounds towards the
board to see the values change.

NOTE: This example does NOT support Circuit Playground Express.
"""
import time
from adafruit_circuitplayground import cp

while True:
    print("Sound level:", cp.sound_level)
    print((cp.sound_level,))
    time.sleep(0.1)

Este código es casi idéntico, pero hemos agregado otra línea print((cp.sound_level,)).

Nótese que el trazador gráfico de Mu espera valores de tipo tupla para graficar. Las tuplas en Python vienen en paréntesis () y separados por coma. Si tienes dos valores en una tupla se vería así (1.0, 3.14). Ya que solo tenemos un valor, lo vamos a imprimir como  (1.0,) - note los paréntesis alrededor del número, así como una coma luego del número. Por eso los paréntesis extra y la coma en print((cp.sound_level,)).

Haga click en el botón de Plotter en la parte superior de Mu para ver el trazador gráfico. Ahora trate de hacer sonidos hacia la tarjeta para ver como la línea del trazador sube. Trate de quedarse muy cayado para ver como la línea baja. ¡Diviértase!

Sonidos Fuertes

¿Y que pasa si quieres usar el sonido como una entrada? ¡Con la característica de loud_sound() puedes lograrlo! Puedes usarlo para detectar aplausos, chasquitos o cualquier otro sonido lo suficientemente fuente, como una entrada.

El siguiente ejemplo prende los LEDs tipo NeoPixel cuando un sonido bastante fuerte ocurre. Agregue el siguiente código a su code.py:

"""
This example lights up the NeoPixels on a Circuit Playground Bluefruit in response to a loud sound.
Try snapping or clapping near the board to trigger the LEDs.

NOTE: This example does NOT support Circuit Playground Express.
"""
import time
from adafruit_circuitplayground import cp

while True:
    if cp.loud_sound():
        cp.pixels.fill((50, 0, 50))
        time.sleep(0.2)
    else:
        cp.pixels.fill((0, 0, 0))

Trata de aplaudirle, hacerle charquidos o gritarle a tu tarjeta. ¡NeoPixeles morados!

Vamos a ver el código. Lo primero es importar a time y a cp.

Dentro de nuestro ciclo, comenzamos preguntando si un sonido fuerte ocurre con if cp.loud_sound(), prenda los NeoPixeles con un morado muy ténue con cp.pixels.fill((50, 0, 50)). Luego le agregamos un time.sleep(0.2) para que los LEDs se puedan quedar prendidos lo suficiente para poderlos verlos. Sin eso, solamente estarían prendidos por un instante.

Luego decimos que de otro modo, apague los pixeles al configurarlos con el color (0, 0, 0). Sin esto, los pixeles se prenden y se quedan prendidos.

Umbral de Sonidos Fuertes

Si encuentras muy fácil o muy difícil que se dispare un sonido fuerte, puedes bajar o aumentar el umbral. loud_sound() tiene una configuración por omisión de sound_threshold=200. Para hacerlo más difícil de disparar, puedes aumentar el umbral. Agrega el siguiente código a tu code.py:

"""
This example lights up the NeoPixels on a Circuit Playground Bluefruit in response to a loud sound.
Try snapping or clapping near the board to trigger the LEDs.

NOTE: This example does NOT support Circuit Playground Express.
"""
import time
from adafruit_circuitplayground import cp

while True:
    if cp.loud_sound(sound_threshold=250):
        cp.pixels.fill((50, 0, 50))
        time.sleep(0.2)
    else:
        cp.pixels.fill((0, 0, 0))

El código es exáctamente el mismo, excepto que hemos aumentado el umbral al configurar sound_threshold=250, haciendo que sea requerido un sonido un poco más fuerte para lograr dispararlo.

Si encuentras que es muy difícil de disparar, puedes bajar el umbral, haciendo que un sonido más delicado lo pueda disparar. Trata de configurarlo ensound_threshold=150 para ver la diferencia.

Ahora puedes usar sonido como una entrada en la Circuit Playground Bluefruit. ¡Trata de combinarlo con otros conceptos que hemos aprendido en esta guía par probar que otras cosas puedes hacer!

Ahora que tienes ejemplos de como todo funciona, ¡es hora de ponerse creativo! Trata combinando diferentes conceptos para crear un proyecto completo. Puedes crear algo como una cerradura con combinación de toque capacitivo o una luz de lectura. ¡Las posibilidades son infinitas!

Las siguientes guías van a funcionar con la Circuit Playground Express. Aunque puede que usen formas diferentes de programar y de importar, igual van a funcionar con la versión actual de la Librería Circuit Playground para la Circuit Playground Express.

Si eres nuevo a programación, y buscas una maneera sencilla de comenzar con tu Circuit Playground Express y con CircuitPython, lo importate de saber es que esta librería provee exáctamente eso. Sin embargo, si deseas una explicación con más profundidad de como hace eso, con esto cubrimos tus necesidades. Esta sección entra en algunos concepto algo técnicos así que no te preocupes si no sigues de cerca todo. Hemos incluido esto para aclarar preguntas que usuarios más avanzados puedan tener sobre como funciona la librería por detrás del telón.

Existen múltiples capas de como esta librería funciona. La siguiente explicación es para la Librería Circuit Playground.

Note: Esta librería trabaja con la Circuit Playground Express y con la Circuit Playground Bluefruit, NOT para la Circuit Playground Classic. Cualquier referencia en esta explicación a "Circuit Playground" se refiere solo a las Express y Bluefruit.

Esta sección no está pensada para principiantes. Incluye una explicación muy técnica de como la Librería Circuit Playground trabaja. Asume que ya tienes un poco de conocimiento sobre CircuitPython, su código y como trabajan los módulos.

Módulos de Librería Circuit Playground

La librería está dividida en múltiples módulos. El módulo circuit_playground_base define una clase base llamada CircuitPlaygroundBase, la cual incluye características de la librería que están disponibles para ambas tarjetas Circuit Playground, tales como red_led, button_a, etc. El módulo de express define una clase Express, la cual es una subclase de CircuitPlaygroundBase, la cual agrega características solo disponibles en la Circuit Playground Express como son los aliases para touch.A7 hasta touch.TX (solo la CPX tiene la etiqueta A7 en el séptimo pad). El módulo bluefruit define de forma similar una clase Bluefruit, la cual agrega características disponibles solo para la Circuit Playground Bluefruit, tales como sound_level y loud_sound. Las clases de Express y de Bluefruit heredan características de la clase CircuitPlaygroundBase así que cuando cualquiera de los módulos específicos a la tarjeta sean importados, todas las características de la base y específicas a la tarjeta van a estar disponibles.

Dentro de los módulos, todas las librerías de CircuitPython necesarias son importadas. Toda la inicialización de software y de hardware se realiza en __init__() dentro del módulo, tales como inicializar el acelerómetro o creando variables que luego se van a utilizar. Luego utilizamos métodos y propiedades para exponer las características para usar en tu código.

Uso de Librería Circuit Playground

Para usar la librería, usted incluye from adafruit_circuitplayground import cp al principio de su programa. Lo primero que hace la librería es utilizar  sys.platform para determinar si la tarjeta conectada tiene una microcontroladora Atmel SAMD21 o una nRF52840. Este código está contenido dentro del archivo __init__.py, y se ejecuta al importar, antes que cualquier otro código. Basado en los resultados, importa la librería apropiada, ya sea la express o la bluefruit. Así que digamos que estás corriendo la Circuit Playground Bluefruit, todas las características de bluefruit van a ser importadas. El mecanismo de importa permite que el mismo pedazo de código funcione en todas las tarjetas Circuit Playground. Esta es la esencia de __init__.py:

Download: file
import sys
if sys.platform == 'nRF52840':
    from .bluefruit import cpb as cp
elif sys.platform == 'Atmel SAMD21':
    from .express import cpx as cp

Una vez importada, todas las características de la tarjeta conectada van a estar disponibles para usar como cp.nombre_característica. Por ejemplo, para hablarle al pequeño LED rojo, usted utilizaría cp.red_led en tu programa.

Esta librería es algo inusual en que no debes crear un objeto primario usted mismo. En cambio, el objeto es creado al importar. Cuando usted realiza un from adafruit_circuitplayground import cp, estás importando el objeto cp el cual ya ha sido creado y se le ha asignado el nombre de cp. Usted no utiliza de forma directa las clases de Express o de Bluefruit.

Esta librería fue escrita originalmente solo para la Circuit Playground Express. Anteriormente, usted hubiera podido importar from adafruit_circuitplayground.express import cpx. cpx es el nombre para el objeto clase Express que es creado dentro del módulo express.py. Cuando le agregamos a la librería capacidades para la Circuit Playground Bluefruit, hicimos que el módulo bluefruit.py cree un objeto llamado cpb, análogo a cpx. Sin embargo, nos dimos cuenta que para que el código funcionara en ambas tarjetas, iba a ser necesario cambiar todas las referencias de  cpb por cpx o vice versa. Para aliviar esto, hemos agregado __init__.py, el cual, según describimos arriba, descubre en cual tarjeta está corriendo el código, e importa ya sea cpx o cpb, renombrándolo a simplemente cp

Librería Circuit Playground vs. CircuitPython Básico

Sin esta librería, cada funcionalidad de la tarjeta requeriría configuración individual en tu código, pudiendo ser de un cambio a varias líneas adicionales en tu código. Considera los siguientes ejemplos.

El primer ejemplo prende el LED rojo sin utilizar la Librería Circuit Playground.

Download: file
import digitalio
import board

led = digitalio.DigitalInOut(board.D13)
led.direction = digitalio.Direction.OUTPUT

led.value = True

Este segundo ejemplo prende el LED rojo utilizando la Librería Circuit Playground:

Download: file
from adafruit_circuitplayground import cp

cp.red_led = True

En lugar de incluir la configuración en el programa, la Librería Circuit Playground incluye toda la configuración en __init__() dentro del módulo, por lo que la configuración se realiza automáticamente cuando importas la librería. Este es un ejemplo sencillo para comparación; algún hardware requiere considerablemente más configuración que el LED rojo.

La Librería en una Circuit Playground Express

La Librería Circuit Playground siempre ha empujado las barreras en cuanto a límites de memoria se refiere en la Circuit Playground Express. Esto nos hizo que incluyéramos la Librería Circuit Python y todas sus dependencias en la versión de CircuitPython que se prepara para la Circuit Playground Express, como módulos congelados.

Los módulos congelados son librerías que están "congelados" o  integrados en CircuitPython. El congelar un módulo dentro de CircuitPython mueve la ejecución hacia el flash para ahorrar RAM. Normalmente cuando un módulo es importado, lo siguiente sucede:

  • Si es un archivo .py, es compilado en "byte codes", que se colocan en RAM y se ejecutan ahí
  • Si es un archivo .mpy, ya se encuentra compilado hacia "byte codes" los cuales se ponen en RAM

Ambas de estas opciones utilizan RAM disponible. Este módulo es lo suficientemente complejo que rápidamente se quedó corta la memoria RAM de la Circuit Playground Express. Por lo que congelamos el archivo .mpy dentro de CircuitPython. Un .mpy congelado ya se encuentra compilado en byte codes como cualquier otro archivo .mpy, pero los byte codes ya están disponibles en memoria que se puede accesar directamente (flash), así que no deben ser copiados en RAM. Esto ahorra algo de RAM.

Dicho de otra forma, nos permite correr un módulo que normalmente se quedaría sin memoria a la hora de importar y te causaría un fallo al solicitar memoria. Esto también significa que para usar la librería con la Circuit Playground Express, solamente necesitas instalar CircuitPython ya que la librería y todas sus dependencias están incluidas en su versión de CircuitPython.

Normalmente, usted carga módulos de librerías a su microcontroladora y las pone en la carpeta lib. Sin embargo, según explicamos, este módulo no va a funcionar si está corriendo como una copia local. El módulo express utiliza sys.path al importar para especificar de donde se debe jalar el módulo de la librería. El va a preferir módulos congelados a los que se encuentran en la carpeta /lib para asegurarse de que si un usuario instala una librería local en la carpeta /lib, todavía va a seguir usando el módulo congelado. Sin embargo, también revisa el directorio raíz primero. En orden, primero revisa la raíz, luego revisa los congelados y luego la carpeta /lib. Este orden se definió para asegurarse que puedas cargar librerías de forma local para probarlas si necesidad de modificar la librería. Si deseas probar modificaciones a uno de los módulos congelados en CircuitPython para la Circuit Playground Express, coloque esa librería en su directorio raíz, y va a utilizar esta versión.

 

Errores al Solicitar Memoria en la Circuit Playground Express

Puede que te pase con grandes cantidades de código o con proyectos un poco más complicados que usan dispositivos externos, que tu código falla en correr y recibes un error de MemoryError en la consola serial. La Librería Circuit Playground incluye todos los imports y configuración necesaria para usar la funcionalidad que provee. Esto significa que tiene una huella de memoria relativamente grande. La Circuit Playground Express tiene su memoria disponible limitada. Esta librería se diseñó para hacer sencillo el comenzar con una Circuit Playground y todas las cosas divertidas que trae integradas. Si la tratas de utilizar con una cantidad significativa de código o con muchas otras librerías, es posible que encuentres que se te acaba la memoria de la tarjeta. Si esto sucede en cualquiera de estos escenarios, es posible que ya estás listo para utilizar las librerías individuales necesarias para el hardware que estás tratando de usar en tu código. Esto significa que usarías el CircuitPython básico para manualmente inicializar todo el hardware que deseas utilizar, en lugar de depender de la Librería Circuit Python. Esto te permite inicializar solo el hardware que vas a utilizar en tu proyecto, versus a la Librería CircuitPython inicializando todas las características disponibles en la CPX.

This guide was first published on Jul 28, 2020. It was last updated on Jul 28, 2020.