# Simple test¶

Ensure your device works with this simple test.

examples/circuitplayground_acceleration.py
 ``` 1 2 3 4 5 6 7 8 9 10 11 12``` ```""" 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) ```
examples/circuitplayground_pixels_simpletest.py
 ``` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32``` ```"""This example lights up the NeoPixels with a rainbow swirl.""" import time from adafruit_circuitplayground import cp def wheel(pos): # Input a value 0 to 255 to get a color value. # The colours are a transition r - g - b - back to r. if (pos < 0) or (pos > 255): return (0, 0, 0) if pos < 85: return (int(pos * 3), int(255 - (pos * 3)), 0) if pos < 170: pos -= 85 return (int(255 - pos * 3), 0, int(pos * 3)) pos -= 170 return (0, int(pos * 3), int(255 - pos * 3)) def rainbow_cycle(wait): for j in range(255): for i in range(cp.pixels.n): idx = int((i * 256 / len(cp.pixels)) + j) cp.pixels[i] = wheel(idx & 255) cp.pixels.show() time.sleep(wait) cp.pixels.auto_write = False cp.pixels.brightness = 0.3 while True: rainbow_cycle(0.001) # rainbowcycle with 1ms delay per step ```
examples/circuitplayground_shake.py
 ```1 2 3 4 5 6``` ```"""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!") ```
examples/circuitplayground_tapdetect_single_double.py
 ``` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26``` ```"""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 ```
examples/circuitplayground_tapdetect.py
 ``` 1 2 3 4 5 6 7 8 9 10 11``` ```"""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) ```
examples/circuitplayground_tone.py
 ``` 1 2 3 4 5 6 7 8 9 10``` ```"""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() ```
examples/circuitplayground_touched.py
 ``` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18``` ```"""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") ```
examples/circuitplayground_acceleration_neopixels.py
 ``` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20``` ```"""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))))) ```
examples/circuitplayground_button_a.py
 ```1 2 3 4 5 6 7``` ```"""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 ```
examples/circuitplayground_button_b.py
 ``` 1 2 3 4 5 6 7 8 9 10 11 12 13 14``` ```"""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 ```
examples/circuitplayground_buttons_1_neopixel.py
 ``` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17``` ```"""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 = (0, 255, 0) else: cp.pixels = (0, 0, 0) if cp.button_b: cp.pixels = (0, 0, 255) else: cp.pixels = (0, 0, 0) ```
examples/circuitplayground_buttons_neopixels.py
 ``` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17``` ```"""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 ```
 ``` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43``` ```"""THIS EXAMPLE REQUIRES A SEPARATE LIBRARY BE LOADED ONTO YOUR CIRCUITPY DRIVE. This example requires the adafruit_irremote.mpy library. THIS EXAMPLE WORKS WITH CIRCUIT PLAYGROUND EXPRESS ONLY. This example uses the IR receiver found near the center of the board. Works with another Circuit Playground Express running the circuitplayground_ir_transmit.py example. The NeoPixels will light up when the buttons on the TRANSMITTING Circuit Playground Express are pressed!""" import pulseio import board import adafruit_irremote from adafruit_circuitplayground import cp # Create a 'pulseio' input, to listen to infrared signals on the IR receiver try: pulsein = pulseio.PulseIn(board.IR_RX, maxlen=120, idle_state=True) except AttributeError: raise NotImplementedError( "This example does not work with Circuit Playground Bluefruti!" ) # Create a decoder that will take pulses and turn them into numbers decoder = adafruit_irremote.GenericDecode() while True: cp.red_led = True pulses = decoder.read_pulses(pulsein) try: # Attempt to convert received pulses into numbers received_code = decoder.decode_bits(pulses) except adafruit_irremote.IRNECRepeatException: # We got an unusual short code, probably a 'repeat' signal continue except adafruit_irremote.IRDecodeException: # Something got distorted continue print("Infrared code received: ", received_code) if received_code == [66, 84, 78, 65]: print("Button A signal") cp.pixels.fill((100, 0, 155)) if received_code == [66, 84, 78, 64]: print("Button B Signal") cp.pixels.fill((210, 45, 0)) ```
examples/circuitplayground_ir_transmit.py
 ``` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41``` ```"""THIS EXAMPLE REQUIRES A SEPARATE LIBRARY BE LOADED ONTO YOUR CIRCUITPY DRIVE. This example requires the adafruit_irremote.mpy library. THIS EXAMPLE WORKS WITH CIRCUIT PLAYGROUND EXPRESS ONLY. This example uses the IR transmitter found near the center of the board. Works with another Circuit Playground Express running the circuitplayground_ir_receive.py example. Press the buttons to light up the NeoPixels on the RECEIVING Circuit Playground Express!""" import time import pulseio import board import adafruit_irremote from adafruit_circuitplayground import cp # Create a 'pulseio' output, to send infrared signals from the IR transmitter try: pwm = pulseio.PWMOut(board.IR_TX, frequency=38000, duty_cycle=2 ** 15) except AttributeError: raise NotImplementedError( "This example does not work with Circuit Playground Bluefruit!" ) pulseout = pulseio.PulseOut(pwm) # pylint: disable=no-member # Create an encoder that will take numbers and turn them into NEC IR pulses encoder = adafruit_irremote.GenericTransmit( header=[9500, 4500], one=[550, 550], zero=[550, 1700], trail=0 ) while True: if cp.button_a: print("Button A pressed! \n") cp.red_led = True encoder.transmit(pulseout, [66, 84, 78, 65]) cp.red_led = False # wait so the receiver can get the full message time.sleep(0.2) if cp.button_b: print("Button B pressed! \n") cp.red_led = True encoder.transmit(pulseout, [66, 84, 78, 64]) cp.red_led = False time.sleep(0.2) ```
