added arduino, modified build
This commit is contained in:
@@ -0,0 +1,369 @@
|
||||
/*!
|
||||
* @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;
|
||||
Reference in New Issue
Block a user