Merge https://github.com/adafruit/Adafruit_Learning_System_Guides into dashblock-api

update branch

Author: isaacwellish

CircuitPython_Flying_Toasters/code.py

@@ -0,0 +1,181 @@
+"""
+Continuously scroll randomly generated After Dark style toasters.
+Designed for an ItsyBitsy M4 Express and a 1.3" 240x240 TFT
+
+Adafruit invests time and resources providing this open source code.
+Please support Adafruit and open source hardware by purchasing
+products from Adafruit!
+
+Written by Dave Astels for Adafruit Industries
+Copyright (c) 2019 Adafruit Industries
+Licensed under the MIT license.
+
+All text above must be included in any redistribution.
+
+Requires CircuitPython 5.0 or later.
+"""
+
+import time
+from random import seed, randint
+import board
+import displayio
+from adafruit_st7789 import ST7789
+import adafruit_imageload
+
+
+# Sprite cell values
+EMPTY = 0
+CELL_1 = EMPTY + 1
+CELL_2 = CELL_1 + 1
+CELL_3 = CELL_2 + 1
+CELL_4 = CELL_3 + 1
+TOAST = CELL_4 + 1
+
+NUMBER_OF_SPRITES = TOAST + 1
+
+# Animation support
+
+FIRST_CELL = CELL_1
+LAST_CELL = CELL_4
+
+NUMBER_OF_CELLS = (LAST_CELL - FIRST_CELL) + 1
+
+# A boolean array corresponding to the sprites, True if it's part of the animation sequence.
+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
+CHANCE_OF_NEW_TOAST = 2
+
+# How many sprites to styart with
+INITIAL_NUMBER_OF_SPRITES= 5
+
+# Global variables
+display = None
+tilegrid = None
+
+seed(int(time.monotonic()))
+
+def make_display():
+    """Set up the display support.
+    Return the Display object.
+    """
+    spi = board.SPI()
+    while not spi.try_lock():
+        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)
+
+    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",
+                                                    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,
+                              default_tile=EMPTY)
+    group.append(grid)
+    display.show(group)
+    return grid
+
+def random_cell():
+    return randint(FIRST_CELL, LAST_CELL)
+
+def evaluate_position(row, col):
+    """Return whether how long of aa toaster is placable at the given location.
+    :param row: the tile row (0-9)
+    :param col: the tile column (0-9)
+    """
+    return tilegrid[col, row] == EMPTY
+
+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)
+            if evaluate_position(row, col):
+                break
+        tilegrid[col, row] = random_cell()
+
+def next_sprite(sprite):
+    if ANIMATED[sprite]:
+        return (((sprite - FIRST_CELL) + 1) % NUMBER_OF_CELLS) + FIRST_CELL
+    return sprite
+
+def advance_animation():
+    """Cycle through animation cells each time."""
+    for tile_number in range(81):
+        tilegrid[tile_number] = next_sprite(tilegrid[tile_number])
+
+def slide_tiles():
+    """Move the tilegrid one pixel to the bottom-left."""
+    tilegrid.x -= 1
+    tilegrid.y += 1
+
+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):
+            tilegrid[col, row] = tilegrid[col + 1, row - 1]
+        tilegrid[8, row] = EMPTY
+    for col in range(9):
+        tilegrid[col, 0] = EMPTY
+    tilegrid.x = 0
+    tilegrid.y = -32
+
+def get_entry_row():
+    while True:
+        row = randint(0, 8)
+        if tilegrid[8, row] == EMPTY and tilegrid[7, row] == EMPTY:
+            return row
+
+def get_entry_column():
+    while True:
+        col = randint(0, 8)
+        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
+
+    if randint(1, 10) <= CHANCE_OF_NEW_TOAST:
+        tile = TOAST
+    elif randint(1, 8) <= CHANCE_OF_NEW_TOASTER:
+        tile = random_cell()
+    else:
+        tile = EMPTY
+    tilegrid[get_entry_column(), 0] = tile
+
+display = make_display()
+tilegrid = make_tilegrid()
+seed_toasters(INITIAL_NUMBER_OF_SPRITES)
+display.refresh()
+
+while True:
+    for _ in range(32):
+        display.refresh(target_frames_per_second=80)
+        advance_animation()
+        slide_tiles()
+    shift_tiles()
+    add_toaster_or_toast()
+    display.refresh(target_frames_per_second=120)

