Merge branch 'master' into aqi-node-guide

Author: brentru

Gemma_Firewalker_AnimLite/.gemma_m0.test.only

@@ -0,0 +1,8 @@
+{\rtf1\ansi\ansicpg1252\cocoartf2511
+\cocoatextscaling0\cocoaplatform0{\fonttbl\f0\fswiss\fcharset0 Helvetica;}
+{\colortbl;\red255\green255\blue255;}
+{\*\expandedcolortbl;;}
+\margl1440\margr1440\vieww10800\viewh8400\viewkind0
+\pard\tx720\tx1440\tx2160\tx2880\tx3600\tx4320\tx5040\tx5760\tx6480\tx7200\tx7920\tx8640\pardirnatural\partightenfactor0
+
+\f0\fs24 \cf0  }

Gemma_Firewalker_AnimLite/Gemma_Firewalker_AnimLite.ino

@@ -0,0 +1,168 @@
+// 'Firewalker' LED sneakers sketch for Adafruit NeoPixels by Phillip Burgess
+
+#include <Adafruit_NeoPixel.h>
+
+const uint8_t gamma1[] PROGMEM = { // Gamma correction table for LED brightness
+    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  1,  1,
+    1,  1,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,
+    2,  3,  3,  3,  3,  3,  3,  3,  4,  4,  4,  4,  4,  5,  5,  5,
+    5,  6,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  9,  9,  9, 10,
+   10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 16, 16,
+   17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 24, 24, 25,
+   25, 26, 27, 27, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 35, 36,
+   37, 38, 39, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 50,
+   51, 52, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 66, 67, 68,
+   69, 70, 72, 73, 74, 75, 77, 78, 79, 81, 82, 83, 85, 86, 87, 89,
+   90, 92, 93, 95, 96, 98, 99,101,102,104,105,107,109,110,112,114,
+  115,117,119,120,122,124,126,127,129,131,133,135,137,138,140,142,
+  144,146,148,150,152,154,156,158,160,162,164,167,169,171,173,175,
+  177,180,182,184,186,189,191,193,196,198,200,203,205,208,210,213,
+  215,218,220,223,225,228,231,233,236,239,241,244,247,249,252,255 };
+
+// LEDs go around the full perimeter of the shoe sole, but the step animation
+// is mirrored on both the inside and outside faces, while the strip doesn't
+// necessarily start and end at the heel or toe.  These constants help configure
+// the strip and shoe sizes, and the positions of the front- and rear-most LEDs.
+// Becky's shoes: 39 LEDs total, 20 LEDs long, LED #5 at back.
+// Phil's shoes: 43 LEDs total, 22 LEDs long, LED #6 at back.
+#define N_LEDS        39 // TOTAL number of LEDs in strip
+#define SHOE_LEN_LEDS 20 // Number of LEDs down ONE SIDE of shoe
+#define SHOE_LED_BACK  5 // Index of REAR-MOST LED on shoe
+#define STEP_PIN      A2 // Analog input for footstep
+#define LED_PIN       A0 // NeoPixel strip is connected here
+#define MAXSTEPS       3 // Process (up to) this many concurrent steps
+
+Adafruit_NeoPixel strip = Adafruit_NeoPixel(N_LEDS, LED_PIN, NEO_GRB + NEO_KHZ800);
+
+// The readings from the sensors are usually around 250-350 when not being pressed,
+// then dip below 100 when the heel is standing on it (for Phil's shoes; Becky's
+// don't dip quite as low because she's smaller).
+#define STEP_TRIGGER    150  // Reading must be below this to trigger step
+#define STEP_HYSTERESIS 200  // After trigger, must return to this level
+
+int
+  stepMag[MAXSTEPS],  // Magnitude of steps
+  stepX[MAXSTEPS],    // Position of 'step wave' along strip
+  mag[SHOE_LEN_LEDS], // Brightness buffer (one side of shoe)
+  stepFiltered,       // Current filtered pressure reading
+  stepCount,          // Number of 'frames' current step has lasted
+  stepMin;            // Minimum reading during current step
+uint8_t
+  stepNum = 0,        // Current step number in stepMag/stepX tables
+  dup[SHOE_LEN_LEDS]; // Inside/outside copy indexes
+boolean
+  stepping  = false;  // If set, step was triggered, waiting to release
+
+
+void setup() {
+  pinMode(9, INPUT_PULLUP); // Set internal pullup resistor for sensor pin
+  // As previously mentioned, the step animation is mirrored on the inside and
+  // outside faces of the shoe.  To avoid a bunch of math and offsets later, the
+  // 'dup' array indicates where each pixel on the outside face of the shoe should
+  // be copied on the inside.  (255 = don't copy, as on front- or rear-most LEDs).
+  // Later, the colors for the outside face of the shoe are calculated and then get
+  // copied to the appropriate positions on the inside face.
+  memset(dup, 255, sizeof(dup));
+  int8_t a, b;
+  for(a=1              , b=SHOE_LED_BACK-1            ; b>=0    ;) dup[a++] = b--;
+  for(a=SHOE_LEN_LEDS-2, b=SHOE_LED_BACK+SHOE_LEN_LEDS; b<N_LEDS;) dup[a--] = b++;
+
+  // Clear step magnitude and position buffers
+  memset(stepMag, 0, sizeof(stepMag));
+  memset(stepX  , 0, sizeof(stepX));
+  strip.begin();
+  stepFiltered = analogRead(STEP_PIN); // Initial input
+}
+
+void loop() {
+  uint8_t i, j;
+
+  // Read analog input, with a little noise filtering
+  //stepFiltered = ((stepFiltered * 3) + analogRead(STEP_PIN)) >> 2;
+    stepFiltered = (((stepFiltered * 3) - 100) + analogRead(STEP_PIN)) >> 2;
+    
+  // The strip doesn't simply display the current pressure reading.  Instead,
+  // there's a bit of an animated flourish from heel to toe.  This takes time,
+  // and during quick foot-tapping there could be multiple step animations
+  // 'in flight,' so a short list is kept.
+  if(stepping) { // If a step was previously triggered...
+    if(stepFiltered >= STEP_HYSTERESIS) { // Has step let up?
+      stepping = false;                   // Yep! Stop monitoring.
+      // Add new step to the step list (may be multiple in flight)
+      stepMag[stepNum] = (STEP_HYSTERESIS - stepMin) * 6; // Step intensity
+      stepX[stepNum]   = -80; // Position starts behind heel, moves forward
+      if(++stepNum >= MAXSTEPS) stepNum = 0; // If many, overwrite oldest
+    } else if(stepFiltered < stepMin) stepMin = stepFiltered; // Track min val
+  } else if(stepFiltered < STEP_TRIGGER) { // No step yet; watch for trigger
+    stepping = true;         // Got one!
+    stepMin  = stepFiltered; // Note initial value
+  }
+
+  // Render a 'brightness map' for all steps in flight.  It's like
+  // a grayscale image; there's no color yet, just intensities.
+  int mx1, px1, px2, m;
+  memset(mag, 0, sizeof(mag));    // Clear magnitude buffer
+  for(i=0; i<MAXSTEPS; i++) {     // For each step...
+    if(stepMag[i] <= 0) continue; // Skip if inactive
+    for(j=0; j<SHOE_LEN_LEDS; j++) { // For each LED...
+      // Each step has sort of a 'wave' that's part of the animation,
+      // moving from heel to toe.  The wave position has sub-pixel
+      // resolution (4X), and is up to 80 units (20 pixels) long.
+      mx1 = (j << 2) - stepX[i]; // Position of LED along wave
+      if((mx1 <= 0) || (mx1 >= 80)) continue; // Out of range
+      if(mx1 > 64) { // Rising edge of wave; ramp up fast (4 px)
+        m = ((long)stepMag[i] * (long)(80 - mx1)) >> 4;
+      } else { // Falling edge of wave; fade slow (16 px)
+        m = ((long)stepMag[i] * (long)mx1) >> 6;
+      }
+      mag[j] += m; // Add magnitude to buffered sum
+    }
+    stepX[i]++; // Update position of step wave
+    if(stepX[i] >= (80 + (SHOE_LEN_LEDS << 2)))
+      stepMag[i] = 0; // Off end; disable step wave
+    else
+      stepMag[i] = ((long)stepMag[i] * 127L) >> 7; // Fade
+  }
+
+  // For a little visual interest, some 'sparkle' is added.
+  // The cumulative step magnitude is added to one pixel at random.
+  long sum = 0;
+  for(i=0; i<MAXSTEPS; i++) sum += stepMag[i];
+  if(sum > 0) {
+    i = random(SHOE_LEN_LEDS);
+    mag[i] += sum / 4;
+  }
+
+  // Now the grayscale magnitude buffer is remapped to color for the LEDs.
+  // The code below uses a blackbody palette, which fades from white to yellow
+  // to red to black.  The goal here was specifically a "walking on fire"
+  // aesthetic, so the usual ostentatious rainbow of hues seen in most LED
+  // projects is purposefully skipped in favor of a more plain effect.
+  uint8_t r, g, b;
+  int     level;
+  for(i=0; i<SHOE_LEN_LEDS; i++) { // For each LED on one side...
+    level = mag[i];                // Pixel magnitude (brightness)
+    if(level < 255) {              // 0-254 = black to red-1
+      r = pgm_read_byte(&gamma1[level]);
+      g = b = 0;
+    } else if(level < 510) {       // 255-509 = red to yellow-1
+      r = 255;
+      g = pgm_read_byte(&gamma1[level - 255]);
+      b = 0;
+    } else if(level < 765) {       // 510-764 = yellow to white-1
+      r = g = 255;
+      b = pgm_read_byte(&gamma1[level - 510]);
+    } else {                       // 765+ = white
+      r = g = b = 255;
+    }
+    // Set R/G/B color along outside of shoe
+    strip.setPixelColor(i+SHOE_LED_BACK, r, g, b);
+    // Pixels along inside are funny...
+    j = dup[i];
+    if(j < 255) strip.setPixelColor(j, r, g, b);
+  }
+
+  strip.show();
+  delayMicroseconds(1500);
+}

