You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
370 lines
13 KiB
370 lines
13 KiB
/*!
|
|
* @file Adafruit_CircuitPlayground.cpp
|
|
*
|
|
* @mainpage Adafruit CircuitPlayground Library
|
|
*
|
|
* @section intro_sec Introduction
|
|
*
|
|
* This is the documentation for Adafruit's CircuitPlayground driver for the
|
|
* Arduino platform. It is designed specifically to work with the
|
|
* Adafruit CircuitPlayground boards:
|
|
* - https://www.adafruit.com/products/3000
|
|
* - https://www.adafruit.com/products/3333
|
|
*
|
|
*
|
|
* Adafruit invests time and resources providing this open source code,
|
|
* please support Adafruit and open-source hardware by purchasing
|
|
* products from Adafruit!
|
|
*
|
|
*
|
|
* @section author Author
|
|
*
|
|
* Written by Ladyada and others for Adafruit Industries.
|
|
*
|
|
* @section license License
|
|
*
|
|
* BSD license, all text here must be included in any redistribution.
|
|
*
|
|
*/
|
|
|
|
#include <Adafruit_Circuit_Playground.h>
|
|
|
|
/**************************************************************************/
|
|
/*!
|
|
@brief Set up the CircuitPlayground hardware
|
|
@param brightness Optional brightness to set the neopixels to
|
|
@returns True if device is set up, false on any failure
|
|
*/
|
|
/**************************************************************************/
|
|
boolean Adafruit_CircuitPlayground::begin(uint8_t brightness) {
|
|
pinMode(CPLAY_REDLED, OUTPUT);
|
|
pinMode(CPLAY_BUZZER, OUTPUT);
|
|
#ifdef __AVR__
|
|
pinMode(CPLAY_CAPSENSE_SHARED, OUTPUT);
|
|
pinMode(CPLAY_LEFTBUTTON, INPUT);
|
|
pinMode(CPLAY_RIGHTBUTTON, INPUT);
|
|
pinMode(CPLAY_SLIDESWITCHPIN, INPUT);
|
|
#else // Circuit Playground Express
|
|
pinMode(CPLAY_LEFTBUTTON, INPUT_PULLDOWN);
|
|
pinMode(CPLAY_RIGHTBUTTON, INPUT_PULLDOWN);
|
|
pinMode(CPLAY_SLIDESWITCHPIN, INPUT_PULLUP);
|
|
irReceiver=IRrecvPCI(CPLAY_IR_RECEIVER);
|
|
irDecoder=IRdecode();
|
|
#endif
|
|
|
|
|
|
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();
|
|
|
|
speaker.begin();
|
|
|
|
strip.begin();
|
|
strip.show(); // Initialize all pixels to 'off'
|
|
strip.setBrightness(brightness);
|
|
|
|
#ifdef __AVR__
|
|
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);
|
|
#else // Circuit Playground Express // Circuit Playground Express
|
|
for(int i=0; i<7; i++) {
|
|
cap[i] = Adafruit_CPlay_FreeTouch(A1+i, OVERSAMPLE_4, RESISTOR_50K, FREQ_MODE_NONE);
|
|
if (! cap[i].begin()) return false;
|
|
}
|
|
#endif
|
|
|
|
return lis.begin(CPLAY_LIS3DH_ADDRESS);
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/*!
|
|
@brief read capacitive touch sensor
|
|
@param p the pin to read. Must be a captouch enabled pin.
|
|
@param samples Optional number of samples to take. Defaults to 10.
|
|
@returns measured captouch value
|
|
*/
|
|
/**************************************************************************/
|
|
uint16_t Adafruit_CircuitPlayground::readCap(uint8_t p, uint8_t samples) {
|
|
#ifdef __AVR__ // Circuit Playground Classic
|
|
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;
|
|
}
|
|
#else // Circuit Playground Express // Circuit Playground Express
|
|
// analog pins r ez!
|
|
if ((p >= A1) && (p <= A7)) {
|
|
return cap[p - A1].measure();
|
|
}
|
|
// oof digital pins
|
|
switch (p) {
|
|
case 0: return cap[A6 - A1].measure();
|
|
case 1: return cap[A7 - A1].measure();
|
|
case 2: return cap[A5 - A1].measure();
|
|
case 3: return cap[A4 - A1].measure();
|
|
case 6: return cap[A1 - A1].measure();
|
|
case 9: return cap[A2 - A1].measure();
|
|
case 10: return cap[A3 - A1].measure();
|
|
default: return 0;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/*!
|
|
@brief turn on or off the red LED on pin #13
|
|
@param v pass true to turn LED on, false to turn LED off
|
|
*/
|
|
/**************************************************************************/
|
|
void Adafruit_CircuitPlayground::redLED(boolean v) {
|
|
digitalWrite(CPLAY_REDLED, v);
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/*!
|
|
@brief read the slide switch
|
|
@returns true if slide switch in set, false if not
|
|
*/
|
|
/**************************************************************************/
|
|
boolean Adafruit_CircuitPlayground::slideSwitch(void) {
|
|
return digitalRead(CPLAY_SLIDESWITCHPIN);
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/*!
|
|
@brief read the left button
|
|
@returns true if button is pressed, false if not
|
|
*/
|
|
/**************************************************************************/
|
|
boolean Adafruit_CircuitPlayground::leftButton(void) {
|
|
return digitalRead(CPLAY_LEFTBUTTON);
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/*!
|
|
@brief read the right button
|
|
@returns true if button is pressed, false if not
|
|
*/
|
|
/**************************************************************************/
|
|
boolean Adafruit_CircuitPlayground::rightButton(void) {
|
|
return digitalRead(CPLAY_RIGHTBUTTON);
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/*!
|
|
@brief play a tone on the onboard buzzer
|
|
@param freq the frequency to play
|
|
@param time the duration of the tone in milliseconds
|
|
@param wait Optional flag to wait for time milliseconds after playing the tone. Defaults to true.
|
|
@note The driver circuitry is an on/off transistor driver, so you will only be able to play square waves.
|
|
It is also not the same loudness over all frequencies but is designed to be the loudest at around 4 KHz
|
|
*/
|
|
/**************************************************************************/
|
|
void Adafruit_CircuitPlayground::playTone(uint16_t freq, uint16_t time, boolean wait) {
|
|
tone(CPLAY_BUZZER, freq, time);
|
|
if (wait) delay(time);
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/*!
|
|
@brief read the onboard lightsensor
|
|
@returns value between 0 and 1023 read from the light sensor
|
|
@note 1000 Lux will roughly read as 2 Volts (or about 680 as a raw analog reading).
|
|
A reading of about 300 is common for most indoor light levels.
|
|
Note that outdoor daylight is 10,000 Lux or even higher, so this sensor is best
|
|
suited for indoor light levels!
|
|
*/
|
|
/**************************************************************************/
|
|
uint16_t Adafruit_CircuitPlayground::lightSensor(void) {
|
|
return analogRead(CPLAY_LIGHTSENSOR);
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/*!
|
|
@brief read the onboard sound sensor. A reading of ~0 is silent, and
|
|
loud audio will result in a reading between -500 and 500 or so.
|
|
@returns value of the sound sensor
|
|
*/
|
|
/**************************************************************************/
|
|
int16_t Adafruit_CircuitPlayground::soundSensor(void) {
|
|
int16_t x;
|
|
mic.capture(&x, 1);
|
|
return x;
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/*!
|
|
@brief read the X parameter of the onboard accelerometer. Value returned is
|
|
defined by setAccelRange().
|
|
@returns X value of the accelerometer
|
|
*/
|
|
/**************************************************************************/
|
|
float Adafruit_CircuitPlayground::motionX(void) {
|
|
sensors_event_t event;
|
|
CircuitPlayground.lis.getEvent(&event);
|
|
return event.acceleration.x;
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/*!
|
|
@brief read the Y parameter of the onboard accelerometer. Value returned is
|
|
defined by setAccelRange().
|
|
@returns Y value of the accelerometer
|
|
*/
|
|
/**************************************************************************/
|
|
float Adafruit_CircuitPlayground::motionY(void) {
|
|
sensors_event_t event;
|
|
CircuitPlayground.lis.getEvent(&event);
|
|
return event.acceleration.y;
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/*!
|
|
@brief read the Z parameter of the onboard accelerometer. Value returned is
|
|
defined by setAccelRange().
|
|
@returns the Z value of the onboard accelerometer
|
|
*/
|
|
/**************************************************************************/
|
|
float Adafruit_CircuitPlayground::motionZ(void) {
|
|
sensors_event_t event;
|
|
CircuitPlayground.lis.getEvent(&event);
|
|
return event.acceleration.z;
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/*!
|
|
@brief read the onboard thermistor.
|
|
@returns temperature reading in Centigrade.
|
|
*/
|
|
/**************************************************************************/
|
|
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;
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/*!
|
|
@brief read the onboard thermistor.
|
|
@returns temperature reading in Farenheight.
|
|
*/
|
|
/**************************************************************************/
|
|
float Adafruit_CircuitPlayground::temperatureF(void) {
|
|
float tempF = CircuitPlayground.temperature() * 1.8 + 32;
|
|
return tempF;
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/*!
|
|
@brief get a color value from the color wheel.
|
|
@param WheelPos a value 0 to 255
|
|
@returns 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);
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/*!
|
|
@brief detect a color value from the light sensor
|
|
@param red the pointer to where the red component should be stored.
|
|
@param green the pointer to where the green component should be stored.
|
|
@param blue the pointer to where the blue component should be stored.
|
|
@returns the components of the detected colors in the passed pointers.
|
|
*/
|
|
/**************************************************************************/
|
|
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);
|
|
}
|
|
|
|
/**************************************************************************/
|
|
/*!
|
|
@brief check whether or not this device is a CircuitPlayground Express.
|
|
@returns True if the device is a CircuitPlayground Express, false if it is a 'classic'.
|
|
*/
|
|
/**************************************************************************/
|
|
boolean Adafruit_CircuitPlayground::isExpress(void) {
|
|
#ifdef __AVR__
|
|
return false;
|
|
#else
|
|
return true;
|
|
#endif
|
|
}
|
|
|
|
// instantiate static
|
|
Adafruit_CircuitPlayground CircuitPlayground;
|