CircuitPython_Flying_Toasters/spritesheet.bmp

@@ -1,14 +1,12 @@
-# CircuitPlaygroundExpress_AnalogIn
-# reads the analog voltage level from a 10k potentiometer
-# connected to GND, 3.3V, and pin A1
-# and prints the results to the REPL
+# Circuit Playground AnalogIn
+# Reads the analog voltage level from a 10k potentiometer connected to GND, 3.3V, and pin A1
+# and prints the results to the serial console.
 
 import time
-
 import board
-from analogio import AnalogIn
+import analogio
 
-analogin = AnalogIn(board.A1)
+analogin = analogio.AnalogIn(board.A1)
 
 
 def getVoltage(pin):  # helper

Introducing_CircuitPlaygroundExpress/CircuitPlaygroundExpress_AnalogIn.py

@@ -1,16 +1,14 @@
-# CircuitPlaygroundExpress_DigitalIO
+# Circuit Playground digitalio example
 
 import time
-
 import board
-from digitalio import DigitalInOut, Direction, Pull
+import digitalio
 
-led = DigitalInOut(board.D13)
-led.direction = Direction.OUTPUT
+led = digitalio.DigitalInOut(board.D13)
+led.switch_to_output()
 
-button = DigitalInOut(board.BUTTON_A)
-button.direction = Direction.INPUT
-button.pull = Pull.DOWN
+button = digitalio.DigitalInOut(board.BUTTON_A)
+button.switch_to_input(pull=digitalio.Pull.DOWN)
 
 while True:
     if button.value:  # button is pushed

Introducing_CircuitPlaygroundExpress/CircuitPlaygroundExpress_DigitalIO.py