IoT_Party_Parrot/code.py

@@ -0,0 +1,104 @@
+import time
+import board
+import displayio
+from adafruit_matrixportal.matrixportal import MatrixPortal
+from adafruit_matrixportal.matrix import Matrix
+import adafruit_imageload
+
+# 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
+
+print("Party Parrot Twitter Matrix")
+
+#  import your bearer token
+bear = secrets['bearer_token']
+
+#  query URL for tweets. looking for hashtag partyparrot sent to a specific username
+DATA_SOURCE = ('https://api.twitter.com/2/tweets/search/recent?query=#partyparrot to:blitzcitydiy')
+#  json data path to get most recent tweet's ID number
+DATA_LOCATION = ["meta", "newest_id"]
+
+#  create MatrixPortal object to grab data/connect to internet
+matrixportal = MatrixPortal(
+    url=DATA_SOURCE,
+    json_path=DATA_LOCATION,
+    status_neopixel=board.NEOPIXEL
+)
+
+#  create matrix display
+matrix = Matrix(width=32, height=32)
+display = matrix.display
+
+group = displayio.Group(max_size=20)
+
+#  load in party parrot bitmap
+parrot_bit, parrot_pal = adafruit_imageload.load("/partyParrotsTweet.bmp",
+                                                 bitmap=displayio.Bitmap,
+                                                 palette=displayio.Palette)
+
+parrot_grid = displayio.TileGrid(parrot_bit, pixel_shader=parrot_pal,
+                                 width=1, height=1,
+                                 tile_height=32, tile_width=32,
+                                 default_tile=10,
+                                 x=0, y=0)
+
+group.append(parrot_grid)
+
+display.show(group)
+
+#  add bearer token as a header to request
+matrixportal.set_headers({'Authorization': 'Bearer ' + bear})
+
+last_value = 0 #  checks last tweet's ID
+check = 0 #  time.monotonic() holder
+parrot = False #  state to track if an animation is currently running
+party = 0 #  time.monotonic() holder
+p = 0 #  index for tilegrid
+party_count = 0 #  count for animation cycles
+
+while True:
+    #  every 30 seconds...
+    if (check + 30) < time.monotonic():
+        #  store most recent tweet's ID number in value
+        value = matrixportal.fetch()
+        print("Response is", value)
+        #  reset time count
+        check = time.monotonic()
+        #  compare last tweet ID and current tweet ID
+        if last_value != value:
+            print("new party!")
+            #  if it's new, then it's a party!
+            last_value = value
+            parrot = True
+        else:
+            #  if it's not new, then the wait continues
+            print("no new party... :(")
+    #  when a new tweet comes in...
+    if parrot:
+        #  every 0.1 seconds...
+        if (party + 0.1) < time.monotonic():
+            #  the party parrot animation cycles
+            parrot_grid[0] = p
+            #  p is the tilegrid index location
+            p += 1
+            party = time.monotonic()
+            #  if an animation cycle ends
+            if p > 9:
+                #  index is reset
+                p = 0
+                #  animation cycle count is updated
+                party_count += 1
+                print("party parrot", party_count)
+            #  after 16 animations cycles...
+            if party_count > 15:
+                #  reset states
+                parrot = False
+                party_count = 0
+                p = 0
+                #  clear the matrix so that it's blank
+                parrot_grid[0] = 10
+                print("the party is over")

