Merge branch 'rockpaperscissors' of https://github.com/kevinjwalters/Adafruit_Learning_System_Guides into rockpaperscissors

Author: Kevin J Walters

Astrophotography_Tracker/alignment_scope_adapter.stl

@@ -0,0 +1,222 @@
+# ON AIR sign for YouTube livestreaming
+# Runs on Airlift Metro M4 with 64x32 RGB Matrix display & shield
+
+import time
+import board
+import displayio
+import adafruit_display_text.label
+from adafruit_display_shapes.rect import Rect
+from adafruit_display_shapes.polygon import Polygon
+from adafruit_bitmap_font import bitmap_font
+from adafruit_matrixportal.network import Network
+from adafruit_matrixportal.matrix import Matrix
+
+# Get wifi details and more from a secrets.py file
+try:
+    from secrets import secrets
+except ImportError:
+    print("WiFi secrets are kept in secrets.py, please add them there!")
+    raise
+
+# Set up where we'll be fetching data from
+# Adafruit YouTube channel:
+CHANNEL_ID = (
+    "UCpOlOeQjj7EsVnDh3zuCgsA"  # this isn't a secret but you have to look it up
+)
+
+DATA_SOURCE = (
+    "https://www.googleapis.com/youtube/v3/search?part=snippet&channelId="
+    + CHANNEL_ID
+    + "&type=video&eventType=live&key="
+    + secrets["youtube_token"]
+)
+DATA_LOCATION1 = ["items"]
+
+# Number of seconds between checking, if this is too quick the query quota will run out
+UPDATE_DELAY = 300
+
+# Times are in 24-hour format for simplification
+OPERATING_TIME_START = "12:00"  # what hour to start checking
+OPERATING_TIME_END = "19:00"  # what hour to stop checking
+
+# --- Display setup ---
+matrix = Matrix()
+display = matrix.display
+network = Network(status_neopixel=board.NEOPIXEL, debug=False)
+
+# --- Drawing setup ---
+# Create a Group
+group = displayio.Group(max_size=22)
+# Create a bitmap object
+bitmap = displayio.Bitmap(64, 32, 2)  # width, height, bit depth
+# Create a color palette
+color = displayio.Palette(4)
+color[0] = 0x000000  # black
+color[1] = 0xFF0000  # red
+color[2] = 0x444444  # dim white
+color[3] = 0xDD8000  # gold
+# Create a TileGrid using the Bitmap and Palette
+tile_grid = displayio.TileGrid(bitmap, pixel_shader=color)
+# Add the TileGrid to the Group
+group.append(tile_grid)
+
+# draw the frame for startup
+rect1 = Rect(0, 0, 2, 32, fill=color[2])
+rect2 = Rect(62, 0, 2, 32, fill=color[2])
+rect3 = Rect(2, 0, 9, 2, fill=color[0])
+rect4 = Rect(53, 0, 9, 2, fill=color[0])
+rect5 = Rect(2, 30, 12, 2, fill=color[0])
+rect6 = Rect(50, 30, 12, 2, fill=color[0])
+
+group.append(rect1)
+group.append(rect2)
+group.append(rect3)
+group.append(rect4)
+group.append(rect5)
+group.append(rect6)
+
+
+def redraw_frame():  # to adjust spacing at bottom later
+    rect3.fill = color[2]
+    rect4.fill = color[2]
+    rect5.fill = color[2]
+    rect6.fill = color[2]
+
+
+# draw the wings w polygon shapes
+wing_polys = []
+
+wing_polys.append(Polygon([(3, 3), (9, 3), (9, 4), (4, 4)], outline=color[1]))
+wing_polys.append(Polygon([(5, 6), (9, 6), (9, 7), (6, 7)], outline=color[1]))
+wing_polys.append(Polygon([(7, 9), (9, 9), (9, 10), (8, 10)], outline=color[1]))
+wing_polys.append(Polygon([(54, 3), (60, 3), (59, 4), (54, 4)], outline=color[1]))
+wing_polys.append(Polygon([(54, 6), (58, 6), (57, 7), (54, 7)], outline=color[1]))
+wing_polys.append(Polygon([(54, 9), (56, 9), (55, 10), (54, 10)], outline=color[1]))
+
+for wing_poly in wing_polys:
+    group.append(wing_poly)
+
+
+def redraw_wings(index):  # to change colors
+    for wing in wing_polys:
+        wing.outline = color[index]
+
+
+# --- Content Setup ---
+deco_font = bitmap_font.load_font("/BellotaText-Bold-21.bdf")
+
+# Create two lines of text. Besides changing the text, you can also
+# customize the color and font (using Adafruit_CircuitPython_Bitmap_Font).
+
+# text positions
+on_x = 15
+on_y = 9
+off_x = 12
+off_y = 9
+air_x = 15
+air_y = 25
+
+
+text_line1 = adafruit_display_text.label.Label(
+    deco_font, color=color[3], text="OFF", max_glyphs=6
+)
+text_line1.x = off_x
+text_line1.y = off_y
+
+text_line2 = adafruit_display_text.label.Label(
+    deco_font, color=color[1], text="AIR", max_glyphs=6
+)
+text_line2.x = air_x
+text_line2.y = air_y
+
+# Put each line of text into the Group
+group.append(text_line1)
+group.append(text_line2)
+
+
+def startup_text():
+    text_line1.text = "ADA"
+    text_line1.x = 10
+    text_line1.color = color[2]
+    text_line2.text = "FRUIT"
+    text_line2.x = 2
+    text_line2.color = color[2]
+    redraw_wings(0)
+    display.show(group)
+
+
+startup_text()  # display the startup text
+
+
+def update_text(state):
+    if state:  # if switch is on, text is "ON" at startup
+        text_line1.text = "ON"
+        text_line1.x = on_x
+        text_line1.color = color[1]
+        text_line2.text = "AIR"
+        text_line2.x = air_x
+        text_line2.color = color[1]
+        redraw_wings(1)
+        redraw_frame()
+        display.show(group)
+    else:  # else, text if "OFF" at startup
+        text_line1.text = "OFF"
+        text_line1.x = off_x
+        text_line1.color = color[3]
+        text_line2.text = "AIR"
+        text_line2.x = air_x
+        text_line2.color = color[3]
+        redraw_wings(3)
+        redraw_frame()
+        display.show(group)
+
+
+def get_status():
+    """
+    Get the status whether we are on/off air within operating hours
+    If outside of hours, return False
+    """
+    # Get the time values we need
+    now = time.localtime()
+    start_hour, start_minute = OPERATING_TIME_START.split(":")
+    end_hour, end_minute = OPERATING_TIME_END.split(":")
+
+    # Convert time into a float for easy calculations
+    start_time = int(start_hour) + (int(start_minute) / 60)
+    end_time = int(end_hour) + (int(end_minute) / 60)
+    current_time = now[3] + (now[4] / 60)
+
+    if start_time <= current_time < end_time:
+        try:
+            on_air = network.fetch_data(DATA_SOURCE, json_path=(DATA_LOCATION1,))
+            if len(on_air) > 0:
+                return True
+        except RuntimeError:
+            return False
+
+    return False
+
+
+# Synchronize Board's clock to Internet
+network.get_local_time()
+mode_state = get_status()
+update_text(mode_state)
+last_check = None
+
+
+while True:
+    if last_check is None or time.monotonic() > last_check + UPDATE_DELAY:
+        try:
+            status = get_status()
+            if status:
+                if mode_state == 0:  # state has changed, toggle it
+                    update_text(1)
+                    mode_state = 1
+            else:
+                if mode_state == 1:
+                    update_text(0)
+                    mode_state = 0
+            print("On Air:", status)
+            last_check = time.monotonic()
+        except RuntimeError as e:
+            print("Some error occured, retrying! -", e)

