Merge branch 'master' of https://github.com/adafruit/Adafruit_Learning_System_Guides

Author: Kevin J Walters

.gitignore

@@ -3,3 +3,4 @@ Hue_Controller/secrets.h
 .idea
 *.DS_Store
 CircuitPython_Logger/secrets\.py
+.python-version

.travis.yml

@@ -15,7 +15,7 @@ cache:
 
 env:
   global:
-    - ARDUINO_IDE_VERSION="1.8.7"
+    - ARDUINO_IDE_VERSION="1.8.11"
     - PRETTYNAME="Adafruit Learning System Guides"
     - PLATFORM_CHECK_ONLY_ON_FILE=true
 

Adafruit_ESP32_Arduino_Demos/SerialESPPassthrough/Airlift-BitsyWing-FeatherWing-Passthru.UF2

@@ -0,0 +1,50 @@
+"""Sensor demo for Adafruit Feather Sense. Prints data from each of the sensors."""
+import time
+import array
+import math
+import board
+import audiobusio
+import adafruit_apds9960.apds9960
+import adafruit_bmp280
+import adafruit_lis3mdl
+import adafruit_lsm6ds
+import adafruit_sht31d
+
+i2c = board.I2C()
+
+apds9960 = adafruit_apds9960.apds9960.APDS9960(i2c)
+bmp280 = adafruit_bmp280.Adafruit_BMP280_I2C(i2c)
+lis3mdl = adafruit_lis3mdl.LIS3MDL(i2c)
+lsm6ds33 = adafruit_lsm6ds.LSM6DS33(i2c)
+sht31d = adafruit_sht31d.SHT31D(i2c)
+microphone = audiobusio.PDMIn(board.MICROPHONE_CLOCK, board.MICROPHONE_DATA,
+                              sample_rate=16000, bit_depth=16)
+
+def normalized_rms(values):
+    minbuf = int(sum(values) / len(values))
+    return int(math.sqrt(sum(float(sample - minbuf) *
+                             (sample - minbuf) for sample in values) / len(values)))
+
+apds9960.enable_proximity = True
+apds9960.enable_color = True
+
+# Set this to sea level pressure in hectoPascals at your location for accurate altitude reading.
+bmp280.sea_level_pressure = 1013.25
+
+while True:
+    samples = array.array('H', [0] * 160)
+    microphone.record(samples, len(samples))
+
+    print("\nFeather Sense Sensor Demo")
+    print("---------------------------------------------")
+    print("Proximity:", apds9960.proximity)
+    print("Red: {}, Green: {}, Blue: {}, Clear: {}".format(*apds9960.color_data))
+    print("Temperature: {:.1f} C".format(bmp280.temperature))
+    print("Barometric pressure:", bmp280.pressure)
+    print("Altitude: {:.1f} m".format(bmp280.altitude))
+    print("Magnetic: {:.3f} {:.3f} {:.3f} uTesla".format(*lis3mdl.magnetic))
+    print("Acceleration: {:.2f} {:.2f} {:.2f} m/s^2".format(*lsm6ds33.acceleration))
+    print("Gyro: {:.2f} {:.2f} {:.2f} dps".format(*lsm6ds33.gyro))
+    print("Humidity: {:.1f} %".format(sht31d.relative_humidity))
+    print("Sound level:", normalized_rms(samples))
+    time.sleep(0.3)

Adafruit_Feather_Sense/feather_sense_sensor_demo.py