IoT_Party_Parrot/partyParrotsTweet.bmp

@@ -0,0 +1,11 @@
+# This file is where you keep secret settings, passwords, and tokens!
+# If you put them in the code you risk committing that info or sharing it
+
+secrets = {
+    'ssid' : 'insert your network name here',
+    'password' : 'insert your network password here',
+    'timezone' : "America/New_York", # http://worldtimeapi.org/timezones
+    'twitter_api_key' : 'insert your twitter api key here',
+    'twitter_secret_key' : 'insert your twitter secret key here',
+    'bearer_token' : 'insert your bearer token here'
+    }

IoT_Party_Parrot/secrets.py

@@ -0,0 +1,54 @@
+import time
+import imageio
+from skimage.color import rgb2gray
+import matplotlib.pyplot as plt
+import numpy as np
+
+THRESH = 0.3
+
+RUN = int(input('Enter run number: '))
+
+vid = imageio.get_reader('run_{:03d}.mp4'.format(RUN), 'ffmpeg')
+
+#----------------
+# MAIN PROCESSING
+#----------------
+frame_data = []
+start = time.monotonic()
+# go through video frame by frame
+print("Processing", end='')
+for frame in vid:
+    print('.', end='', flush=True)
+    frame_bin = rgb2gray(frame) > THRESH
+    frame_count = np.count_nonzero(frame_bin == True)
+    frame_percent = 100 * frame_count / (1920*1080)
+    frame_data.append((frame_count, frame_percent))
+# overall stats
+avg_count = sum([x[0] for x in frame_data]) / len(frame_data)
+avg_percent = 100 * avg_count / (1920*1080)
+
+end = time.monotonic()
+print("\nProcessing done in {} secs.".format(end - start))
+print("Average Count = {}".format(avg_count))
+print("Average Percent = {}".format(avg_percent))
+
+#-------------
+# SAVE TO FILE
+#-------------
+print("Saving data to file...")
+with open('run_{:03d}.csv'.format(RUN), 'w') as fp:
+    for frame, data in enumerate(frame_data):
+        fp.write('{},{},{}\n'.format(frame, data[0], data[1]))
+
+#---------
+# PLOTTING
+#---------
+print("Generating plots...")
+fig, ax = plt.subplots(1, figsize = (10,5))
+ax.set_title("RUN {:03d}\nTHRESH = {}, AVG_CNT = {:4.2}, AVG_PER = {:.3}".format(RUN, THRESH,avg_count, avg_percent))
+ax.set_xlabel("FRAME")
+ax.set_ylabel("COUNT")
+ax.plot([x[0] for x in frame_data])
+fig.savefig('run_{:03d}_plot.png'.format(RUN))
+
+print("DONE.")