Astrophotography_Tracker/astrophotography_mount.fzz

@@ -0,0 +1,13 @@
+# Ocean_Resin_Lightbox
+
+Code to accompany this tutorial:
+https://learn.adafruit.com/ocean-epoxy-resin-art-with-rgb-led-matrix-animations
+
+Ocean Epoxy Resin LightBox with RGB LED Matrix Animations
+Adafruit invests time and resources providing this open source code.
+Please support Adafruit and open source hardware by purchasing
+products from Adafruit!
+Written by Jeff Epler, Erin St Blaine & Limor Fried for Adafruit Industries
+Copyright (c) 2020 Adafruit Industries
+Licensed under the MIT license.
+All text above must be included in any redistribution.

Astrophotography_Tracker/fritzing_mount.png

@@ -0,0 +1,132 @@
+"""
+RGB Matrix Ocean Scroller
+Adafruit invests time and resources providing this open source code.
+Please support Adafruit and open source hardware by purchasing
+products from Adafruit!
+Written by Jeff Epler & Limor Fried for Adafruit Industries
+Copyright (c) 2019-2020 Adafruit Industries
+Licensed under the MIT license.
+All text above must be included in any redistribution.
+"""
+
+import math
+import time
+import random
+
+import adafruit_imageload.bmp
+import board
+import displayio
+import framebufferio
+import rgbmatrix
+import ulab
+
+displayio.release_displays()
+
+class Reshader:
+    '''reshader fades the image to mimic brightness control'''
+    def __init__(self, palette):
+        self.palette = palette
+        ulab_palette = ulab.zeros((len(palette), 3))
+        for i in range(len(palette)):
+            rgb = int(palette[i])
+            ulab_palette[i, 2] = rgb & 0xff
+            ulab_palette[i, 1] = (rgb >> 8) & 0xff
+            ulab_palette[i, 0] = rgb >> 16
+        self.ulab_palette = ulab_palette
+
+    def reshade(self, brightness):
+        '''reshader'''
+        palette = self.palette
+        shaded = ulab.array(self.ulab_palette * brightness, dtype=ulab.uint8)
+        for i in range(len(palette)):
+            palette[i] = tuple(shaded[i])
+
+def do_crawl_down(image_file, *,
+                  speed=12, weave=4, pulse=.5,
+                  weave_speed=1/6, pulse_speed=1/7):
+    # pylint:disable=too-many-locals
+    '''function to scroll the image'''
+    the_bitmap, the_palette = adafruit_imageload.load(
+        image_file,
+        bitmap=displayio.Bitmap,
+        palette=displayio.Palette)
+
+    shader = Reshader(the_palette)
+
+    group = displayio.Group()
+    tile_grid = displayio.TileGrid(bitmap=the_bitmap, pixel_shader=the_palette)
+    group.append(tile_grid)
+    display.show(group)
+
+    start_time = time.monotonic_ns()
+    start_y = display.height   # High enough to be "off the top"
+    end_y = -the_bitmap.height     # Low enough to be "off the bottom"
+
+    # Mix up how the bobs and brightness change on each run
+    r1 = random.random() * math.pi
+    r2 = random.random() * math.pi
+
+    y = start_y
+    while y > end_y:
+        now = time.monotonic_ns()
+        y = start_y - speed * ((now - start_time) / 1e9)
+        group.y = round(y)
+
+        # wave from side to side
+        group.x = round(weave * math.cos(y * weave_speed + r1))
+
+        # Change the brightness
+        if pulse > 0:
+            shader.reshade((1 - pulse) + pulse * math.sin(y * pulse_speed + r2))
+
+        display.refresh(minimum_frames_per_second=0, target_frames_per_second=60)
+
+def do_pulse(image_file, *, duration=4, pulse_speed=1/8, pulse=.5):
+    '''pulse animation'''
+    the_bitmap, the_palette = adafruit_imageload.load(
+        image_file,
+        bitmap=displayio.Bitmap,
+        palette=displayio.Palette)
+
+    shader = Reshader(the_palette)
+
+    group = displayio.Group()
+    tile_grid = displayio.TileGrid(bitmap=the_bitmap, pixel_shader=the_palette)
+    group.append(tile_grid)
+    group.x = (display.width - the_bitmap.width) // 2
+    group.y = (display.height - the_bitmap.height) // 2
+    display.show(group)
+
+    start_time = time.monotonic_ns()
+    end_time = start_time + int(duration * 1e9)
+
+    now_ns = time.monotonic_ns()
+    while now_ns < end_time:
+        now_ns = time.monotonic_ns()
+        current_time = (now_ns - start_time) / 1e9
+
+        shader.reshade((1 - pulse) - pulse
+                       * math.cos(2*math.pi*current_time*pulse_speed)**2)
+
+        display.refresh(minimum_frames_per_second=0, target_frames_per_second=60)
+
+matrix = rgbmatrix.RGBMatrix(
+    width=64, height=32, bit_depth=5,
+    rgb_pins=[board.D6, board.D5, board.D9, board.D11, board.D10, board.D12],
+    addr_pins=[board.A5, board.A4, board.A3, board.A2],
+    clock_pin=board.D13, latch_pin=board.D0, output_enable_pin=board.D1)
+display = framebufferio.FramebufferDisplay(matrix, auto_refresh=False)
+
+# Image playlist - set to run randomly. Set pulse from 0 to .5
+while True:
+    show_next = random.randint(1, 5) #change to reflect how many images you add
+    if show_next == 1:
+        do_crawl_down("/ray.bmp")
+    elif show_next == 2:
+        do_crawl_down("/waves1.bmp", speed=7, weave=0, pulse=.35)
+    elif show_next == 3:
+        do_crawl_down("/waves2.bmp", speed=9, weave=0, pulse=.35)
+    elif show_next == 4:
+        do_pulse("/heart.bmp", duration=4, pulse=.45)
+    elif show_next == 5:
+        do_crawl_down("/dark.bmp")