@@ -0,0 +1,167 @@
+"""
+Heart Rate Trainer
+Read heart rate data from a heart rate peripheral using the standard BLE
+Heart Rate service.
+Displays BPM value to Seven Segment FeatherWing
+Displays percentage of max heart rate on another 7Seg FeatherWing
+"""
+
+import time
+import board
+
+import adafruit_ble
+from adafruit_ble.advertising.standard import ProvideServicesAdvertisement
+from adafruit_ble.services.standard.device_info import DeviceInfoService
+from adafruit_ble_heart_rate import HeartRateService
+
+from adafruit_ht16k33.segments import Seg7x4
+
+from digitalio import DigitalInOut, Direction
+
+# Feather on-board status LEDs setup
+red_led = DigitalInOut(board.RED_LED)
+red_led.direction = Direction.OUTPUT
+red_led.value = True
+
+blue_led = DigitalInOut(board.BLUE_LED)
+blue_led.direction = Direction.OUTPUT
+blue_led.value = False
+
+# target heart rate for interval training
+# Change this number depending on your max heart rate, usually figured
+# as (220 - your age).
+max_rate = 180
+
+# Seven Segment FeatherWing setup
+i2c = board.I2C()
+display_A = Seg7x4(i2c, address=0x70)  # this will be the BPM display
+display_A.fill(0)  # Clear the display
+# Second display has A0 address jumpered
+display_B = Seg7x4(i2c, address=0x71)  # this will be the % target display
+display_B.fill(0)  # Clear the display
+
+# display_A "b.P.M."
+display_A.set_digit_raw(0, 0b11111100)
+display_A.set_digit_raw(1, 0b11110011)
+display_A.set_digit_raw(2, 0b00110011)
+display_A.set_digit_raw(3, 0b10100111)
+# display_B "Prct"
+display_B.set_digit_raw(0, 0b01110011)
+display_B.set_digit_raw(1, 0b01010000)
+display_B.set_digit_raw(2, 0b01011000)
+display_B.set_digit_raw(3, 0b01000110)
+time.sleep(3)
+
+display_A.fill(0)
+for h in range(4):
+    display_A.set_digit_raw(h, 0b10000000)
+# display_B show maximum heart rate value
+display_B.fill(0)
+display_B.print(max_rate)
+time.sleep(2)
+
+# PyLint can't find BLERadio for some reason so special case it here.
+ble = adafruit_ble.BLERadio()    # pylint: disable=no-member
+
+hr_connection = None
+
+def display_SCAN():
+    display_A.fill(0)
+    display_A.set_digit_raw(0, 0b01101101)
+    display_A.set_digit_raw(1, 0b00111001)
+    display_A.set_digit_raw(2, 0b01110111)
+    display_A.set_digit_raw(3, 0b00110111)
+
+
+def display_bLE():
+    display_B.fill(0)
+    display_B.set_digit_raw(0, 0b00000000)
+    display_B.set_digit_raw(1, 0b01111100)
+    display_B.set_digit_raw(2, 0b00111000)
+    display_B.set_digit_raw(3, 0b01111001)
+
+def display_dots():  # "...."
+    for j in range(4):
+        display_A.set_digit_raw(j, 0b10000000)
+        display_B.set_digit_raw(j, 0b10000000)
+
+def display_dashes():  # "----"
+    for k in range(4):
+        display_A.set_digit_raw(k, 0b01000000)
+        display_B.set_digit_raw(k, 0b01000000)
+
+# Start with a fresh connection.
+if ble.connected:
+    display_SCAN()
+    display_bLE()
+    time.sleep(1)
+
+    for connection in ble.connections:
+        if HeartRateService in connection:
+            connection.disconnect()
+        break
+
+while True:
+    print("Scanning...")
+    red_led.value = True
+    blue_led.value = False
+    display_SCAN()
+    display_bLE()
+    time.sleep(1)
+
+
+    for adv in ble.start_scan(ProvideServicesAdvertisement, timeout=5):
+        if HeartRateService in adv.services:
+            print("found a HeartRateService advertisement")
+            hr_connection = ble.connect(adv)
+            display_dots()
+            time.sleep(2)
+            print("Connected")
+            blue_led.value = True
+            red_led.value = False
+            break
+
+    # Stop scanning whether or not we are connected.
+    ble.stop_scan()
+    print("Stopped scan")
+    red_led.value = False
+    blue_led.value = True
+    time.sleep(0.5)
+
+    if hr_connection and hr_connection.connected:
+        print("Fetch connection")
+        if DeviceInfoService in hr_connection:
+            dis = hr_connection[DeviceInfoService]
+            try:
+                manufacturer = dis.manufacturer
+            except AttributeError:
+                manufacturer = "(Manufacturer Not specified)"
+            try:
+                model_number = dis.model_number
+            except AttributeError:
+                model_number = "(Model number not specified)"
+            print("Device:", manufacturer, model_number)
+        else:
+            print("No device information")
+        hr_service = hr_connection[HeartRateService]
+        print("Location:", hr_service.location)
+
+        while hr_connection.connected:
+            values = hr_service.measurement_values
+            print(values)  # returns the full heart_rate data set
+            if values:
+                bpm = (values.heart_rate)
+                if bpm is not 0:
+                    pct_target = (round(100*(bpm/max_rate)))
+                display_A.fill(0)  # clear the display
+                display_B.fill(0)
+                if values.heart_rate is 0:
+                    display_dashes()
+                else:
+                    display_A.fill(0)
+                    display_B.print(pct_target)
+                    time.sleep(0.1)
+                    display_A.print(bpm)
+
+            time.sleep(0.9)
+            display_A.set_digit_raw(0, 0b00000000)

