forked from adafruit/Adafruit_CircuitPlayground
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Adafruit_CircuitPlayground.cpp
196 lines (164 loc) · 6 KB
/
Adafruit_CircuitPlayground.cpp
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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
#include <Adafruit_CircuitPlayground.h>
boolean Adafruit_CircuitPlayground::begin(uint8_t brightness) {
pinMode(CPLAY_REDLED, OUTPUT);
pinMode(CPLAY_SLIDESWITCHPIN, INPUT);
pinMode(CPLAY_LEFTBUTTON, INPUT);
pinMode(CPLAY_RIGHTBUTTON, INPUT);
pinMode(CPLAY_BUZZER, OUTPUT);
pinMode(CPLAY_CAPSENSE_SHARED, OUTPUT);
strip = Adafruit_CPlay_NeoPixel();
strip.updateType(NEO_GRB + NEO_KHZ800);
strip.updateLength(10);
strip.setPin(CPLAY_NEOPIXELPIN);
lis = Adafruit_CPlay_LIS3DH(CPLAY_LIS3DH_CS);
mic = Adafruit_CPlay_Mic();
strip.begin();
strip.show(); // Initialize all pixels to 'off'
strip.setBrightness(brightness);
cap[0] = CPlay_CapacitiveSensor(CPLAY_CAPSENSE_SHARED, 0);
cap[1] = CPlay_CapacitiveSensor(CPLAY_CAPSENSE_SHARED, 1);
cap[2] = CPlay_CapacitiveSensor(CPLAY_CAPSENSE_SHARED, 2);
cap[3] = CPlay_CapacitiveSensor(CPLAY_CAPSENSE_SHARED, 3);
cap[4] = CPlay_CapacitiveSensor(CPLAY_CAPSENSE_SHARED, 6);
cap[5] = CPlay_CapacitiveSensor(CPLAY_CAPSENSE_SHARED, 9);
cap[6] = CPlay_CapacitiveSensor(CPLAY_CAPSENSE_SHARED, 10);
cap[7] = CPlay_CapacitiveSensor(CPLAY_CAPSENSE_SHARED, 12);
if (! lis.begin(0x18)) { // change this to 0x19 for alternative i2c address
return false;
}
return true;
}
uint16_t Adafruit_CircuitPlayground::readCap(uint8_t p, uint8_t samples) {
switch (p) {
case 0:
return cap[0].capacitiveSensor(samples);
case 1:
return cap[1].capacitiveSensor(samples);
case 2:
return cap[2].capacitiveSensor(samples);
case 3:
return cap[3].capacitiveSensor(samples);
case 6:
return cap[4].capacitiveSensor(samples);
case 9:
return cap[5].capacitiveSensor(samples);
case 10:
return cap[6].capacitiveSensor(samples);
case 12:
return cap[7].capacitiveSensor(samples);
default:
return 0;
}
}
// just turn on/off the red #13 LED
void Adafruit_CircuitPlayground::redLED(boolean v) {
digitalWrite(CPLAY_REDLED, v);
}
// just read the slide switch
boolean Adafruit_CircuitPlayground::slideSwitch(void) {
return digitalRead(CPLAY_SLIDESWITCHPIN);
}
// just read the left button
boolean Adafruit_CircuitPlayground::leftButton(void) {
return digitalRead(CPLAY_LEFTBUTTON);
}
// just read the right button
boolean Adafruit_CircuitPlayground::rightButton(void) {
return digitalRead(CPLAY_RIGHTBUTTON);
}
void Adafruit_CircuitPlayground::playTone(uint16_t freq, uint16_t time, boolean wait) {
tone(CPLAY_BUZZER, freq, time);
if (wait) delay(time);
}
uint16_t Adafruit_CircuitPlayground::lightSensor(void) {
return analogRead(CPLAY_LIGHTSENSOR);
}
uint16_t Adafruit_CircuitPlayground::soundSensor(void) {
return analogRead(CPLAY_SOUNDSENSOR);
}
float Adafruit_CircuitPlayground::motionX(void) {
sensors_event_t event;
CircuitPlayground.lis.getEvent(&event);
return event.acceleration.x;
}
float Adafruit_CircuitPlayground::motionY(void) {
sensors_event_t event;
CircuitPlayground.lis.getEvent(&event);
return event.acceleration.y;
}
float Adafruit_CircuitPlayground::motionZ(void) {
sensors_event_t event;
CircuitPlayground.lis.getEvent(&event);
return event.acceleration.z;
}
float Adafruit_CircuitPlayground::temperature(void) {
// Thermistor test
float reading;
reading = analogRead(CPLAY_THERMISTORPIN);
//Serial.print("Thermistor reading: "); Serial.println(reading);
// convert the value to resistance
reading = ((1023.0 * SERIESRESISTOR) / reading);
reading -= SERIESRESISTOR;
//Serial.print("Thermistor resistance: "); Serial.println(reading);
float steinhart;
steinhart = reading / THERMISTORNOMINAL; // (R/Ro)
steinhart = log(steinhart); // ln(R/Ro)
steinhart /= BCOEFFICIENT; // 1/B * ln(R/Ro)
steinhart += 1.0 / (TEMPERATURENOMINAL + 273.15); // + (1/To)
steinhart = 1.0 / steinhart; // Invert
steinhart -= 273.15; // convert to C
return steinhart;
}
// Get the temperature in degrees Fahrenheit
float Adafruit_CircuitPlayground::temperatureF(void) {
float tempF = CircuitPlayground.temperature() * 1.8 + 32;
return tempF;
}
// Input a value 0 to 255 to get a color value.
// The colours are a transition r - g - b - back to r.
uint32_t Adafruit_CircuitPlayground::colorWheel(uint8_t WheelPos) {
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 Adafruit_CircuitPlayground::senseColor(uint8_t& red, uint8_t& green, uint8_t& blue) {
// Save the current pixel brightness so it can later be restored. Then bump
// the brightness to max to make sure the LED is as bright as possible for
// the color readings.
uint8_t old_brightness = strip.getBrightness();
strip.setBrightness(255);
// Set pixel 1 (next to the light sensor) to full red, green, blue
// color and grab a light sensor reading. Make sure to wait a bit
// after changing pixel colors to let the light sensor change
// resistance!
setPixelColor(1, 255, 0, 0); // Red
delay(LIGHT_SETTLE_MS);
uint16_t raw_red = lightSensor();
setPixelColor(1, 0, 255, 0); // Green
delay(LIGHT_SETTLE_MS);
uint16_t raw_green = lightSensor();
setPixelColor(1, 0, 0, 255); // Blue
delay(LIGHT_SETTLE_MS);
uint16_t raw_blue = lightSensor();
// Turn off the pixel and restore brightness, we're done with readings.
setPixelColor(1, 0);
strip.setBrightness(old_brightness);
// Now scale down each of the raw readings to be within
// 0 to 255. Remember each sensor reading is from the ADC
// which has 10 bits of resolution (0 to 1023), so dividing
// by 4 will change the range from 0-1023 to 0-255. Also
// use the min function to clamp the value to 255 at most (just
// to prevent overflow from 255.xx to 0).
red = min(255, raw_red/4);
green = min(255, raw_green/4);
blue = min(255, raw_blue/4);
}
// instantiate static
Adafruit_CircuitPlayground CircuitPlayground;