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!

This guide was first published on Jul 28, 2020. It was last updated on Jul 28, 2020.
This page (Luz) was last updated on Sep 10, 2020.