BLE_Heart_Rate_Trainer/ble_heart_rate_trainer.py

@@ -0,0 +1,20 @@
+"""This uses the CLUE as a Bluetooth LE sensor node."""
+
+import time
+from adafruit_clue import clue
+import adafruit_ble_broadcastnet
+
+print("This is BroadcastNet CLUE sensor:", adafruit_ble_broadcastnet.device_address)
+
+while True:
+    measurement = adafruit_ble_broadcastnet.AdafruitSensorMeasurement()
+
+    measurement.temperature = clue.temperature
+    measurement.pressure = clue.pressure
+    measurement.relative_humidity = clue.humidity
+    measurement.acceleration = clue.acceleration
+    measurement.magnetic = clue.magnetic
+
+    print(measurement)
+    adafruit_ble_broadcastnet.broadcast(measurement)
+    time.sleep(60)

BLE_Sensornet/clue_sensornet.py

@@ -0,0 +1,31 @@
+"""This uses the Feather Sense as a Bluetooth LE sensor node."""
+
+import time
+import adafruit_ble_broadcastnet
+import board
+import adafruit_lsm6ds   # accelerometer
+import adafruit_sht31d   # humidity sensor
+import adafruit_bmp280   # barometric sensor
+import adafruit_lis3mdl  # magnetic sensor
+
+i2c = board.I2C()
+
+sense_accel = adafruit_lsm6ds.LSM6DS33(i2c)
+sense_humid = adafruit_sht31d.SHT31D(i2c)
+sense_barometric = adafruit_bmp280.Adafruit_BMP280_I2C(i2c)
+sense_magnet = adafruit_lis3mdl.LIS3MDL(i2c)
+
+print("This is BroadcastNet Feather Sense sensor:", adafruit_ble_broadcastnet.device_address)
+
+while True:
+    measurement = adafruit_ble_broadcastnet.AdafruitSensorMeasurement()
+
+    measurement.temperature = sense_barometric.temperature
+    measurement.pressure = sense_barometric.pressure
+    measurement.relative_humidity = sense_humid.relative_humidity
+    measurement.acceleration = sense_accel.acceleration
+    measurement.magnetic = sense_magnet.magnetic
+
+    # print(measurement)
+    adafruit_ble_broadcastnet.broadcast(measurement)
+    time.sleep(60)

BLE_Sensornet/feather_sense_sensornet.py

