1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

// SPDX-FileCopyrightText: 2019 Brent Rubell for Adafruit Industries
//
// SPDX-License-Identifier: MIT

/*
* Adafruit Prop-Maker Featherwing
* NeoPixel Example
* 
* Rainbow example for 30-Pixel NeoPixel Strip
*/
#include <Adafruit_NeoPixel.h>

#ifdef USE_TINYUSB  // For Serial when selecting TinyUSB
#include <Adafruit_TinyUSB.h>
#endif

// NeoPixel strip length, in pixels
#define NUM_PIXELS 30

#if defined(__SAMD21G18A__) || defined(__AVR_ATmega32U4__) || defined(NRF52840_XXAA)
  #define NEOPIXEL_PIN 5
  #define POWER_PIN    10
#elif defined(__AVR_ATmega328P__)
  #define NEOPIXEL_PIN 5
  #define POWER_PIN    10
#elif defined(NRF52)
  #define NEOPIXEL_PIN 27
  #define POWER_PIN    11
#elif defined(ESP8266)
  #define NEOPIXEL_PIN 2
  #define POWER_PIN    15
#elif defined(TEENSYDUINO)
  #define NEOPIXEL_PIN 8
  #define POWER_PIN    10
#elif defined(ESP32)
  #define NEOPIXEL_PIN 14
  #define POWER_PIN    33
#endif

// create a neopixel strip
Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_PIXELS, NEOPIXEL_PIN, NEO_GRB + NEO_KHZ800);


void setup() {
  Serial.begin(115200);
  Serial.println("\nProp-Maker Wing: NeoPixel");

  // Set power pin to output
  pinMode(POWER_PIN, OUTPUT);
  // Disable the pin, we're not currently writing to the neopixels.
  digitalWrite(POWER_PIN, LOW);

  // This initializes the NeoPixel library.
  strip.begin();
}


uint32_t Wheel(byte WheelPos) {
  // Input a value 0 to 255 to get a color value.
  // The colours are a transition r - g - b - back to r.
  WheelPos = 255 - WheelPos;
  if(WheelPos < 85) {
    return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  }
  if(WheelPos < 170) {
    WheelPos -= 85;
    return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
  WheelPos -= 170;
  return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}

void rainbow(uint8_t wait) {
  uint16_t i, j;

  for(j=0; j<256; j++) {
    for(i=0; i<strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel((i+j) & 255));
    }
    // turn on the Prop-Maker FeatherWing's power pin
    digitalWrite(POWER_PIN, HIGH);
    // write the pixel values
    strip.show();
    delay(wait);
  }
}

