Add gas mask code

3D_Printed_NeoPixel_Gas_Mask/3D_Printed_NeoPixel_Gas_Mask.ino

@@ -0,0 +1,70 @@
+#include <Adafruit_NeoPixel.h>
+
+#define PIN       0
+#define NUM_LEDS 24
+
+Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUM_LEDS, PIN);
+
+uint8_t  mode   = 0,        // Current animation effect
+         offset = 0;        // Position of spinner animation
+uint32_t color  = 0xFF0000; // Starting color = red
+uint32_t prevTime;          // Time of last animation mode switch
+
+void setup() {
+  pixels.begin();
+  pixels.setBrightness(85); // 1/3 brightness
+  prevTime = millis();      // Starting time
+}
+
+void loop() {
+  uint8_t  i;
+  uint32_t t;
+
+  switch(mode) {
+
+   case 0: // Random sparkles - just one LED on at a time!
+    i = random(NUM_LEDS);           // Choose a random pixel
+    pixels.setPixelColor(i, color); // Set it to current color
+    pixels.show();                  // Refresh LED states
+    // Set same pixel to "off" color now but DON'T refresh...
+    // it stays on for now...both this and the next random
+    // pixel will be refreshed on the next pass.
+    pixels.setPixelColor(i, 0);
+    delay(10);                      // 10 millisecond delay
+    break;
+ 
+   case 1: // Spinny wheel
+    // A little trick here: pixels are processed in groups of 8
+    // (with 2 of 8 on at a time), NeoPixel rings are 24 pixels
+    // (8*3) and 16 pixels (8*2), so we can issue the same data
+    // to both rings and it appears correct and contiguous
+    // (also, the pixel order is different between the two ring
+    // types, so we get the reversed motion on #2 for free).
+    for(i=0; i<NUM_LEDS; i++) {    // For each LED...
+      uint32_t c = 0;              // Assume pixel will be "off" color
+      if(((offset + i) & 7) < 2) { // For each 8 pixels, 2 will be...
+        c = color;                 // ...assigned the current color
+      }
+      pixels.setPixelColor(i, c);  // Set color of pixel 'i'
+    }
+    pixels.show();                 // Refresh LED states
+    delay(50);                     // 50 millisecond delay
+    offset++;                      // Shift animation by 1 pixel on next frame
+    if(offset >= 8) offset = 0;    // Reset offset every 8 pixels
+    break;
+
+    // More animation modes could be added here!
+  }
+
+  t = millis();                    // Current time in milliseconds
+  if((t - prevTime) > 8000) {      // Every 8 seconds...
+    mode++;                        // Advance to next animation mode
+    if(mode > 1) {                 // End of modes?
+      mode = 0;                    // Start over from beginning
+      color >>= 8;                 // Next color R->G->B
+      if(!color) color = 0xFF0000; // Preiodically reset to red
+    }
+    pixels.clear();                // Set all pixels to 'off' state
+    prevTime = t;                  // Record the time of the last mode change
+  }
+}

3D_Printed_NeoPixel_Gas_Mask/3D_Printed_NeoPixel_Gas_Mask.py

@@ -0,0 +1,55 @@
+import board
+import neopixel
+import time
+try:
+	import urandom as random  # for v1.0 API support
+except ImportError:
+	import random
+
+numpix = 24        # Number of NeoPixels
+pixpin = board.D0  # Pin where NeoPixels are connected
+strip  = neopixel.NeoPixel(pixpin, numpix, brightness=0.3)
+
+mode     = 0  # Current animation effect
+offset   = 0  # Position of spinner animation
+color    = [255, 0, 0]       # RGB color - red
+prevtime = time.monotonic()  # Time of last animation mode switch
+
+while True:  # Loop forever...
+
+	if mode == 0:  # Random sparkles - lights just one LED at a time
+		i = random.randint(0, numpix - 1)  # Choose random pixel
+		strip[i] = color   # Set it to current color
+		strip.write()      # Refresh LED states
+		# Set same pixel to "off" color now but DON'T refresh...
+		# it stays on for now...bot this and the next random
+		# pixel will be refreshed on the next pass.
+		strip[i] = [0,0,0]
+		time.sleep(0.008)  # 8 millisecond delay
+	elif mode == 1:  # Spinny wheels
+		# A little trick here: pixels are processed in groups of 8
+		# (with 2 of 8 on at a time), NeoPixel rings are 24 pixels
+		# (8*3) and 16 pixels (8*2), so we can issue the same data
+		# to both rings and it appears correct and contiguous
+		# (also, the pixel order is different between the two ring
+		# types, so we get the reversed motion on #2 for free).
+		for i in range(numpix):  # For each LED...
+			if ((offset + i) & 7) < 2:  # 2 pixels out of 8...
+				strip[i] = color    # are set to current color
+			else:
+				strip[i] = [0,0,0]  # other pixels are off
+		strip.write()    # Refresh LED states
+		time.sleep(0.04) # 40 millisecond delay
+		offset += 1      # Shift animation by 1 pixel on next frame
+		if offset >= 8: offset = 0
+	# Additional animation modes could be added here!
+
+	t = time.monotonic()         # Current time in seconds
+	if (t - prevtime) >= 8:      # Every 8 seconds...
+		mode += 1            # Advance to next mode
+		if mode > 1:         # End of modes? 
+			mode  =  0   # Start over from beginning
+			# Rotate color R->G->B
+			color = [ color[2], color[0], color[1] ]
+		strip.fill([0,0,0])  # Turn off all pixels
+		prevtime = t         # Record time of last mode change