@@ -0,0 +1,106 @@
+'''BLE Synth
+File for the Circuit Playground Bluefruit
+Amp Portion'''
+from adafruit_circuitplayground.bluefruit import cpb
+from adafruit_led_animation.animation import Comet, AnimationGroup,\
+    AnimationSequence
+import adafruit_led_animation.color as color
+from adafruit_ble import BLERadio
+from adafruit_ble.advertising.standard import ProvideServicesAdvertisement
+from adafruit_ble.services.nordic import UARTService
+from adafruit_bluefruit_connect.packet import Packet
+from adafruit_bluefruit_connect.color_packet import ColorPacket
+from adafruit_bluefruit_connect.button_packet import ButtonPacket
+
+#  easily call for NeoPixels to be off
+off = (0, 0, 0)
+#  state to debounce on CPB end
+tone = False
+
+# Setup for comet animation
+COMET_SPEED = 0.04  # Lower numbers increase the animation speed
+CPB_COMET_TAIL_LENGTH = 5  # The length of the comet on the Circuit Playground Bluefruit
+CPB_COMET_BOUNCE = False  # Set to True to make the comet "bounce" the opposite direction on CPB
+
+animations = AnimationSequence(
+    AnimationGroup(
+        Comet(cpb.pixels, COMET_SPEED, off, tail_length=CPB_COMET_TAIL_LENGTH,
+              bounce=CPB_COMET_BOUNCE)))
+
+#  note frequencies
+C4 = 261.63
+Csharp4 = 277.18
+D4 = 293.66
+Dsharp4 = 311.13
+E4 = 329.63
+F4 = 349.23
+Fsharp4 = 369.99
+G4 = 392
+Gsharp4 = 415.3
+A4 = 440
+Asharp4 = 466.16
+B4 = 493.88
+
+#  note array
+note = [C4, Csharp4, D4, Dsharp4, E4, F4,
+        Fsharp4, G4, Gsharp4, A4, Asharp4, B4]
+
+#  colors to recieve from color packet & for neopixels
+color_C = color.RED
+color_Csharp = color.ORANGE
+color_D = color.YELLOW
+color_Dsharp = color.GREEN
+color_E = color.TEAL
+color_F = color.CYAN
+color_Fsharp = color.BLUE
+color_G = color.PURPLE
+color_Gsharp = color.MAGENTA
+color_A = color.GOLD
+color_Asharp = color.PINK
+color_B = color.WHITE
+
+#  color array
+color = [color_C, color_Csharp, color_D, color_Dsharp, color_E,
+         color_F, color_Fsharp, color_G, color_Gsharp, color_A,
+         color_Asharp, color_B]
+
+# Setup BLE connection
+ble = BLERadio()
+uart = UARTService()
+advertisement = ProvideServicesAdvertisement(uart)
+
+while True:
+    #  connect via BLE
+    ble.start_advertising(advertisement)  # Start advertising.
+    was_connected = False
+    while not was_connected or ble.connected:
+        if ble.connected:  # If BLE is connected...
+            was_connected = True
+            #  start animations
+            animations.animate()
+            #  look for packets
+            if uart.in_waiting:
+                try:
+                    packet = Packet.from_stream(uart)  # Create the packet object.
+                except ValueError:
+                    continue
+                #  if it's a color packet:
+                if isinstance(packet, ColorPacket):
+                    for i in range(12):
+                        colors = color[i]
+                        notes = note[i]
+                        #  if the packet matches one of our colors:
+                        if packet.color == colors and not tone:
+                            #  animate with that color
+                            animations.color = colors
+                            #  play matching note
+                            cpb.start_tone(notes)
+                            tone = True
+                #  if it's a button packet aka feather's button has been released:
+                elif isinstance(packet, ButtonPacket) and packet.pressed:
+                    if packet.button == ButtonPacket.RIGHT and tone:
+                        tone = False
+                        #  stop playing the note
+                        cpb.stop_tone()
+                        #  turn off the neopixels but keep animation active
+                        animations.color = off