Merge branch 'adafruit:main' into bls_cpx_ir_data

Author: bradanlane

Drum_Track_Sequencer/code.py

@@ -0,0 +1,77 @@
+# SPDX-FileCopyrightText: 2024 John Park for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+"""
+Drum Track Sequencer
+ Feather RP2040, Motor FeatherWing, stepper motor,
+ four reflection sensors, USB MIDI out
+"""
+import asyncio
+import busio
+import board
+from adafruit_motorkit import MotorKit
+from adafruit_motor import stepper
+import keypad
+import usb_midi
+
+# Tempo setup
+BPM = 100  # user set value
+tempo_table = {  # motor speed seems non-linear, so we'll use a lookup table
+    110: 0.0004,
+    100: 0.001,
+    90: 0.002,
+    80: 0.003,
+    75: 0.004,
+    65: 0.005,
+    60: 0.006,
+    50: 0.008
+}
+def get_nearest_tempo(given_bpm):
+    nearest_table_item = min(tempo_table.keys(), key=lambda k: abs(k - given_bpm))
+    return tempo_table[nearest_table_item]
+motor_pause = get_nearest_tempo(BPM)
+
+i2c=busio.I2C(board.SCL, board.SDA, frequency=400_000)
+
+# Motor setup
+kit = MotorKit(i2c=i2c)
+motor_run=True
+
+# Sensor setup
+optical_pins = (board.D6, board.D9, board.D10, board.D12)
+optical_sensors = keypad.Keys(optical_pins, value_when_pressed=False, pull=True)
+
+# MIDI setup
+midi = usb_midi.ports[1]
+midi_notes = (36, 37, 38, 39)  # typical drum voice notes
+
+def play_drum(note):
+    midi_msg_on = bytearray([0x99, note, 120])  # 0x90 noteOn ch1, 0x99 noteOn ch10
+    midi_msg_off = bytearray([0x89, note, 0])
+    midi.write(midi_msg_on)
+    midi.write(midi_msg_off)
+
+async def check_sensors():
+    while True:
+        optical_sensor = optical_sensors.events.get()
+        if optical_sensor:
+            if optical_sensor.pressed:
+                track_num = optical_sensor.key_number
+                # print("tripped", track_num)
+                play_drum(midi_notes[track_num])
+        await asyncio.sleep(0.008)  # don't check sensors constantly or motor speed reduced
+
+async def run_motor():
+    while True:
+        kit.stepper1.onestep(
+                                direction=stepper.BACKWARD,
+                                style=stepper.DOUBLE
+        )
+        await asyncio.sleep(motor_pause)  # motor speed-- smaller numbers are faster
+
+async def main():
+    motor_task = asyncio.create_task(run_motor())
+    sensor_task = asyncio.create_task(check_sensors())
+    await asyncio.gather(motor_task, sensor_task)
+
+asyncio.run(main())

Dune_Thumper/code.py

@@ -0,0 +1,59 @@
+# SPDX-FileCopyrightText: 2023 Liz Clark for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+
+import time
+import board
+import audiocore
+import audiobusio
+import audiomixer
+import pwmio
+from digitalio import DigitalInOut, Direction
+from adafruit_ticks import ticks_ms, ticks_add, ticks_diff
+from adafruit_motor import servo
+import adafruit_lis3dh
+
+time.sleep(2)
+
+# enable external power pin
+# provides power to the external components
+external_power = DigitalInOut(board.EXTERNAL_POWER)
+external_power.direction = Direction.OUTPUT
+external_power.value = True
+
+# i2s playback
+wave_file = open("dune_thumper_sfx.wav", "rb")
+wave = audiocore.WaveFile(wave_file)
+audio = audiobusio.I2SOut(board.I2S_BIT_CLOCK, board.I2S_WORD_SELECT, board.I2S_DATA)
+mixer = audiomixer.Mixer(voice_count=1, sample_rate=22050, channel_count=1,
+                         bits_per_sample=16, samples_signed=True)
+audio.play(mixer)
+mixer.voice[0].play(wave, loop=True)
+mixer.voice[0].level = 0
+
+# servo control
+pwm = pwmio.PWMOut(board.EXTERNAL_SERVO, frequency=10)
+prop_servo = servo.ContinuousServo(pwm)
+servo_move = False
+
+i2c = board.I2C()
+int1 = DigitalInOut(board.ACCELEROMETER_INTERRUPT)
+lis3dh = adafruit_lis3dh.LIS3DH_I2C(i2c, int1=int1)
+lis3dh.range = adafruit_lis3dh.RANGE_2_G
+
+clock = ticks_ms()
+prop_time = 4000
+
+while True:
+    if not servo_move:
+        mixer.voice[0].level = 0.0
+        prop_servo.throttle = 0.0
+    else:
+        prop_servo.throttle = 0.5
+        mixer.voice[0].level = 0.5
+        if ticks_diff(ticks_ms(), clock) >= prop_time:
+            servo_move = False
+    if lis3dh.shake(shake_threshold=20):
+        servo_move = True
+        clock = ticks_ms()
+        clock = ticks_add(clock, prop_time)

Dune_Thumper/dune_thumper_sfx.wav

@@ -0,0 +1,64 @@
+// SPDX-FileCopyrightText: 2024 ladyada for Adafruit Industries
+//
+// SPDX-License-Identifier: MIT
+
+#include <Adafruit_DotStar.h>
+#include <Adafruit_NeoPixel.h>
+
+#define NUMPIXELS 64
+Adafruit_DotStar  dotstrip(NUMPIXELS, PIN_DATA, PIN_CLOCK, DOTSTAR_BRG);
+Adafruit_NeoPixel neostrip(NUMPIXELS, PIN_DATA, NEO_GRB + NEO_KHZ800);
+Adafruit_NeoPixel pixel(1, PIN_NEOPIXEL, NEO_GRB + NEO_KHZ800); // internal board pixel
+
+void setup() {
+  Serial.begin(115200);
+  
+  dotstrip.begin();
+  dotstrip.setBrightness(25);
+  dotstrip.show();
+
+  neostrip.begin();
+  neostrip.setBrightness(25);
+  neostrip.show();
+
+  pixel.begin();
+  pixel.setBrightness(25);
+  pixel.show();
+}
+
+uint16_t firstPixelHue = 0;
+bool which_strip = false;
+
+void loop() {  
+  firstPixelHue += 256;
+
+  if (which_strip == true) {
+    // neopixel
+    for(int i=0; i<neostrip.numPixels(); i++) {
+      int pixelHue = firstPixelHue + (i * 65536L / neostrip.numPixels());
+      neostrip.setPixelColor(i, neostrip.gamma32(neostrip.ColorHSV(pixelHue)));
+    }
+    neostrip.show();
+  } else {
+    // dotstar
+    for(int i=0; i<dotstrip.numPixels(); i++) {
+      int pixelHue = firstPixelHue + (i * 65536L / dotstrip.numPixels());
+      dotstrip.setPixelColor(i, dotstrip.gamma32(dotstrip.ColorHSV(pixelHue)));
+    }
+    dotstrip.show();
+  }
+  pixel.setPixelColor(0, pixel.gamma32(pixel.ColorHSV(firstPixelHue)));
+  pixel.show();
+  delay(10);
+
+  if (firstPixelHue == 0) {
+    which_strip = !which_strip;
+  }
+
+  float powerVoltage;
+  powerVoltage = analogRead(A0) / 1023.0 * 3.3;
+  powerVoltage *= 2; // resistor divider by 2, so * by 2
+  Serial.print("Power voltage: ");
+  Serial.print(powerVoltage);
+  Serial.println(" V");
+}

Factory_Tests/Pixel_Trinkey_FactoryTest/Pixel_Trinkey_FactoryTest.ino

@@ -0,0 +1,32 @@
+// SPDX-FileCopyrightText: 2024 ladyada for Adafruit Industries
+//
+// SPDX-License-Identifier: MIT
+
+#include <Adafruit_NeoPixel.h>
+
+Adafruit_NeoPixel pixel(1, PIN_NEOPIXEL, NEO_GRB + NEO_KHZ800);
+
+const int buttonPin = MISO;
+
+int buttonState = 0;
+
+void setup() {
+  Serial.begin(115200);
+  pinMode(buttonPin, INPUT);
+  pixel.begin();
+  pixel.setBrightness(10);
+  pixel.show();
+}
+
+void loop() {
+  buttonState = digitalRead(buttonPin);
+
+  if (buttonState == HIGH) {
+    pixel.setPixelColor(0, 0x0);
+    pixel.show();
+  } else {
+    pixel.setPixelColor(0, 0xFF0000);
+    pixel.show();
+  }
+  delay(100);
+}

Neo_Trinkey_Examples/Arduino_Digital_Input/Arduino_Digital_Input.ino

@@ -0,0 +1,31 @@
+// SPDX-FileCopyrightText: 2024 ladyada for Adafruit Industries
+//
+// SPDX-License-Identifier: MIT
+
+#include <Adafruit_DotStar.h>
+
+#define NUMPIXELS 64
+Adafruit_DotStar  dotstrip(NUMPIXELS, PIN_DATA, PIN_CLOCK, DOTSTAR_BRG);
+
+void setup() {
+  Serial.begin(115200);
+  
+  dotstrip.begin();
+  dotstrip.setBrightness(25);
+  dotstrip.show();
+
+}
+
+uint16_t firstPixelHue = 0;
+
+void loop() {  
+  firstPixelHue += 256;
+  
+  for(int i=0; i<dotstrip.numPixels(); i++) {
+    int pixelHue = firstPixelHue + (i * 65536L / dotstrip.numPixels());
+    dotstrip.setPixelColor(i, dotstrip.gamma32(dotstrip.ColorHSV(pixelHue)));
+  }
+  dotstrip.show();
+  delay(10);
+
+}

Neo_Trinkey_Examples/Arduino_DotStar/Arduino_DotStar.ino

@@ -0,0 +1,31 @@
+// SPDX-FileCopyrightText: 2024 ladyada for Adafruit Industries
+//
+// SPDX-License-Identifier: MIT
+
+#include <Adafruit_NeoPixel.h>
+
+#define NUMPIXELS 64
+Adafruit_NeoPixel neostrip(NUMPIXELS, PIN_DATA, NEO_GRB + NEO_KHZ800);
+
+void setup() {
+  Serial.begin(115200);
+
+  neostrip.begin();
+  neostrip.setBrightness(25);
+  neostrip.show();
+
+}
+
+uint16_t firstPixelHue = 0;
+
+void loop() {  
+  firstPixelHue += 256;
+  for(int i=0; i<neostrip.numPixels(); i++) {
+      int pixelHue = firstPixelHue + (i * 65536L / neostrip.numPixels());
+      neostrip.setPixelColor(i, neostrip.gamma32(neostrip.ColorHSV(pixelHue)));
+    }
+  neostrip.show();
+  
+  delay(10);
+
+}

Neo_Trinkey_Examples/Arduino_NeoPixel/Arduino_NeoPixel.ino

@@ -0,0 +1,20 @@
+# SPDX-FileCopyrightText: 2021 Kattni Rembor for Adafruit Industries
+# SPDX-License-Identifier: MIT
+"""CircuitPython Digital Input example
+Blinking a built-in NeoPixel LED using a button switch.
+
+"""
+import board
+import digitalio
+import neopixel
+
+pixel = neopixel.NeoPixel(board.NEOPIXEL, 1)
+
+button = digitalio.DigitalInOut(board.D4)
+button.switch_to_input(pull=digitalio.Pull.UP)
+
+while True:
+    if not button.value:
+        pixel.fill((255, 0, 0))
+    else:
+        pixel.fill((0, 0, 0))

Neo_Trinkey_Examples/CircuitPython_Digital_Input/code.py

@@ -0,0 +1,25 @@
+# SPDX-FileCopyrightText: 2024 Liz Clark for Adafruit Industries
+# SPDX-License-Identifier: MIT
+
+import time
+import board
+from rainbowio import colorwheel
+import adafruit_dotstar as dotstar
+
+clock_pin = board.CLOCK
+data_pin = board.DATA
+num_dots = 30
+speed = 0.01
+brightness = 0.2
+order = "PGBR" # PGBR, PGRB, PRBG or PRGB
+dots = dotstar.DotStar(clock_pin, data_pin, num_dots,
+					   brightness=brightness, auto_write=True,
+					   pixel_order=order)
+
+hue = 0
+dots.fill(colorwheel(hue))
+
+while True:
+    hue = (hue + 1) % 256
+    dots.fill(colorwheel(hue))
+    time.sleep(speed)

Neo_Trinkey_Examples/CircuitPython_DotStar/code.py

@@ -0,0 +1,23 @@
+# SPDX-FileCopyrightText: 2024 Liz Clark for Adafruit Industries
+# SPDX-License-Identifier: MIT
+
+import time
+import board
+from rainbowio import colorwheel
+import neopixel
+
+pixel_pin = board.DATA
+num_pixels = 30
+speed = 0.01
+brightness = 0.5
+order = "GRB" # "GRBW" for RGBW NeoPixels
+pixels = neopixel.NeoPixel(pixel_pin, num_pixels,
+                           brightness=brightness, auto_write=True,
+                           pixel_order=order)
+hue = 0
+pixels.fill(colorwheel(hue))
+
+while True:
+    hue = (hue + 1) % 256
+    pixels.fill(colorwheel(hue))
+    time.sleep(speed)