| /*! | |
| * @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. | |
| * | |
| */ | |
| /**************************************************************************/ | |
| /*! | |
| @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 | |
| */ | |
| /**************************************************************************/ | |
| bool Adafruit_CircuitPlayground::begin(uint8_t brightness) { | |
| pinMode(CPLAY_REDLED, OUTPUT); | |
| pinMode(CPLAY_BUZZER, OUTPUT); | |
| pinMode(CPLAY_CAPSENSE_SHARED, OUTPUT); | |
| pinMode(CPLAY_LEFTBUTTON, INPUT); | |
| pinMode(CPLAY_RIGHTBUTTON, INPUT); | |
| pinMode(CPLAY_SLIDESWITCHPIN, INPUT); | |
| pinMode(CPLAY_LEFTBUTTON, INPUT_PULLDOWN); | |
| pinMode(CPLAY_RIGHTBUTTON, INPUT_PULLDOWN); | |
| pinMode(CPLAY_SLIDESWITCHPIN, INPUT_PULLUP); | |
| pinMode(CPLAY_SPEAKER_SHUTDOWN, OUTPUT); | |
| digitalWrite(CPLAY_SPEAKER_SHUTDOWN, HIGH); | |
| pinMode(CPLAY_LEFTBUTTON, INPUT_PULLDOWN); | |
| pinMode(CPLAY_RIGHTBUTTON, INPUT_PULLDOWN); | |
| pinMode(CPLAY_SLIDESWITCHPIN, INPUT_PULLUP); | |
| irReceiver = IRrecvPCI(CPLAY_IR_RECEIVER); | |
| irDecoder = IRdecode(); | |
| // since we aren't calling speaker.begin() anymore, do this here | |
| pinMode(CPLAY_SPEAKER_SHUTDOWN, OUTPUT); | |
| digitalWrite(CPLAY_SPEAKER_SHUTDOWN, HIGH); | |
| strip = Adafruit_CPlay_NeoPixel(); | |
| strip.updateType(NEO_GRB + NEO_KHZ800); | |
| strip.updateLength(10); | |
| strip.setPin(CPLAY_NEOPIXELPIN); | |
| lis = Adafruit_CPlay_LIS3DH(CPLAY_LIS3DH_CS, &SPI); // SPI | |
| lis = Adafruit_CPlay_LIS3DH(&Wire1); // i2c on wire1 | |
| lis = Adafruit_CPlay_LIS3DH(&Wire1); // i2c on wire1 | |
| 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); | |
| 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; | |
| } | |
| 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) { | |
| // bluefruit | |
| 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; | |
| } | |
| // 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; | |
| } | |
| } | |
| /**************************************************************************/ | |
| /*! | |
| @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(bool v) { | |
| digitalWrite(CPLAY_REDLED, v); | |
| } | |
| /**************************************************************************/ | |
| /*! | |
| @brief read the slide switch | |
| @returns true if slide switch in set, false if not | |
| */ | |
| /**************************************************************************/ | |
| bool Adafruit_CircuitPlayground::slideSwitch(void) { | |
| return digitalRead(CPLAY_SLIDESWITCHPIN); | |
| } | |
| /**************************************************************************/ | |
| /*! | |
| @brief read the left button | |
| @returns true if button is pressed, false if not | |
| */ | |
| /**************************************************************************/ | |
| bool Adafruit_CircuitPlayground::leftButton(void) { | |
| return digitalRead(CPLAY_LEFTBUTTON); | |
| } | |
| /**************************************************************************/ | |
| /*! | |
| @brief read the right button | |
| @returns true if button is pressed, false if not | |
| */ | |
| /**************************************************************************/ | |
| bool 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, | |
| bool wait) { | |
| if (!freq) | |
| return; | |
| uint32_t ocr; | |
| uint16_t prescale = 1; | |
| uint8_t scalebits = 0; | |
| uint8_t hi1, lo1, hi2, lo2; | |
| // Determine best prescaler setting for 10-bit timer | |
| do { | |
| scalebits++; | |
| ocr = F_PLL / freq / prescale - 1; | |
| prescale *= 2; | |
| if (prescale >= 16384) { | |
| ocr = 1023; | |
| scalebits = 0b1111; | |
| } | |
| } while (ocr > 1023); | |
| // Set up Timer4 for fast PWM on !OC4A | |
| PLLFRQ = (PLLFRQ & 0xCF) | 0x30; // Route PLL to async clk | |
| TCCR4A = _BV(COM4A0) | _BV(PWM4A); // Clear on match, PWMA on | |
| TCCR4B = _BV(PWM4X) | scalebits; // PWM invert | |
| TCCR4D = 0; // Fast PWM mode | |
| TCCR4E = 0; // Not enhanced mode | |
| DT4 = 0; // No dead time | |
| hi1 = ocr >> 8; | |
| lo1 = ocr & 0xFF; | |
| hi2 = ocr >> 9; | |
| lo2 = (ocr >> 1) & 0xFF; | |
| noInterrupts(); // TC4H accesses MUST be atomic | |
| TC4H = hi1; | |
| OCR4C = lo1; // TOP | |
| TC4H = hi2; | |
| OCR4A = lo2; // 50% duty | |
| interrupts(); | |
| pinMode(5, OUTPUT); // Enable output | |
| delay(time); | |
| pinMode(5, INPUT); // Disable output | |
| TCCR4A = 0; // PWMA off | |
| tone(CPLAY_BUZZER, freq, time); | |
| delay(time); // time argument to tone() isn't working, so... | |
| 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 | |
| double 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); | |
| double 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. | |
| */ | |
| /**************************************************************************/ | |
| 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'. | |
| */ | |
| /**************************************************************************/ | |
| bool Adafruit_CircuitPlayground::isExpress(void) { | |
| return false; | |
| return true; | |
| } | |
| // instantiate static | |
| Adafruit_CircuitPlayground CircuitPlayground; | |