Mask_Efficacy/process_run.py

@@ -0,0 +1,40 @@
+import time
+import math
+import os
+import RPi.GPIO as GPIO
+import simpleaudio as sa
+import picamera
+
+camera = picamera.PiCamera()
+camera.resolution = (1920, 1080)
+VIDEO_LENGTH = 10
+
+BUTTON = 4
+GPIO.setmode(GPIO.BCM)
+GPIO.setup(BUTTON, GPIO.IN, pull_up_down=GPIO.PUD_UP)
+
+SIN_LENGTH = 500
+SIN_AMPLITUDE = 127
+SIN_OFFSET = 128
+DELTA_PI = 2 * math.pi / SIN_LENGTH
+sine_wave = bytes([
+     int(SIN_OFFSET + SIN_AMPLITUDE * math.sin(DELTA_PI * i)) for i in range(SIN_LENGTH)
+])
+
+def play_tone(length):
+    play_back = sa.play_buffer(sine_wave*length, 2, 2, 44100)
+    play_back.wait_done()
+
+run_number = int(input("Enter run number:"))
+
+print("Press button when ready.")
+while GPIO.input(BUTTON):
+    pass
+
+play_tone(100)
+camera.start_recording("run_{:03d}.h264".format(run_number))
+camera.wait_recording(VIDEO_LENGTH)
+camera.stop_recording()
+play_tone(100)
+
+err = os.system("MP4Box -add run_{0:03d}.h264 run_{0:03d}.mp4".format(run_number))