@@ -162,11 +162,12 @@ void setup() {
   delay(20);
 #endif
 
-  uint8_t e;
+  uint8_t e, rtna = 0x01; // Screen refresh rate control (datasheet 9.2.18, FRCTRL2)
   // Initialize displays
   for(e=0; e<NUM_EYES; e++) {
     eye[e].display = new Adafruit_ST7789(eye[e].spi, eye[e].cs, eye[e].dc, eye[e].rst);
     eye[e].display->init(240, 240);
+    eye[e].display->sendCommand(0xC6, &rtna, 1);
     eye[e].spi->setClockSource(DISPLAY_CLKSRC);
     eye[e].display->fillScreen(0x1234);
     eye[e].display->setRotation(0);
@@ -510,24 +511,30 @@ void loop() {
         timeToNextBlink = blinkDuration * 3 + random(4000000);
       }
 
-      // Eyelids naturally "track" the pupils (move up or down automatically)
-      int ix = (int)map2screen(mapRadius - eye[eyeNum].eyeX) + 120, // Pupil position
-          iy = (int)map2screen(mapRadius - eye[eyeNum].eyeY) + 120; // on screen
-      iy += irisRadius / 2; // top edge of iris (ish) in screen pixels
       float uq, lq; // So many sloppy temp vars in here for now, sorry
-      if(eyeNum & 1) ix = 239 - ix; // Flip for right eye
-      if(iy > upperOpen[ix]) {
-        uq = 1.0;
-      } else if(iy < upperClosed[ix]) {
-        uq = 0.0;
-      } else {
-        uq = (float)(iy - upperClosed[ix]) / (float)(upperOpen[ix] - upperClosed[ix]);
-      }
-      if(booped) {
-        uq = 0.9;
-        lq = 0.7;
+      if(tracking) {
+        // Eyelids naturally "track" the pupils (move up or down automatically)
+        int ix = (int)map2screen(mapRadius - eye[eyeNum].eyeX) + 120, // Pupil position
+            iy = (int)map2screen(mapRadius - eye[eyeNum].eyeY) + 120; // on screen
+        iy += irisRadius * trackFactor;
+        if(eyeNum & 1) ix = 239 - ix; // Flip for right eye
+        if(iy > upperOpen[ix]) {
+          uq = 1.0;
+        } else if(iy < upperClosed[ix]) {
+          uq = 0.0;
+        } else {
+          uq = (float)(iy - upperClosed[ix]) / (float)(upperOpen[ix] - upperClosed[ix]);
+        }
+        if(booped) {
+          uq = 0.9;
+          lq = 0.7;
+        } else {
+          lq = 1.0 - uq;
+        }
       } else {
-        lq = 1.0 - uq;
+        // If no tracking, eye is FULLY OPEN when not blinking
+        uq = 1.0;
+        lq = 1.0;
       }
       // Dampen eyelid movements slightly
       // SAVE upper & lower lid factors per eye,

M4_Eyes/M4_Eyes.ino

@@ -266,6 +266,15 @@ void loadConfig(char *filename) {
       JsonVariant iristv       = doc["irisTexture"],
                   scleratv     = doc["scleraTexture"];
 
+      v = doc["tracking"];
+      if(v.is<bool>()) tracking = v.as<bool>();
+      v = doc["squint"];
+      if(v.is<float>()) {
+        trackFactor = 1.0 - v.as<float>();
+        if(trackFactor < 0.0)      trackFactor = 0.0;
+        else if(trackFactor > 1.0) trackFactor = 1.0;
+      }
+
       // Convert clockwise int (0-1023) or float (0.0-1.0) values to CCW int used internally:
       v = doc["irisSpin"];
       if(v.is<float>()) irisSpin   = v.as<float>() * -1024.0;

M4_Eyes/file.cpp

@@ -69,6 +69,8 @@ GLOBAL_VAR uint16_t  lightSensorMax      GLOBAL_INIT(1023);
 GLOBAL_VAR float     lightSensorCurve    GLOBAL_INIT(1.0);
 GLOBAL_VAR float     irisMin             GLOBAL_INIT(0.45);
 GLOBAL_VAR float     irisRange           GLOBAL_INIT(0.35);
+GLOBAL_VAR bool      tracking            GLOBAL_INIT(true);
+GLOBAL_VAR float     trackFactor         GLOBAL_INIT(0.5);
 
 // Pin definition stuff will go here
 

M4_Eyes/globals.h

@@ -0,0 +1,56 @@
+import time
+import board
+import busio
+from adafruit_ht16k33 import segments
+
+# Create the I2C interface.
+i2c = busio.I2C(board.SCL, board.SDA)
+
+# Create the LED segment class.
+# This creates a 14 segment 4 character display:
+display = segments.Seg14x4(i2c)
+
+# Clear the display.
+display.fill(0)
+
+# set brightness, range 1-15, 15 max brightness
+display.brightness = 15
+
+# show phrase on alphanumeric display
+message = "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG"
+count = 0
+
+# print one character at time with short sleep
+# creates smooth scrolling effect
+while count < len(message):
+    display.print(message[count])
+    count += 1
+    time.sleep(0.3)
+
+# Can just print a number
+display.print(42)
+time.sleep(1)
+
+# Set the first character to '1':
+display[0] = '1'
+# Set the second character to '2':
+display[1] = '2'
+# Set the third character to 'A':
+display[2] = 'A'
+# Set the forth character to 'B':
+display[3] = 'B'
+time.sleep(1)
+
+numbers = [0.0, 1.0, -1.0, 0.55, -0.55, 10.23, -10.2, 100.5, -100.5]
+
+# print negative and positive floating point numbers
+for i in numbers:
+    display.print(i)
+    time.sleep(0.5)
+
+# print hex values, enable colon
+for i in range(0xFF):
+    display.fill(0)
+    display.print(':')
+    display.print(hex(i))
+    time.sleep(0.25)