void loop()
{
  // cycle a the rainbow with a 20ms wait
  rainbow(20);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

// SPDX-FileCopyrightText: 2019 Brent Rubell for Adafruit Industries
//
// SPDX-License-Identifier: MIT

/*
* Adafruit Prop-Maker Featherwing
* Accelerometer Example
* 
* Prints acceleration data to the Serial Monitor
*/
// include the accelerometer library
#include <Adafruit_LIS3DH.h>

// Adjust this number for the sensitivity of the 'click' force
// this strongly depend on the range! for 16G, try 5-10
// for 8G, try 10-20. for 4G try 20-40. for 2G try 40-80
#define CLICKTHRESHHOLD 40

// inst. i2c accelerometer
Adafruit_LIS3DH lis = Adafruit_LIS3DH();

void setup() {
  Serial.begin(115200);
  Serial.println("\nProp-Maker Wing: Accelerometer");

  Serial.println("Starting LIS3DH...");
  if (! lis.begin(0x18)) {   // change this to 0x19 for alternative i2c address
    Serial.println("Couldnt start LIS3DH");
    while (1);
  }
  Serial.println("LIS3DH Started!");

  // Set Accelerometer Range (2, 4, 8, or 16 G!)
  lis.setRange(LIS3DH_RANGE_4_G);

  /* Set Accelerometer Click Detection
  * 0 = turn off click detection & interrupt
  * 1 = single click only interrupt output
  * 2 = double click only interrupt output   
  * NOTE: Higher numbers are less sensitive
  */
  lis.setClick(1, CLICKTHRESHHOLD);

}

void loop() {

  // Detect a click 
  uint8_t click = lis.getClick();
  
  // Get a new accel. sensor event
  sensors_event_t event; 
  lis.getEvent(&event);
  
  /* Display the results (acceleration is measured in m/s^2) */
  Serial.print("\t\tX: "); Serial.print(event.acceleration.x);
  Serial.print(" \tY: "); Serial.print(event.acceleration.y); 
  Serial.print(" \tZ: "); Serial.print(event.acceleration.z); 
  Serial.println(" m/s^2 ");
  Serial.println();

  delay(1000); 
  
  // detect click
  if (click & 0x10) Serial.print(" single click");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

// SPDX-FileCopyrightText: 2019 Brent Rubell for Adafruit Industries
//
// SPDX-License-Identifier: MIT

/*
* Adafruit Prop-Maker Featherwing
* LED Example
*
* Rainbow swirl example for 3W LED.
*/

#ifdef USE_TINYUSB  // For Serial when selecting TinyUSB
#include <Adafruit_TinyUSB.h>
#endif

#if defined(__SAMD21G18A__) || defined(__AVR_ATmega32U4__) || defined(NRF52840_XXAA)
  // No green PWM on 32u4
  #define POWER_PIN    10
  #define RED_LED      11
  #define GREEN_LED    12  // no PWM on atmega32u4
  #define BLUE_LED     13
#elif defined(__AVR_ATmega328P__)
  // No Red or Blue PWM
  #define POWER_PIN    10
  #define RED_LED      2
  #define GREEN_LED    3  // the only PWM pin!
  #define BLUE_LED     4
#elif defined(NRF52)
  #define POWER_PIN    11
  #define RED_LED      7
  #define GREEN_LED    15
  #define BLUE_LED     16
#elif defined(ESP8266)
  #define POWER_PIN    15
  #define RED_LED      13
  #define GREEN_LED    12
  #define BLUE_LED     14
#elif defined(TEENSYDUINO)
  #define POWER_PIN    10
  #define RED_LED      9
  #define GREEN_LED    6
  #define BLUE_LED     5
#elif defined(ARDUINO_ADAFRUIT_FEATHER_ESP32S2)
  #define POWER_PIN    10
  #define RED_LED       0
  #define GREEN_LED     1
  #define BLUE_LED      2
  #define RED_PIN      11
  #define GREEN_PIN    12
  #define BLUE_PIN     13
  #define analogWrite ledcWrite
#elif defined(ESP32)
  #define POWER_PIN    33
  #define RED_LED       0
  #define GREEN_LED     1
  #define BLUE_LED      2
  #define RED_PIN      27
  #define GREEN_PIN    12
  #define BLUE_PIN     13
  #define analogWrite ledcWrite
#endif

uint8_t i=0;

uint8_t red_out = RED_LED;
uint8_t green_out = GREEN_LED;
uint8_t blue_out = BLUE_LED;

void setup() {
  Serial.begin(115200);
  Serial.println("\nProp-Maker Wing: LED Example");

  // set up the power pin
  pinMode(POWER_PIN, OUTPUT);
  // disable the power pin, we're not writing to the LEDs
  digitalWrite(POWER_PIN, LOW);

  // Set up the LED Pins
  #if defined(ESP32) // and ESP32-S2!
    #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 1, 1)
      // newer LEDC API, use pins instead of channel
      red_out = RED_PIN;
      green_out = GREEN_PIN;
      blue_out = BLUE_PIN;
      ledcAttach(RED_PIN, 5000, 8);
      ledcAttach(GREEN_PIN, 5000, 8);
      ledcAttach(BLUE_PIN, 5000, 8);
    #else
      // older LEDC API, use channel, attach pin to channel
      ledcSetup(RED_LED, 5000, 8);
      ledcAttachPin(RED_PIN, RED_LED);
      ledcSetup(GREEN_LED, 5000, 8);
      ledcAttachPin(GREEN_PIN, GREEN_LED);
      ledcSetup(BLUE_LED, 5000, 8);
      ledcAttachPin(BLUE_PIN, BLUE_LED);
    #endif
  #else
    pinMode(red_out, OUTPUT);
    pinMode(green_out, OUTPUT);
    pinMode(blue_out, OUTPUT);
  #endif

  analogWrite(red_out, 0);
  analogWrite(green_out, 0);
  analogWrite(blue_out, 0);
}

uint32_t Color(uint8_t r, uint8_t g, uint8_t b) {
  return ((uint32_t)r << 16) | ((uint32_t)g << 8) | b;
}

uint32_t Wheel(byte WheelPos) {
  WheelPos = 255 - WheelPos;
  if(WheelPos < 85) {
    return Color(255 - WheelPos * 3, 0, WheelPos * 3);
  }
  if(WheelPos < 170) {
    WheelPos -= 85;
    return Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
  WheelPos -= 170;
  return Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}

void loop()
{
  // set RGB Colors
  uint32_t color = Wheel(i++);
  uint8_t red = color >> 16;
  uint8_t green = color >> 8;
  uint8_t blue = color;

  // turn on the power pin
  digitalWrite(POWER_PIN, HIGH);

  // write colors to the 3W LED
  analogWrite(red_out, red);
  analogWrite(green_out, green);
  analogWrite(blue_out, blue);
  delay(2);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

// SPDX-FileCopyrightText: 2019 Brent Rubell for Adafruit Industries
//
// SPDX-License-Identifier: MIT

/*
* Adafruit Prop-Maker Featherwing
* Switch Example
* 
* Print to the Serial Montior when a switch is pressed.
*/

#ifdef USE_TINYUSB  // For Serial when selecting TinyUSB
#include <Adafruit_TinyUSB.h>
#endif

#if defined(__SAMD21G18A__) || defined(__AVR_ATmega32U4__) || defined(NRF52840_XXAA)
  #define SWITCH_PIN   9
#elif defined(__AVR_ATmega328P__)
  #define SWITCH_PIN   9
#elif defined(NRF52)
  #define SWITCH_PIN   31
#elif defined(ESP8266)
  #define SWITCH_PIN   0
#elif defined(TEENSYDUINO)
  #define SWITCH_PIN   4
#elif defined(ESP32)
  #define SWITCH_PIN   15
#endif

void setup() {
  Serial.begin(115200);
  Serial.println("\nProp-Maker Wing: Switch Example");
  // set up the switch
  pinMode(SWITCH_PIN, INPUT_PULLUP);
}

void loop()
{
  if (!digitalRead(SWITCH_PIN)) {
    Serial.println("Switch pressed!");
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# SPDX-FileCopyrightText: 2019 Kattni Rembor for Adafruit Industries
#
# SPDX-License-Identifier: MIT

"""Simple rainbow example for 30-pixel NeoPixel strip"""
import digitalio
import board
from rainbowio import colorwheel
import neopixel

NUM_PIXELS = 30  # NeoPixel strip length (in pixels)

enable = digitalio.DigitalInOut(board.D10)
enable.direction = digitalio.Direction.OUTPUT
enable.value = True

strip = neopixel.NeoPixel(board.D5, NUM_PIXELS, brightness=1)

while True:
    for i in range(255):
        strip.fill((colorwheel(i)))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# SPDX-FileCopyrightText: 2019, 2023 Kattni Rembor for Adafruit Industries
#
# SPDX-License-Identifier: MIT

"""Simple example to play a wave file"""
# This example only works on Feathers that have analog audio out!
import digitalio
import board
import audiocore

try:
    from audioio import AudioOut
except ImportError:
    try:
        from audiopwmio import PWMAudioOut as AudioOut
    except ImportError:
        pass  # not always supported by every board!

WAV_FILE_NAME = "StreetChicken.wav"  # Change to the name of your wav file!

enable = digitalio.DigitalInOut(board.D10)
enable.direction = digitalio.Direction.OUTPUT
enable.value = True

with AudioOut(board.A0) as audio:  # Speaker connector
    wave_file = open(WAV_FILE_NAME, "rb")
    wave = audiocore.WaveFile(wave_file)

    audio.play(wave)
    while audio.playing:
        pass

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# SPDX-FileCopyrightText: 2019 Kattni Rembor for Adafruit Industries
#
# SPDX-License-Identifier: MIT

"""Simple example to print acceleration data to console"""
import time
import digitalio
import board
import busio
import adafruit_lis3dh

# Set up accelerometer on I2C bus, 4G range:
i2c = busio.I2C(board.SCL, board.SDA)
int1 = digitalio.DigitalInOut(board.D6)
accel = adafruit_lis3dh.LIS3DH_I2C(i2c, int1=int1)
accel.range = adafruit_lis3dh.RANGE_4_G
accel.set_tap(1, 100)

while True:
    x, y, z = accel.acceleration
    print(x, y, z)
    time.sleep(0.1)
    if accel.tapped:
        print("Tapped!")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

# SPDX-FileCopyrightText: 2019, 2023 Kattni Rembor for Adafruit Industries
#
# SPDX-License-Identifier: MIT

"""Simple rainbow swirl example for 3W LED"""
import time
import pwmio
import board
import digitalio

enable = digitalio.DigitalInOut(board.D10)
enable.direction = digitalio.Direction.OUTPUT
enable.value = True


def colorwheel(pos):
    if pos < 0 or pos > 255:
        return 0, 0, 0
    if pos < 85:
        return int(255 - pos * 3), int(pos * 3), 0
    if pos < 170:
        pos -= 85
        return 0, int(255 - pos * 3), int(pos * 3)
    pos -= 170
    return int(pos * 3), 0, int(255 - pos * 3)


red = pwmio.PWMOut(board.D11, duty_cycle=0, frequency=20000)
green = pwmio.PWMOut(board.D12, duty_cycle=0, frequency=20000)
blue = pwmio.PWMOut(board.D13, duty_cycle=0, frequency=20000)

while True:
    for i in range(255):
        r, g, b = colorwheel(i)
        red.duty_cycle = int(r * 65536 / 256)
        green.duty_cycle = int(g * 65536 / 256)
        blue.duty_cycle = int(b * 65536 / 256)
        time.sleep(0.05)