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!

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

This page (Aceleración) was last updated on Oct 06, 2020.