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

Author: cogliano

BLE_CPB_Color_Picker/ble_color_picker.py

@@ -0,0 +1,27 @@
+# CircuitPython NeoPixel Color Picker Example
+
+import board
+import neopixel
+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
+
+ble = BLERadio()
+uart_service = UARTService()
+advertisement = ProvideServicesAdvertisement(uart_service)
+
+pixels = neopixel.NeoPixel(board.NEOPIXEL, 10, brightness=0.1)
+
+while True:
+    # Advertise when not connected.
+    ble.start_advertising(advertisement)
+    while not ble.connected:
+        pass
+
+    while ble.connected:
+        packet = Packet.from_stream(uart_service)
+        if isinstance(packet, ColorPacket):
+            print(packet.color)
+            pixels.fill(packet.color)

Bluetooth_Luminaries/code.py

@@ -0,0 +1,162 @@
+""" FancyLED Palette and Color Picker Control with BlueFruit App
+    Code by Phil Burgess, Dan Halbert & Erin St Blaine for Adafruit Industries
+"""
+import board
+import neopixel
+import touchio
+import adafruit_fancyled.adafruit_fancyled as fancy
+# from adafruit_ble.uart import UARTServer
+# for >= CPy 5.0.0
+from adafruit_ble.uart_server import UARTServer
+from adafruit_bluefruit_connect.packet import Packet
+from adafruit_bluefruit_connect.button_packet import ButtonPacket
+from adafruit_bluefruit_connect.color_packet import ColorPacket
+
+NUM_LEDS = 24             # change to reflect your total number of ring LEDs
+RING_PIN = board.A1       # change to reflect your wiring
+CPX_PIN = board.D8        # CPX Neopixels live on pin D8
+
+touch_A2 = touchio.TouchIn(board.A2)
+touch_A3 = touchio.TouchIn(board.A3)
+touch_A4 = touchio.TouchIn(board.A4)
+touch_A5 = touchio.TouchIn(board.A5)
+touch_A6 = touchio.TouchIn(board.A6)
+touch_TX = touchio.TouchIn(board.TX)
+
+# Palettes can have any number of elements in various formats
+# check https://learn.adafruit.com/fancyled-library-for-circuitpython/colors
+# for more info
+# Declare a 6-element RGB rainbow palette
+PALETTE_RAINBOW = [fancy.CRGB(1.0, 0.0, 0.0),  # Red
+                   fancy.CRGB(0.5, 0.3, 0.0),  # Orange
+                   fancy.CRGB(0.5, 0.5, 0.0),  # Yellow
+                   fancy.CRGB(0.3, 0.7, 0.0),  # Yellow Green
+                   fancy.CRGB(0.0, 1.0, 0.0),  # Green
+                   fancy.CRGB(0.0, 0.7, 0.3),  # Teal
+                   fancy.CRGB(0.0, 0.5, 0.5),  # Cyan
+                   fancy.CRGB(0.0, 0.3, 0.7),  # Blue
+                   fancy.CRGB(0.0, 0.0, 1.0),  # Blue
+                   fancy.CRGB(0.5, 0.0, 0.5),  # Magenta
+                   fancy.CRGB(0.7, 0.0, 0.3)]  # Purple
+
+# Reading Lamp mode - Warm Yellow
+PALETTE_BRIGHT = [fancy.CRGB(255, 183, 55)]
+
+# Black Only palette for "off" mode
+PALETTE_DARK = [fancy.CRGB(0, 0, 0)]
+
+# Declare a FIRE palette
+PALETTE_FIRE = [fancy.CRGB(160, 30, 0),  # Reds and Yellows
+                fancy.CRGB(27, 65, 0),
+                fancy.CRGB(0, 0, 0),
+                fancy.CRGB(224, 122, 0),
+                fancy.CRGB(0, 0, 0),
+                fancy.CRGB(250, 80, 0),
+                fancy.CRGB(0, 0, 0),
+                fancy.CRGB(0, 0, 0),
+                fancy.CRGB(200, 40, 0)]
+
+# Declare a NeoPixel object on NEOPIXEL_PIN with NUM_LEDS pixels,
+# no auto-write.
+# Set brightness to max because we'll be using FancyLED's brightness control.
+ring = neopixel.NeoPixel(RING_PIN, NUM_LEDS, brightness=1.0, auto_write=False)
+cpx = neopixel.NeoPixel(CPX_PIN, NUM_LEDS, brightness=1.0, auto_write=False)
+
+offset = 0  # Positional offset into color palette to get it to 'spin'
+offset_increment = 6
+OFFSET_MAX = 1000000
+
+uart_server = UARTServer()
+
+def set_palette(palette):
+    for i in range(NUM_LEDS):
+        # Load each pixel's color from the palette using an offset, run it
+        # through the gamma function, pack RGB value and assign to pixel.
+        color = fancy.palette_lookup(palette, (offset + i) / NUM_LEDS)
+        color = fancy.gamma_adjust(color, brightness=1.0)
+        ring[i] = color.pack()
+    ring.show()
+
+    for i in range(NUM_LEDS):
+        # Load each pixel's color from the palette using an offset, run it
+        # through the gamma function, pack RGB value and assign to pixel.
+        color = fancy.palette_lookup(palette, (offset + i) / NUM_LEDS)
+        color = fancy.gamma_adjust(color, brightness=1.0)
+        cpx[i] = color.pack()
+    cpx.show()
+
+# set initial palette to run on startup
+palette_choice = PALETTE_FIRE
+
+# True if cycling a palette
+cycling = True
+
+# Are we already advertising?
+advertising = False
+
+
+while True:
+
+    if cycling:
+        set_palette(palette_choice)
+        offset = (offset + offset_increment) % OFFSET_MAX
+
+    if not uart_server.connected and not advertising:
+        uart_server.start_advertising()
+        advertising = True
+
+    # Are we connected via Bluetooth now?
+    if uart_server.connected:
+        # Once we're connected, we're not advertising any more.
+        advertising = False
+        # Have we started to receive a packet?
+        if uart_server.in_waiting:
+            packet = Packet.from_stream(uart_server)
+            if isinstance(packet, ColorPacket):
+                cycling = False
+                # Set all the pixels to one color and stay there.
+                ring.fill(packet.color)
+                cpx.fill(packet.color)
+                ring.show()
+                cpx.show()
+            elif isinstance(packet, ButtonPacket):
+                cycling = True
+                if packet.pressed:
+                    if packet.button == ButtonPacket.BUTTON_1:
+                        palette_choice = PALETTE_DARK
+                    elif packet.button == ButtonPacket.BUTTON_2:
+                        palette_choice = PALETTE_BRIGHT
+                    elif packet.button == ButtonPacket.BUTTON_3:
+                        palette_choice = PALETTE_FIRE
+                        offset_increment = 6
+                    elif packet.button == ButtonPacket.BUTTON_4:
+                        palette_choice = PALETTE_RAINBOW
+                        offset_increment = 1
+
+                # change the speed of the animation by incrementing offset
+                    elif packet.button == ButtonPacket.UP:
+                        offset_increment += 1
+                    elif packet.button == ButtonPacket.DOWN:
+                        offset_increment -= 1
+
+    # Whether or not we're connected via Bluetooth,
+    # we also want to handle touch inputs.
+    if touch_A2.value:
+        cycling = True
+        palette_choice = PALETTE_DARK
+    elif touch_A3.value:
+        cycling = True
+        palette_choice = PALETTE_BRIGHT
+    elif touch_A4.value:
+        cycling = True
+        palette_choice = PALETTE_FIRE
+        offset_increment = 6
+    elif touch_A5.value:
+        cycling = True
+        palette_choice = PALETTE_RAINBOW
+        offset_increment = 1
+    # Also check for touch speed control
+#    if touch_A6.value:
+#        offset_increment += 1
+#    if touch_TX.value:
+#        offset_increment -= 1

