initial commit
This commit is contained in:
@@ -0,0 +1,261 @@
|
||||
#include <Adafruit_NeoPixel.h>
|
||||
#ifdef __AVR__
|
||||
#include <avr/power.h>
|
||||
#endif
|
||||
|
||||
#define PIN 6
|
||||
|
||||
#define NUM_LEDS 60
|
||||
|
||||
#define BRIGHTNESS 50
|
||||
|
||||
Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_LEDS, PIN, NEO_GRBW + NEO_KHZ800);
|
||||
|
||||
byte neopix_gamma[] = {
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5,
|
||||
5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10,
|
||||
10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 16, 16,
|
||||
17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 24, 24, 25,
|
||||
25, 26, 27, 27, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 35, 36,
|
||||
37, 38, 39, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 50,
|
||||
51, 52, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 66, 67, 68,
|
||||
69, 70, 72, 73, 74, 75, 77, 78, 79, 81, 82, 83, 85, 86, 87, 89,
|
||||
90, 92, 93, 95, 96, 98, 99,101,102,104,105,107,109,110,112,114,
|
||||
115,117,119,120,122,124,126,127,129,131,133,135,137,138,140,142,
|
||||
144,146,148,150,152,154,156,158,160,162,164,167,169,171,173,175,
|
||||
177,180,182,184,186,189,191,193,196,198,200,203,205,208,210,213,
|
||||
215,218,220,223,225,228,231,233,236,239,241,244,247,249,252,255 };
|
||||
|
||||
|
||||
void setup() {
|
||||
// This is for Trinket 5V 16MHz, you can remove these three lines if you are not using a Trinket
|
||||
#if defined (__AVR_ATtiny85__)
|
||||
if (F_CPU == 16000000) clock_prescale_set(clock_div_1);
|
||||
#endif
|
||||
// End of trinket special code
|
||||
strip.setBrightness(BRIGHTNESS);
|
||||
strip.begin();
|
||||
strip.show(); // Initialize all pixels to 'off'
|
||||
}
|
||||
|
||||
void loop() {
|
||||
// Some example procedures showing how to display to the pixels:
|
||||
colorWipe(strip.Color(255, 0, 0), 50); // Red
|
||||
colorWipe(strip.Color(0, 255, 0), 50); // Green
|
||||
colorWipe(strip.Color(0, 0, 255), 50); // Blue
|
||||
colorWipe(strip.Color(0, 0, 0, 255), 50); // White
|
||||
|
||||
whiteOverRainbow(20,75,5);
|
||||
|
||||
pulseWhite(5);
|
||||
|
||||
// fullWhite();
|
||||
// delay(2000);
|
||||
|
||||
rainbowFade2White(3,3,1);
|
||||
|
||||
|
||||
}
|
||||
|
||||
// Fill the dots one after the other with a color
|
||||
void colorWipe(uint32_t c, uint8_t wait) {
|
||||
for(uint16_t i=0; i<strip.numPixels(); i++) {
|
||||
strip.setPixelColor(i, c);
|
||||
strip.show();
|
||||
delay(wait);
|
||||
}
|
||||
}
|
||||
|
||||
void pulseWhite(uint8_t wait) {
|
||||
for(int j = 0; j < 256 ; j++){
|
||||
for(uint16_t i=0; i<strip.numPixels(); i++) {
|
||||
strip.setPixelColor(i, strip.Color(0,0,0, neopix_gamma[j] ) );
|
||||
}
|
||||
delay(wait);
|
||||
strip.show();
|
||||
}
|
||||
|
||||
for(int j = 255; j >= 0 ; j--){
|
||||
for(uint16_t i=0; i<strip.numPixels(); i++) {
|
||||
strip.setPixelColor(i, strip.Color(0,0,0, neopix_gamma[j] ) );
|
||||
}
|
||||
delay(wait);
|
||||
strip.show();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void rainbowFade2White(uint8_t wait, int rainbowLoops, int whiteLoops) {
|
||||
float fadeMax = 100.0;
|
||||
int fadeVal = 0;
|
||||
uint32_t wheelVal;
|
||||
int redVal, greenVal, blueVal;
|
||||
|
||||
for(int k = 0 ; k < rainbowLoops ; k ++){
|
||||
|
||||
for(int j=0; j<256; j++) { // 5 cycles of all colors on wheel
|
||||
|
||||
for(int i=0; i< strip.numPixels(); i++) {
|
||||
|
||||
wheelVal = Wheel(((i * 256 / strip.numPixels()) + j) & 255);
|
||||
|
||||
redVal = red(wheelVal) * float(fadeVal/fadeMax);
|
||||
greenVal = green(wheelVal) * float(fadeVal/fadeMax);
|
||||
blueVal = blue(wheelVal) * float(fadeVal/fadeMax);
|
||||
|
||||
strip.setPixelColor( i, strip.Color( redVal, greenVal, blueVal ) );
|
||||
|
||||
}
|
||||
|
||||
//First loop, fade in!
|
||||
if(k == 0 && fadeVal < fadeMax-1) {
|
||||
fadeVal++;
|
||||
}
|
||||
|
||||
//Last loop, fade out!
|
||||
else if(k == rainbowLoops - 1 && j > 255 - fadeMax ){
|
||||
fadeVal--;
|
||||
}
|
||||
|
||||
strip.show();
|
||||
delay(wait);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
delay(500);
|
||||
|
||||
|
||||
for(int k = 0 ; k < whiteLoops ; k ++){
|
||||
|
||||
for(int j = 0; j < 256 ; j++){
|
||||
|
||||
for(uint16_t i=0; i < strip.numPixels(); i++) {
|
||||
strip.setPixelColor(i, strip.Color(0,0,0, neopix_gamma[j] ) );
|
||||
}
|
||||
strip.show();
|
||||
}
|
||||
|
||||
delay(2000);
|
||||
for(int j = 255; j >= 0 ; j--){
|
||||
|
||||
for(uint16_t i=0; i < strip.numPixels(); i++) {
|
||||
strip.setPixelColor(i, strip.Color(0,0,0, neopix_gamma[j] ) );
|
||||
}
|
||||
strip.show();
|
||||
}
|
||||
}
|
||||
|
||||
delay(500);
|
||||
|
||||
|
||||
}
|
||||
|
||||
void whiteOverRainbow(uint8_t wait, uint8_t whiteSpeed, uint8_t whiteLength ) {
|
||||
|
||||
if(whiteLength >= strip.numPixels()) whiteLength = strip.numPixels() - 1;
|
||||
|
||||
int head = whiteLength - 1;
|
||||
int tail = 0;
|
||||
|
||||
int loops = 3;
|
||||
int loopNum = 0;
|
||||
|
||||
static unsigned long lastTime = 0;
|
||||
|
||||
|
||||
while(true){
|
||||
for(int j=0; j<256; j++) {
|
||||
for(uint16_t i=0; i<strip.numPixels(); i++) {
|
||||
if((i >= tail && i <= head) || (tail > head && i >= tail) || (tail > head && i <= head) ){
|
||||
strip.setPixelColor(i, strip.Color(0,0,0, 255 ) );
|
||||
}
|
||||
else{
|
||||
strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
if(millis() - lastTime > whiteSpeed) {
|
||||
head++;
|
||||
tail++;
|
||||
if(head == strip.numPixels()){
|
||||
loopNum++;
|
||||
}
|
||||
lastTime = millis();
|
||||
}
|
||||
|
||||
if(loopNum == loops) return;
|
||||
|
||||
head%=strip.numPixels();
|
||||
tail%=strip.numPixels();
|
||||
strip.show();
|
||||
delay(wait);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
void fullWhite() {
|
||||
|
||||
for(uint16_t i=0; i<strip.numPixels(); i++) {
|
||||
strip.setPixelColor(i, strip.Color(0,0,0, 255 ) );
|
||||
}
|
||||
strip.show();
|
||||
}
|
||||
|
||||
|
||||
// Slightly different, this makes the rainbow equally distributed throughout
|
||||
void rainbowCycle(uint8_t wait) {
|
||||
uint16_t i, j;
|
||||
|
||||
for(j=0; j<256 * 5; j++) { // 5 cycles of all colors on wheel
|
||||
for(i=0; i< strip.numPixels(); i++) {
|
||||
strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
|
||||
}
|
||||
strip.show();
|
||||
delay(wait);
|
||||
}
|
||||
}
|
||||
|
||||
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));
|
||||
}
|
||||
strip.show();
|
||||
delay(wait);
|
||||
}
|
||||
}
|
||||
|
||||
// Input a value 0 to 255 to get a color value.
|
||||
// The colours are a transition r - g - b - back to r.
|
||||
uint32_t Wheel(byte WheelPos) {
|
||||
WheelPos = 255 - WheelPos;
|
||||
if(WheelPos < 85) {
|
||||
return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3,0);
|
||||
}
|
||||
if(WheelPos < 170) {
|
||||
WheelPos -= 85;
|
||||
return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3,0);
|
||||
}
|
||||
WheelPos -= 170;
|
||||
return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0,0);
|
||||
}
|
||||
|
||||
uint8_t red(uint32_t c) {
|
||||
return (c >> 16);
|
||||
}
|
||||
uint8_t green(uint32_t c) {
|
||||
return (c >> 8);
|
||||
}
|
||||
uint8_t blue(uint32_t c) {
|
||||
return (c);
|
||||
}
|
||||
|
||||
133
libraries/Adafruit_NeoPixel/examples/StrandtestBLE/BLESerial.cpp
Normal file
133
libraries/Adafruit_NeoPixel/examples/StrandtestBLE/BLESerial.cpp
Normal file
@@ -0,0 +1,133 @@
|
||||
#include "BLESerial.h"
|
||||
|
||||
// #define BLE_SERIAL_DEBUG
|
||||
|
||||
BLESerial* BLESerial::_instance = NULL;
|
||||
|
||||
BLESerial::BLESerial(unsigned char req, unsigned char rdy, unsigned char rst) :
|
||||
BLEPeripheral(req, rdy, rst)
|
||||
{
|
||||
this->_txCount = 0;
|
||||
this->_rxHead = this->_rxTail = 0;
|
||||
this->_flushed = 0;
|
||||
BLESerial::_instance = this;
|
||||
|
||||
addAttribute(this->_uartService);
|
||||
addAttribute(this->_uartNameDescriptor);
|
||||
setAdvertisedServiceUuid(this->_uartService.uuid());
|
||||
addAttribute(this->_rxCharacteristic);
|
||||
addAttribute(this->_rxNameDescriptor);
|
||||
this->_rxCharacteristic.setEventHandler(BLEWritten, BLESerial::_received);
|
||||
addAttribute(this->_txCharacteristic);
|
||||
addAttribute(this->_txNameDescriptor);
|
||||
}
|
||||
|
||||
void BLESerial::begin(...) {
|
||||
BLEPeripheral::begin();
|
||||
#ifdef BLE_SERIAL_DEBUG
|
||||
Serial.println(F("BLESerial::begin()"));
|
||||
#endif
|
||||
}
|
||||
|
||||
void BLESerial::poll() {
|
||||
if (millis() < this->_flushed + 100) {
|
||||
BLEPeripheral::poll();
|
||||
} else {
|
||||
flush();
|
||||
}
|
||||
}
|
||||
|
||||
void BLESerial::end() {
|
||||
this->_rxCharacteristic.setEventHandler(BLEWritten, NULL);
|
||||
this->_rxHead = this->_rxTail = 0;
|
||||
flush();
|
||||
BLEPeripheral::disconnect();
|
||||
}
|
||||
|
||||
int BLESerial::available(void) {
|
||||
BLEPeripheral::poll();
|
||||
int retval = (this->_rxHead - this->_rxTail + sizeof(this->_rxBuffer)) % sizeof(this->_rxBuffer);
|
||||
#ifdef BLE_SERIAL_DEBUG
|
||||
Serial.print(F("BLESerial::available() = "));
|
||||
Serial.println(retval);
|
||||
#endif
|
||||
return retval;
|
||||
}
|
||||
|
||||
int BLESerial::peek(void) {
|
||||
BLEPeripheral::poll();
|
||||
if (this->_rxTail == this->_rxHead) return -1;
|
||||
uint8_t byte = this->_rxBuffer[this->_rxTail];
|
||||
#ifdef BLE_SERIAL_DEBUG
|
||||
Serial.print(F("BLESerial::peek() = "));
|
||||
Serial.print((char) byte);
|
||||
Serial.print(F(" 0x"));
|
||||
Serial.println(byte, HEX);
|
||||
#endif
|
||||
return byte;
|
||||
}
|
||||
|
||||
int BLESerial::read(void) {
|
||||
BLEPeripheral::poll();
|
||||
if (this->_rxTail == this->_rxHead) return -1;
|
||||
this->_rxTail = (this->_rxTail + 1) % sizeof(this->_rxBuffer);
|
||||
uint8_t byte = this->_rxBuffer[this->_rxTail];
|
||||
#ifdef BLE_SERIAL_DEBUG
|
||||
Serial.print(F("BLESerial::read() = "));
|
||||
Serial.print((char) byte);
|
||||
Serial.print(F(" 0x"));
|
||||
Serial.println(byte, HEX);
|
||||
#endif
|
||||
return byte;
|
||||
}
|
||||
|
||||
void BLESerial::flush(void) {
|
||||
if (this->_txCount == 0) return;
|
||||
this->_txCharacteristic.setValue(this->_txBuffer, this->_txCount);
|
||||
this->_flushed = millis();
|
||||
this->_txCount = 0;
|
||||
BLEPeripheral::poll();
|
||||
#ifdef BLE_SERIAL_DEBUG
|
||||
Serial.println(F("BLESerial::flush()"));
|
||||
#endif
|
||||
}
|
||||
|
||||
size_t BLESerial::write(uint8_t byte) {
|
||||
BLEPeripheral::poll();
|
||||
if (this->_txCharacteristic.subscribed() == false) return 0;
|
||||
this->_txBuffer[this->_txCount++] = byte;
|
||||
if (this->_txCount == sizeof(this->_txBuffer)) flush();
|
||||
#ifdef BLE_SERIAL_DEBUG
|
||||
Serial.print(F("BLESerial::write("));
|
||||
Serial.print((char) byte);
|
||||
Serial.print(F(" 0x"));
|
||||
Serial.print(byte, HEX);
|
||||
Serial.println(F(") = 1"));
|
||||
#endif
|
||||
return 1;
|
||||
}
|
||||
|
||||
BLESerial::operator bool() {
|
||||
bool retval = BLEPeripheral::connected();
|
||||
#ifdef BLE_SERIAL_DEBUG
|
||||
Serial.print(F("BLESerial::operator bool() = "));
|
||||
Serial.println(retval);
|
||||
#endif
|
||||
return retval;
|
||||
}
|
||||
|
||||
void BLESerial::_received(const uint8_t* data, size_t size) {
|
||||
for (int i = 0; i < size; i++) {
|
||||
this->_rxHead = (this->_rxHead + 1) % sizeof(this->_rxBuffer);
|
||||
this->_rxBuffer[this->_rxHead] = data[i];
|
||||
}
|
||||
#ifdef BLE_SERIAL_DEBUG
|
||||
Serial.print(F("BLESerial::received("));
|
||||
for (int i = 0; i < size; i++) Serial.print((char) data[i]);
|
||||
Serial.println(F(")"));
|
||||
#endif
|
||||
}
|
||||
|
||||
void BLESerial::_received(BLECentral& /*central*/, BLECharacteristic& rxCharacteristic) {
|
||||
BLESerial::_instance->_received(rxCharacteristic.value(), rxCharacteristic.valueLength());
|
||||
}
|
||||
@@ -0,0 +1,46 @@
|
||||
#ifndef _BLE_SERIAL_H_
|
||||
#define _BLE_SERIAL_H_
|
||||
|
||||
#include <Arduino.h>
|
||||
#include <BLEPeripheral.h>
|
||||
|
||||
class BLESerial : public BLEPeripheral, public Stream
|
||||
{
|
||||
public:
|
||||
BLESerial(unsigned char req, unsigned char rdy, unsigned char rst);
|
||||
|
||||
void begin(...);
|
||||
void poll();
|
||||
void end();
|
||||
|
||||
virtual int available(void);
|
||||
virtual int peek(void);
|
||||
virtual int read(void);
|
||||
virtual void flush(void);
|
||||
virtual size_t write(uint8_t byte);
|
||||
using Print::write;
|
||||
virtual operator bool();
|
||||
|
||||
private:
|
||||
unsigned long _flushed;
|
||||
static BLESerial* _instance;
|
||||
|
||||
size_t _rxHead;
|
||||
size_t _rxTail;
|
||||
size_t _rxCount() const;
|
||||
uint8_t _rxBuffer[BLE_ATTRIBUTE_MAX_VALUE_LENGTH];
|
||||
size_t _txCount;
|
||||
uint8_t _txBuffer[BLE_ATTRIBUTE_MAX_VALUE_LENGTH];
|
||||
|
||||
BLEService _uartService = BLEService("6E400001-B5A3-F393-E0A9-E50E24DCCA9E");
|
||||
BLEDescriptor _uartNameDescriptor = BLEDescriptor("2901", "UART");
|
||||
BLECharacteristic _rxCharacteristic = BLECharacteristic("6E400002-B5A3-F393-E0A9-E50E24DCCA9E", BLEWriteWithoutResponse, BLE_ATTRIBUTE_MAX_VALUE_LENGTH);
|
||||
BLEDescriptor _rxNameDescriptor = BLEDescriptor("2901", "RX - Receive Data (Write)");
|
||||
BLECharacteristic _txCharacteristic = BLECharacteristic("6E400003-B5A3-F393-E0A9-E50E24DCCA9E", BLENotify, BLE_ATTRIBUTE_MAX_VALUE_LENGTH);
|
||||
BLEDescriptor _txNameDescriptor = BLEDescriptor("2901", "TX - Transfer Data (Notify)");
|
||||
|
||||
void _received(const uint8_t* data, size_t size);
|
||||
static void _received(BLECentral& /*central*/, BLECharacteristic& rxCharacteristic);
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,208 @@
|
||||
/****************************************************************************
|
||||
* This example was developed by the Hackerspace San Salvador to demonstrate
|
||||
* the simultaneous use of the NeoPixel library and the Bluetooth SoftDevice.
|
||||
* To compile this example you'll need to add support for the NRF52 based
|
||||
* following the instructions at:
|
||||
* https://github.com/sandeepmistry/arduino-nRF5
|
||||
* Or adding the following URL to the board manager URLs on Arduino preferences:
|
||||
* https://sandeepmistry.github.io/arduino-nRF5/package_nRF5_boards_index.json
|
||||
* Then you can install the BLEPeripheral library avaiable at:
|
||||
* https://github.com/sandeepmistry/arduino-BLEPeripheral
|
||||
* To test it, compile this example and use the UART module from the nRF
|
||||
* Toolbox App for Android. Edit the interface and send the characters
|
||||
* 'a' to 'i' to switch the animation.
|
||||
* There is a delay because this example blocks the thread of execution but
|
||||
* the change will be shown after the current animation ends. (This might
|
||||
* take a couple of seconds)
|
||||
* For more info write us at: info _at- teubi.co
|
||||
*/
|
||||
#include <SPI.h>
|
||||
#include <BLEPeripheral.h>
|
||||
#include "BLESerial.h"
|
||||
#include <Adafruit_NeoPixel.h>
|
||||
|
||||
#define PIN 15
|
||||
|
||||
// Parameter 1 = number of pixels in strip
|
||||
// Parameter 2 = Arduino pin number (most are valid)
|
||||
// Parameter 3 = pixel type flags, add together as needed:
|
||||
// NEO_KHZ800 800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
|
||||
// NEO_KHZ400 400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
|
||||
// NEO_GRB Pixels are wired for GRB bitstream (most NeoPixel products)
|
||||
// NEO_RGB Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
|
||||
// NEO_RGBW Pixels are wired for RGBW bitstream (NeoPixel RGBW products)
|
||||
Adafruit_NeoPixel strip = Adafruit_NeoPixel(64, PIN, NEO_GRB + NEO_KHZ800);
|
||||
|
||||
// IMPORTANT: To reduce NeoPixel burnout risk, add 1000 uF capacitor across
|
||||
// pixel power leads, add 300 - 500 Ohm resistor on first pixel's data input
|
||||
// and minimize distance between Arduino and first pixel. Avoid connecting
|
||||
// on a live circuit...if you must, connect GND first.
|
||||
|
||||
// define pins (varies per shield/board)
|
||||
#define BLE_REQ 10
|
||||
#define BLE_RDY 2
|
||||
#define BLE_RST 9
|
||||
|
||||
// create ble serial instance, see pinouts above
|
||||
BLESerial BLESerial(BLE_REQ, BLE_RDY, BLE_RST);
|
||||
|
||||
uint8_t current_state = 0;
|
||||
uint8_t rgb_values[3];
|
||||
|
||||
void setup() {
|
||||
Serial.begin(115200);
|
||||
Serial.println("Hello World!");
|
||||
// custom services and characteristics can be added as well
|
||||
BLESerial.setLocalName("UART_HS");
|
||||
BLESerial.begin();
|
||||
|
||||
strip.begin();
|
||||
changeColor(strip.Color(0, 0, 0));
|
||||
|
||||
//pinMode(PIN, OUTPUT);
|
||||
//digitalWrite(PIN, LOW);
|
||||
|
||||
current_state = 'a';
|
||||
}
|
||||
|
||||
|
||||
void loop() {
|
||||
while(BLESerial.available()) {
|
||||
uint8_t character = BLESerial.read();
|
||||
switch(character) {
|
||||
case 'a':
|
||||
case 'b':
|
||||
case 'c':
|
||||
case 'd':
|
||||
case 'e':
|
||||
case 'f':
|
||||
case 'g':
|
||||
case 'h':
|
||||
case 'i':
|
||||
current_state = character;
|
||||
break;
|
||||
};
|
||||
}
|
||||
switch(current_state) {
|
||||
case 'a':
|
||||
colorWipe(strip.Color(255, 0, 0), 20); // Red
|
||||
break;
|
||||
case 'b':
|
||||
colorWipe(strip.Color(0, 255, 0), 20); // Green
|
||||
break;
|
||||
case 'c':
|
||||
colorWipe(strip.Color(0, 0, 255), 20); // Blue
|
||||
break;
|
||||
case 'd':
|
||||
theaterChase(strip.Color(255, 0, 0), 20); // Red
|
||||
break;
|
||||
case 'e':
|
||||
theaterChase(strip.Color(0, 255, 0), 20); // Green
|
||||
break;
|
||||
case 'f':
|
||||
theaterChase(strip.Color(255, 0, 255), 20); // Green
|
||||
break;
|
||||
case 'g':
|
||||
rainbowCycle(20);
|
||||
break;
|
||||
case 'h':
|
||||
rainbow(20);
|
||||
break;
|
||||
case 'i':
|
||||
theaterChaseRainbow(20);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void changeColor(uint32_t c) {
|
||||
for(uint16_t i=0; i<strip.numPixels(); i++) {
|
||||
strip.setPixelColor(i, c);
|
||||
}
|
||||
strip.show();
|
||||
}
|
||||
|
||||
// Fill the dots one after the other with a color
|
||||
void colorWipe(uint32_t c, uint8_t wait) {
|
||||
for(uint16_t i=0; i<strip.numPixels(); i++) {
|
||||
strip.setPixelColor(i, c);
|
||||
delay(wait);
|
||||
strip.show();
|
||||
delay(wait);
|
||||
}
|
||||
}
|
||||
|
||||
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));
|
||||
}
|
||||
strip.show();
|
||||
delay(wait);
|
||||
}
|
||||
}
|
||||
|
||||
// Slightly different, this makes the rainbow equally distributed throughout
|
||||
void rainbowCycle(uint8_t wait) {
|
||||
uint16_t i, j;
|
||||
|
||||
for(j=0; j<256*5; j++) { // 5 cycles of all colors on wheel
|
||||
for(i=0; i< strip.numPixels(); i++) {
|
||||
strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
|
||||
}
|
||||
strip.show();
|
||||
delay(wait);
|
||||
}
|
||||
}
|
||||
|
||||
//Theatre-style crawling lights.
|
||||
void theaterChase(uint32_t c, uint8_t wait) {
|
||||
for (int j=0; j<10; j++) { //do 10 cycles of chasing
|
||||
for (int q=0; q < 3; q++) {
|
||||
for (uint16_t i=0; i < strip.numPixels(); i=i+3) {
|
||||
strip.setPixelColor(i+q, c); //turn every third pixel on
|
||||
}
|
||||
strip.show();
|
||||
|
||||
delay(wait);
|
||||
|
||||
for (uint16_t i=0; i < strip.numPixels(); i=i+3) {
|
||||
strip.setPixelColor(i+q, 0); //turn every third pixel off
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//Theatre-style crawling lights with rainbow effect
|
||||
void theaterChaseRainbow(uint8_t wait) {
|
||||
for (int j=0; j < 256; j++) { // cycle all 256 colors in the wheel
|
||||
for (int q=0; q < 3; q++) {
|
||||
for (uint16_t i=0; i < strip.numPixels(); i=i+3) {
|
||||
strip.setPixelColor(i+q, Wheel( (i+j) % 255)); //turn every third pixel on
|
||||
}
|
||||
strip.show();
|
||||
|
||||
delay(wait);
|
||||
|
||||
for (uint16_t i=0; i < strip.numPixels(); i=i+3) {
|
||||
strip.setPixelColor(i+q, 0); //turn every third pixel off
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Input a value 0 to 255 to get a color value.
|
||||
// The colours are a transition r - g - b - back to r.
|
||||
uint32_t Wheel(byte 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);
|
||||
}
|
||||
@@ -0,0 +1,165 @@
|
||||
// This is a demonstration on how to use an input device to trigger changes on your neo pixels.
|
||||
// You should wire a momentary push button to connect from ground to a digital IO pin. When you
|
||||
// press the button it will change to a new pixel animation. Note that you need to press the
|
||||
// button once to start the first animation!
|
||||
|
||||
#include <Adafruit_NeoPixel.h>
|
||||
|
||||
#define BUTTON_PIN 2 // Digital IO pin connected to the button. This will be
|
||||
// driven with a pull-up resistor so the switch should
|
||||
// pull the pin to ground momentarily. On a high -> low
|
||||
// transition the button press logic will execute.
|
||||
|
||||
#define PIXEL_PIN 6 // Digital IO pin connected to the NeoPixels.
|
||||
|
||||
#define PIXEL_COUNT 16
|
||||
|
||||
// Parameter 1 = number of pixels in strip, neopixel stick has 8
|
||||
// Parameter 2 = pin number (most are valid)
|
||||
// Parameter 3 = pixel type flags, add together as needed:
|
||||
// NEO_RGB Pixels are wired for RGB bitstream
|
||||
// NEO_GRB Pixels are wired for GRB bitstream, correct for neopixel stick
|
||||
// NEO_KHZ400 400 KHz bitstream (e.g. FLORA pixels)
|
||||
// NEO_KHZ800 800 KHz bitstream (e.g. High Density LED strip), correct for neopixel stick
|
||||
Adafruit_NeoPixel strip = Adafruit_NeoPixel(PIXEL_COUNT, PIXEL_PIN, NEO_GRB + NEO_KHZ800);
|
||||
|
||||
bool oldState = HIGH;
|
||||
int showType = 0;
|
||||
|
||||
void setup() {
|
||||
pinMode(BUTTON_PIN, INPUT_PULLUP);
|
||||
strip.begin();
|
||||
strip.show(); // Initialize all pixels to 'off'
|
||||
}
|
||||
|
||||
void loop() {
|
||||
// Get current button state.
|
||||
bool newState = digitalRead(BUTTON_PIN);
|
||||
|
||||
// Check if state changed from high to low (button press).
|
||||
if (newState == LOW && oldState == HIGH) {
|
||||
// Short delay to debounce button.
|
||||
delay(20);
|
||||
// Check if button is still low after debounce.
|
||||
newState = digitalRead(BUTTON_PIN);
|
||||
if (newState == LOW) {
|
||||
showType++;
|
||||
if (showType > 9)
|
||||
showType=0;
|
||||
startShow(showType);
|
||||
}
|
||||
}
|
||||
|
||||
// Set the last button state to the old state.
|
||||
oldState = newState;
|
||||
}
|
||||
|
||||
void startShow(int i) {
|
||||
switch(i){
|
||||
case 0: colorWipe(strip.Color(0, 0, 0), 50); // Black/off
|
||||
break;
|
||||
case 1: colorWipe(strip.Color(255, 0, 0), 50); // Red
|
||||
break;
|
||||
case 2: colorWipe(strip.Color(0, 255, 0), 50); // Green
|
||||
break;
|
||||
case 3: colorWipe(strip.Color(0, 0, 255), 50); // Blue
|
||||
break;
|
||||
case 4: theaterChase(strip.Color(127, 127, 127), 50); // White
|
||||
break;
|
||||
case 5: theaterChase(strip.Color(127, 0, 0), 50); // Red
|
||||
break;
|
||||
case 6: theaterChase(strip.Color( 0, 0, 127), 50); // Blue
|
||||
break;
|
||||
case 7: rainbow(20);
|
||||
break;
|
||||
case 8: rainbowCycle(20);
|
||||
break;
|
||||
case 9: theaterChaseRainbow(50);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Fill the dots one after the other with a color
|
||||
void colorWipe(uint32_t c, uint8_t wait) {
|
||||
for(uint16_t i=0; i<strip.numPixels(); i++) {
|
||||
strip.setPixelColor(i, c);
|
||||
strip.show();
|
||||
delay(wait);
|
||||
}
|
||||
}
|
||||
|
||||
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));
|
||||
}
|
||||
strip.show();
|
||||
delay(wait);
|
||||
}
|
||||
}
|
||||
|
||||
// Slightly different, this makes the rainbow equally distributed throughout
|
||||
void rainbowCycle(uint8_t wait) {
|
||||
uint16_t i, j;
|
||||
|
||||
for(j=0; j<256*5; j++) { // 5 cycles of all colors on wheel
|
||||
for(i=0; i< strip.numPixels(); i++) {
|
||||
strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
|
||||
}
|
||||
strip.show();
|
||||
delay(wait);
|
||||
}
|
||||
}
|
||||
|
||||
//Theatre-style crawling lights.
|
||||
void theaterChase(uint32_t c, uint8_t wait) {
|
||||
for (int j=0; j<10; j++) { //do 10 cycles of chasing
|
||||
for (int q=0; q < 3; q++) {
|
||||
for (int i=0; i < strip.numPixels(); i=i+3) {
|
||||
strip.setPixelColor(i+q, c); //turn every third pixel on
|
||||
}
|
||||
strip.show();
|
||||
|
||||
delay(wait);
|
||||
|
||||
for (int i=0; i < strip.numPixels(); i=i+3) {
|
||||
strip.setPixelColor(i+q, 0); //turn every third pixel off
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//Theatre-style crawling lights with rainbow effect
|
||||
void theaterChaseRainbow(uint8_t wait) {
|
||||
for (int j=0; j < 256; j++) { // cycle all 256 colors in the wheel
|
||||
for (int q=0; q < 3; q++) {
|
||||
for (int i=0; i < strip.numPixels(); i=i+3) {
|
||||
strip.setPixelColor(i+q, Wheel( (i+j) % 255)); //turn every third pixel on
|
||||
}
|
||||
strip.show();
|
||||
|
||||
delay(wait);
|
||||
|
||||
for (int i=0; i < strip.numPixels(); i=i+3) {
|
||||
strip.setPixelColor(i+q, 0); //turn every third pixel off
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Input a value 0 to 255 to get a color value.
|
||||
// The colours are a transition r - g - b - back to r.
|
||||
uint32_t Wheel(byte 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);
|
||||
}
|
||||
47
libraries/Adafruit_NeoPixel/examples/simple/simple.ino
Normal file
47
libraries/Adafruit_NeoPixel/examples/simple/simple.ino
Normal file
@@ -0,0 +1,47 @@
|
||||
// NeoPixel Ring simple sketch (c) 2013 Shae Erisson
|
||||
// released under the GPLv3 license to match the rest of the AdaFruit NeoPixel library
|
||||
|
||||
#include <Adafruit_NeoPixel.h>
|
||||
#ifdef __AVR__
|
||||
#include <avr/power.h>
|
||||
#endif
|
||||
|
||||
// Which pin on the Arduino is connected to the NeoPixels?
|
||||
// On a Trinket or Gemma we suggest changing this to 1
|
||||
#define PIN 6
|
||||
|
||||
// How many NeoPixels are attached to the Arduino?
|
||||
#define NUMPIXELS 16
|
||||
|
||||
// When we setup the NeoPixel library, we tell it how many pixels, and which pin to use to send signals.
|
||||
// Note that for older NeoPixel strips you might need to change the third parameter--see the strandtest
|
||||
// example for more information on possible values.
|
||||
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
|
||||
|
||||
int delayval = 500; // delay for half a second
|
||||
|
||||
void setup() {
|
||||
// This is for Trinket 5V 16MHz, you can remove these three lines if you are not using a Trinket
|
||||
#if defined (__AVR_ATtiny85__)
|
||||
if (F_CPU == 16000000) clock_prescale_set(clock_div_1);
|
||||
#endif
|
||||
// End of trinket special code
|
||||
|
||||
pixels.begin(); // This initializes the NeoPixel library.
|
||||
}
|
||||
|
||||
void loop() {
|
||||
|
||||
// For a set of NeoPixels the first NeoPixel is 0, second is 1, all the way up to the count of pixels minus one.
|
||||
|
||||
for(int i=0;i<NUMPIXELS;i++){
|
||||
|
||||
// pixels.Color takes RGB values, from 0,0,0 up to 255,255,255
|
||||
pixels.setPixelColor(i, pixels.Color(0,150,0)); // Moderately bright green color.
|
||||
|
||||
pixels.show(); // This sends the updated pixel color to the hardware.
|
||||
|
||||
delay(delayval); // Delay for a period of time (in milliseconds).
|
||||
|
||||
}
|
||||
}
|
||||
134
libraries/Adafruit_NeoPixel/examples/strandtest/strandtest.ino
Normal file
134
libraries/Adafruit_NeoPixel/examples/strandtest/strandtest.ino
Normal file
@@ -0,0 +1,134 @@
|
||||
#include <Adafruit_NeoPixel.h>
|
||||
#ifdef __AVR__
|
||||
#include <avr/power.h>
|
||||
#endif
|
||||
|
||||
#define PIN 6
|
||||
|
||||
// Parameter 1 = number of pixels in strip
|
||||
// Parameter 2 = Arduino pin number (most are valid)
|
||||
// Parameter 3 = pixel type flags, add together as needed:
|
||||
// NEO_KHZ800 800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
|
||||
// NEO_KHZ400 400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
|
||||
// NEO_GRB Pixels are wired for GRB bitstream (most NeoPixel products)
|
||||
// NEO_RGB Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
|
||||
// NEO_RGBW Pixels are wired for RGBW bitstream (NeoPixel RGBW products)
|
||||
Adafruit_NeoPixel strip = Adafruit_NeoPixel(60, PIN, NEO_GRB + NEO_KHZ800);
|
||||
|
||||
// IMPORTANT: To reduce NeoPixel burnout risk, add 1000 uF capacitor across
|
||||
// pixel power leads, add 300 - 500 Ohm resistor on first pixel's data input
|
||||
// and minimize distance between Arduino and first pixel. Avoid connecting
|
||||
// on a live circuit...if you must, connect GND first.
|
||||
|
||||
void setup() {
|
||||
// This is for Trinket 5V 16MHz, you can remove these three lines if you are not using a Trinket
|
||||
#if defined (__AVR_ATtiny85__)
|
||||
if (F_CPU == 16000000) clock_prescale_set(clock_div_1);
|
||||
#endif
|
||||
// End of trinket special code
|
||||
|
||||
|
||||
strip.begin();
|
||||
strip.show(); // Initialize all pixels to 'off'
|
||||
}
|
||||
|
||||
void loop() {
|
||||
// Some example procedures showing how to display to the pixels:
|
||||
colorWipe(strip.Color(255, 0, 0), 50); // Red
|
||||
colorWipe(strip.Color(0, 255, 0), 50); // Green
|
||||
colorWipe(strip.Color(0, 0, 255), 50); // Blue
|
||||
//colorWipe(strip.Color(0, 0, 0, 255), 50); // White RGBW
|
||||
// Send a theater pixel chase in...
|
||||
theaterChase(strip.Color(127, 127, 127), 50); // White
|
||||
theaterChase(strip.Color(127, 0, 0), 50); // Red
|
||||
theaterChase(strip.Color(0, 0, 127), 50); // Blue
|
||||
|
||||
rainbow(20);
|
||||
rainbowCycle(20);
|
||||
theaterChaseRainbow(50);
|
||||
}
|
||||
|
||||
// Fill the dots one after the other with a color
|
||||
void colorWipe(uint32_t c, uint8_t wait) {
|
||||
for(uint16_t i=0; i<strip.numPixels(); i++) {
|
||||
strip.setPixelColor(i, c);
|
||||
strip.show();
|
||||
delay(wait);
|
||||
}
|
||||
}
|
||||
|
||||
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));
|
||||
}
|
||||
strip.show();
|
||||
delay(wait);
|
||||
}
|
||||
}
|
||||
|
||||
// Slightly different, this makes the rainbow equally distributed throughout
|
||||
void rainbowCycle(uint8_t wait) {
|
||||
uint16_t i, j;
|
||||
|
||||
for(j=0; j<256*5; j++) { // 5 cycles of all colors on wheel
|
||||
for(i=0; i< strip.numPixels(); i++) {
|
||||
strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
|
||||
}
|
||||
strip.show();
|
||||
delay(wait);
|
||||
}
|
||||
}
|
||||
|
||||
//Theatre-style crawling lights.
|
||||
void theaterChase(uint32_t c, uint8_t wait) {
|
||||
for (int j=0; j<10; j++) { //do 10 cycles of chasing
|
||||
for (int q=0; q < 3; q++) {
|
||||
for (uint16_t i=0; i < strip.numPixels(); i=i+3) {
|
||||
strip.setPixelColor(i+q, c); //turn every third pixel on
|
||||
}
|
||||
strip.show();
|
||||
|
||||
delay(wait);
|
||||
|
||||
for (uint16_t i=0; i < strip.numPixels(); i=i+3) {
|
||||
strip.setPixelColor(i+q, 0); //turn every third pixel off
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//Theatre-style crawling lights with rainbow effect
|
||||
void theaterChaseRainbow(uint8_t wait) {
|
||||
for (int j=0; j < 256; j++) { // cycle all 256 colors in the wheel
|
||||
for (int q=0; q < 3; q++) {
|
||||
for (uint16_t i=0; i < strip.numPixels(); i=i+3) {
|
||||
strip.setPixelColor(i+q, Wheel( (i+j) % 255)); //turn every third pixel on
|
||||
}
|
||||
strip.show();
|
||||
|
||||
delay(wait);
|
||||
|
||||
for (uint16_t i=0; i < strip.numPixels(); i=i+3) {
|
||||
strip.setPixelColor(i+q, 0); //turn every third pixel off
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Input a value 0 to 255 to get a color value.
|
||||
// The colours are a transition r - g - b - back to r.
|
||||
uint32_t Wheel(byte 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);
|
||||
}
|
||||
Reference in New Issue
Block a user