examples/circuitplayground_light_neopixels.py
 ``` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32``` ```""" 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) ```
examples/circuitplayground_light.py
 ```1 2 3 4 5 6 7 8 9``` ```"""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) ```
examples/circuitplayground_neopixel_0_1.py
 ```1 2 3 4 5 6 7 8``` ```"""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 = (255, 0, 0) cp.pixels = (0, 0, 255) ```
examples/circuitplayground_light_plotter.py
 ``` 1 2 3 4 5 6 7 8 9 10``` ```"""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) ```
examples/circuitplayground_play_file_buttons.py
 ``` 1 2 3 4 5 6 7 8 9 10 11 12 13 14``` ```"""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") ```
examples/circuitplayground_play_file.py
 ``` 1 2 3 4 5 6 7 8 9 10``` ```"""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") ```
examples/circuitplayground_play_tone_buttons.py
 ```1 2 3 4 5 6 7 8``` ```"""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) ```
examples/circuitplayground_play_tone.py
 ```1 2 3 4 5 6``` ```"""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) ```
 ``` 1 2 3 4 5 6 7 8 9 10``` ```"""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) ```
examples/circuitplayground_red_led_blnky_short.py
 ```1 2 3 4 5 6 7 8``` ```"""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) ```
examples/circuitplayground_red_led.py
 ```1 2 3 4 5``` ```"""This example turns on the little red LED.""" from adafruit_circuitplayground import cp while True: cp.red_led = True ```
examples/circuitplayground_slide_switch_red_led.py
 ``` 1 2 3 4 5 6 7 8 9 10 11``` ```"""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 ```
examples/circuitplayground_slide_switch_red_led_short.py
 ```1 2 3 4 5 6``` ```"""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 ```
examples/circuitplayground_slide_switch.py
 ```1 2 3 4 5 6 7 8``` ```"""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) ```
examples/circuitplayground_sound_meter.py
 ``` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66``` ```"""This example uses the sound sensor, located next to the picture of the ear on your board, to light up the NeoPixels as a sound meter. Try talking to your Circuit Playground or clapping, etc, to see the NeoPixels light up!""" import array import math import board import audiobusio from adafruit_circuitplayground import cp def constrain(value, floor, ceiling): return max(floor, min(value, ceiling)) def log_scale(input_value, input_min, input_max, output_min, output_max): normalized_input_value = (input_value - input_min) / (input_max - input_min) return output_min + math.pow(normalized_input_value, 0.630957) * ( output_max - output_min ) def normalized_rms(values): minbuf = int(sum(values) / len(values)) return math.sqrt( sum(float(sample - minbuf) * (sample - minbuf) for sample in values) / len(values) ) mic = audiobusio.PDMIn( board.MICROPHONE_CLOCK, board.MICROPHONE_DATA, sample_rate=16000, bit_depth=16 ) samples = array.array("H",  * 160) mic.record(samples, len(samples)) input_floor = normalized_rms(samples) + 10 # Lower number means more sensitive - more LEDs will light up with less sound. sensitivity = 500 input_ceiling = input_floor + sensitivity peak = 0 while True: mic.record(samples, len(samples)) magnitude = normalized_rms(samples) print((magnitude,)) c = log_scale( constrain(magnitude, input_floor, input_ceiling), input_floor, input_ceiling, 0, 10, ) cp.pixels.fill((0, 0, 0)) for i in range(10): if i < c: cp.pixels[i] = (i * (255 // 10), 50, 0) if c >= peak: peak = min(c, 10 - 1) elif peak > 0: peak = peak - 1 if peak > 0: cp.pixels[int(peak)] = (80, 0, 255) cp.pixels.show() ```
examples/circuitplayground_tap_red_led.py
 ``` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15``` ```"""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 ```
examples/circuitplayground_temperature_neopixels.py
 ``` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35``` ```""" 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) ```
examples/circuitplayground_temperature_plotter.py
 ``` 1 2 3 4 5 6 7 8 9 10 11``` ```"""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) ```
examples/circuitplayground_temperature.py
 ``` 1 2 3 4 5 6 7 8 9 10``` ```"""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) ```
examples/circuitplayground_touch_pixel_fill_rainbow.py
 ``` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31``` ```"""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) ```
examples/circuitplayground_touch_pixel_rainbow.py
 ``` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31``` ```"""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 = (255, 0, 0) if cp.touch_A2: print("Touched A2!") cp.pixels = (210, 45, 0) if cp.touch_A3: print("Touched A3!") cp.pixels = (155, 100, 0) if cp.touch_A4: print("Touched A4!") cp.pixels = (0, 255, 0) if cp.touch_A5: print("Touched A5!") cp.pixels = (0, 135, 125) if cp.touch_A6: print("Touched A6!") cp.pixels = (0, 0, 255) if cp.touch_TX: print("Touched TX!") cp.pixels = (100, 0, 155) time.sleep(0.1) ```