CPX_Walking_Stick/README.md

@@ -0,0 +1,20 @@
+## The Musical Walking Stick tutorial on the Adafruit Learning System
+
+The code in this repo accompanies the Adafruit tutorial
+Musical Walking Stick
+https://learn.adafruit.com/musical-cane/
+
+The *appropriate code file file should be copied onto the **CIRCUITPY** flash drive as **code.py** that appears 
+when you plug the CircuitPlayground Express into your computer via a known good USB cable. 
+
+If the only drive name you get is named **CPLAYBOOT**, CircuitPython may not be loaded 
+on the board. You can load CircuitPython [per this guide](https://learn.adafruit.com/adafruit-circuit-playground-express/circuitpython-quickstart). Then you should be able to see the **CIRCUITPY** drive when connected via USB.
+
+CircuitPython resources may be found at https://CircuitPython.Org/
+
+Learning Guide by Dano Wall
+Code written by Dano Wall and Anne Barela for Adafruit Industries, November 2019
+
+MIT License, include all this text in any redistribution
+
+Support Open Source development by buying your materials at [Adafruit.com](https://www.adafruit.com/).

CPX_Walking_Stick/code.py

@@ -0,0 +1,33 @@
+# Talking Cane
+# for Adafruit Circuit Playground Express with CircuitPython
+from adafruit_circuitplayground.express import cpx
+
+# Change this number to adjust touch sensitivity threshold
+cpx.adjust_touch_threshold(600)
+# Set the tap type: 1=single, 2=double
+cpx.detect_taps = 1
+
+# NeoPixel colors used
+RED = (90, 0, 0)
+BLACK = (0, 0, 0)
+
+cpx.pixels.brightness = 0.1  # set brightness value
+
+# The audio file assigned to the touchpad
+audio_file = "imperial_march.wav"
+
+def play_it():
+    cpx.pixels.fill(RED)  # Light neopixels
+    cpx.play_file(audio_file)  # play audio clip
+    print("playing file ", audio_file)
+    cpx.pixels.fill(BLACK)  # unlight lights
+
+while True:
+    # playback mode. Use the slide switch to change between
+    #   trigger via touch or via single tap
+    if cpx.switch:
+        if cpx.touch_A1:
+            play_it()
+    else:
+        if cpx.tapped:
+            play_it()

CircuitPython_Flying_Toasters/code.py

@@ -44,12 +44,11 @@
 ANIMATED = [_sprite >= FIRST_CELL and _sprite <= LAST_CELL for _sprite in range(NUMBER_OF_SPRITES)]
 
 
-# The chance (out of 10) that a new toaster, or toast will enter
-CHANCE_OF_NEW_TOASTER = 5
+# The chance (out of 10) that toast will enter
 CHANCE_OF_NEW_TOAST = 2
 
 # How many sprites to styart with
-INITIAL_NUMBER_OF_SPRITES= 5
+INITIAL_NUMBER_OF_SPRITES = 4
 
 # Global variables
 display = None
@@ -66,25 +65,22 @@ def make_display():
         pass
     spi.configure(baudrate=24000000) # Configure SPI for 24MHz
     spi.unlock()
-    tft_cs = board.D10
-    tft_dc = board.D7
-
     displayio.release_displays()
-    display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs, reset=board.D9)
+    display_bus = displayio.FourWire(spi, command=board.D7, chip_select=board.D10, reset=board.D9)
 
     return ST7789(display_bus, width=240, height=240, rowstart=80, auto_refresh=True)
 
 def make_tilegrid():
     """Construct and return the tilegrid."""
     group = displayio.Group(max_size=10)
 
-    sprite_sheet, palette = adafruit_imageload.load("/spritesheet.bmp",
+    sprite_sheet, palette = adafruit_imageload.load("/spritesheet-2x.bmp",
                                                     bitmap=displayio.Bitmap,
                                                     palette=displayio.Palette)
     grid = displayio.TileGrid(sprite_sheet, pixel_shader=palette,
-                              width=9, height=9,
-                              tile_height=32, tile_width=32,
-                              x=0, y=-32,
+                              width=5, height=5,
+                              tile_height=64, tile_width=64,
+                              x=0, y=-64,
                               default_tile=EMPTY)
     group.append(grid)
     display.show(group)
@@ -104,8 +100,8 @@ def seed_toasters(number_of_toasters):
     """Create the initial toasters so it doesn't start empty"""
     for _ in range(number_of_toasters):
         while True:
-            row = randint(0, 8)
-            col = randint(0, 8)
+            row = randint(0, 4)
+            col = randint(0, 4)
             if evaluate_position(row, col):
                 break
         tilegrid[col, row] = random_cell()
@@ -117,7 +113,7 @@ def next_sprite(sprite):
 
 def advance_animation():
     """Cycle through animation cells each time."""
-    for tile_number in range(81):
+    for tile_number in range(25):
         tilegrid[tile_number] = next_sprite(tilegrid[tile_number])
 
 def slide_tiles():
@@ -127,43 +123,39 @@ def slide_tiles():
 
 def shift_tiles():
     """Move tiles one spot to the left, and reset the tilegrid's position"""
-    for row in range(8, 0, -1):
-        for col in range(8):
+    for row in range(4, 0, -1):
+        for col in range(4):
             tilegrid[col, row] = tilegrid[col + 1, row - 1]
-        tilegrid[8, row] = EMPTY
-    for col in range(9):
+        tilegrid[4, row] = EMPTY
+    for col in range(5):
         tilegrid[col, 0] = EMPTY
     tilegrid.x = 0
-    tilegrid.y = -32
+    tilegrid.y = -64
 
 def get_entry_row():
     while True:
-        row = randint(0, 8)
-        if tilegrid[8, row] == EMPTY and tilegrid[7, row] == EMPTY:
+        row = randint(0, 4)
+        if tilegrid[4, row] == EMPTY and tilegrid[3, row] == EMPTY:
             return row
 
 def get_entry_column():
     while True:
-        col = randint(0, 8)
+        col = randint(0, 3)
         if tilegrid[col, 0] == EMPTY and tilegrid[col, 1] == EMPTY:
             return col
 
 def add_toaster_or_toast():
     """Maybe add a new toaster or toast on the right and/or top at a randon open location"""
     if randint(1, 10) <= CHANCE_OF_NEW_TOAST:
         tile = TOAST
-    elif randint(1, 10) <= CHANCE_OF_NEW_TOASTER:
-        tile = random_cell()
     else:
-        tile = EMPTY
-    tilegrid[8, get_entry_row()] = tile
+        tile = random_cell()
+    tilegrid[4, get_entry_row()] = tile
 
     if randint(1, 10) <= CHANCE_OF_NEW_TOAST:
         tile = TOAST
-    elif randint(1, 8) <= CHANCE_OF_NEW_TOASTER:
-        tile = random_cell()
     else:
-        tile = EMPTY
+        tile = random_cell()
     tilegrid[get_entry_column(), 0] = tile
 
 display = make_display()
@@ -172,7 +164,7 @@ def add_toaster_or_toast():
 display.refresh()
 
 while True:
-    for _ in range(32):
+    for _ in range(64):
         display.refresh(target_frames_per_second=80)
         advance_animation()
         slide_tiles()