Weihnachtsstern

void runningDots(int speedDelay, int nrSteps) {
    // move a colored dot around and change its color every full round

    int l=0;                // current LED
    byte *rgb;              // red, green ,blue
    unsigned long color;    // color of running pixel

    for(int n=0;n<nrSteps;n++) {
        
        // at the beginning of a new cycle: switch color
        if (l==0) {
            rgb=wheel(random(255));
            color= strip.Color(rgb[0],rgb[1],rgb[2]);
        }
        
        strip.setPixelColor(l,0);           // switch off current LED
        l=(l+1) % NumLeds;                  // advance to next LED
        strip.setPixelColor(l,color);       // set color for next LED
        strip.show();                       // transfer LED settings to the strip
        delay(speedDelay);                  // wait a moment
    }
}

// A star with rainbow colors rotating at adjustable speed
  
int NumLeds         = 14;                       // 7 arms with two LEDs per arm
int touchPins[]     = {32,27,12,13,15,2,33,20}; // arms 0 .. 7
 
#include <Adafruit_NeoPixel.h>
 
Adafruit_NeoPixel strip = Adafruit_NeoPixel(    // define the LED strip (type WS2812)
    NumLeds,                                    // number of color triples
    26,                                         // pin connected to the strip
    NEO_GRB + NEO_KHZ800                        // 800 kHz bit stream in GRB sequence
);
 
byte colorPosition = 0;         // the current position of the color wheel; 0 = red
  
void setup() {
    Serial.begin(115200);       // for monitoring
    delay(100);
     
    strip.begin();              // initialize LED strip
 
    rainbowCycle();             // start the cycle
}
  
void loop() {
}
  
void rainbowCycle() {
      
    byte *c;
    uint16_t l, j;
 
    unsigned long   speedDelay  = 50;   // delay between iterations
    int             gap         =  1;   // gap between color increments
    int             segment     = 10;   // segment size of color circle 
                                        // (10=full, 20=half, ..)
     
    for(;;) {   // forever
         
        // increment color position
        colorPosition= (colorPosition+gap) % 256;
 
        // based on the color position divide the circle into NumLed parts
        // and assign the suitable color to each LED
        // note that this does not yet change the LEDs themselves
        // it only assigns values to the internal memory representation 
        // of the LEDs
  
        // if we divide the circle into smaller portions (e.g. segment=20),
        // only half of the spectrum would be visible at any point in time
 
          
        for(l=0; l< NumLeds; l++) {
            c= wheel(((l * 256 / NumLeds * 10 / segment) 
                + colorPosition) % 256
            );
            strip.setPixelColor(l, *c, *(c+1), *(c+2));
        }
  
        // now transfer the memory as a bit stream to the LED strip
        strip.show();
  
        // check touch sensors
        if (touched(1) && speedDelay<1000) speedDelay++;     // slower
        if (touched(2) && speedDelay>   1) speedDelay--;
        if (touched(3) && gap>1           ) gap--;           // closer
        if (touched(4) && gap<100         ) gap++;
        if (touched(5) && segment>1       ) segment--;       // smaller
        if (touched(6) && segment<50  ) segment++;
        if (touched(0) ) { 
            speedDelay=random(20); 
            gap=random(10); 
            segment=random(10); 
        }
 
        Serial.println(
            "delay="+String(speedDelay)+
            "  gap="+String(gap)+
            "  segment="+String(segment)
        );
  
        // wait before we advance the step counter        
        delay(speedDelay);
    }
}
  
byte *wheel(byte wheelPos) {
    // implements a color circle ("wheel") beginning with 
    //     (1) red, changing to (2) green and (3) to blue
    // the wheel if divided into 256 steps, 
    //     so 0=red, 256/3=green, 256*2/3=blue, etc.
    // the <wheelPos> parameter is a number between 0..255
    // the function returns an RGB array of three bytes
      
    static byte c[3];   // the resulting RGB triple
  
    // we have three segments (0..84, 85..169, 170..255)
    // in each segment one RGB color is completely missing 
    // (i.e. it has a value of 0)
    // another one is growing from 0..255 and the third color 
    // goes down from 255 to 0
    // this means that we have equal brightness 
    // over the whole spectrum
  
    if(wheelPos < 85) {             // first segment 0..84
        c[0]= 255 - wheelPos * 3;   // declining RED
        c[1]= wheelPos * 3;         // growing   GREEN
        c[2]= 0;                    // no        BLUE
      
    } else if(wheelPos < 170) {     // second segment 85..169
        wheelPos -= 85;             // make position relative to segment
        c[0]= 0;                    // no        RED
        c[1]= 255 - wheelPos * 3;   // declining GREEN
        c[2]= wheelPos * 3;         // growing   BLUE
          
    } else {                        // third segment  170..255
        wheelPos -= 170;            // make position relative to segment
        c[0]= wheelPos * 3;         // growing   RED
        c[1]= 0;                    // no        GREEN 
        c[2]= 255 - wheelPos * 3;   // declining BLUE
    }
  
    return c;                       // return the RGB triple
}
 
boolean touched(int arm) {
    int t= touchRead(touchPins[arm]);
    if (t==0) return false;
    if (t< 30) {       // a reasonable threshold is 30
        delay(100);    // wait a moment so the user can release the touch
        return true;        
    }
    return false;
}

// A star with rainbow colors rotating at adjustable speed
// settings are shown on the TFT display
// note that the library for the TFT must have been installed in the Arduino IDE
 
// ===================== DISPLAY ==============
 
#include <SPI.h>                                  // SPI interface for TFT display
#include <TFT_eSPI.h>                                 // Hardware-specific TFT library                                
TFT_eSPI tft = TFT_eSPI();                          // define a variable for the TFT display
 
#define NUM_ARMS  7                                 // the star has 7 arms ("legs")
#define NUM_LEDS (2*NUM_ARMS)                       // we have two LEDs per arm
 
// ===================== LED STRIP ============
 
#include <Adafruit_NeoPixel.h>
Adafruit_NeoPixel strip = Adafruit_NeoPixel(        // define the LED strip (type WS2812)
    NUM_LEDS,                                       // number of color triples
    26,                                             // the pin# connected to the strip
    NEO_GRB + NEO_KHZ800                            // 800 kHz bit stream in GRB sequence
);
byte colorPosition  = 0;                            // initial position of color wheel (0 = red)
 
// ===================== TOUCH PINS ===========
 
int touchPins[] = {32,27,12,13,15,2,33,20};         // pins (#0..#6) connectesd to touch contacts
 
// ===================== SETUP ================
  
void setup() {
    Serial.begin(115200);                           // for monitoring
    delay(100);
 
    tft.begin();                                    // initialize, 240 x 135 pixels (~ 20x4 chars)
    tft.setRotation(1);                             // 1=landscape orientation
    tft.setTextDatum(TL_DATUM);                     // top left reference point for texts
    tft.setTextColor(TFT_WHITE, TFT_BLACK);         // white on black
    tft.fillScreen(TFT_BLACK);                      // clear screen, all black
    tft.setFreeFont(&FreeSans12pt7b);               // fairly large font (allows for 4 lines)
     
    strip.begin();                                  // initialize LED strip
 
    rainbowCycle();                                 // start the cycle
}
  
void loop() {
    // we never get here because rainbowCycle contains and endless loop
}
 
// ===================== RAINBOW ================
  
void rainbowCycle() {
     
    // initial settings:
    unsigned long   speedDelay  = 50;   // delay between iterations in msecs
    int             gap         =  1;   // gap between color increments (wheel steps)
    int             segment     = 10;   // segment size of color circle (10=full, 20=half, ..)
     
    byte *c;                            // a triple of color values obtained from the wheel
 
    tftPrint(0,"Rotating Rainbow");
 
    for(;;) {   // forever
         
        colorPosition = (colorPosition+gap) % 256;      // increment color position
 
        // divide the circle into equi-distant colors for the LEDs
        // if segments==10 use full spectrum, else use less (e.g. 10%) or more (eg 200%)
        // assign a color to each LED starting from the current color position
          
        for(int l=0; l< NUM_LEDS; l++) {
            c= wheel(((l * 256 / NUM_LEDS * 10 / segment) + colorPosition) % 256);
            strip.setPixelColor(l, *c, *(c+1), *(c+2));
        }
  
        strip.show();               // now transfer the LED memory to the LED strip
  
        // check touch sensors and modify settings if desired
        if (touched(1) && speedDelay<1000) speedDelay++;     // slower
        if (touched(2) && speedDelay>   1) speedDelay--;
        if (touched(3) && gap>1           ) gap--;           // closer
        if (touched(4) && gap<100         ) gap++;
        if (touched(5) && segment>1       ) segment--;       // smaller
        if (touched(6) && segment<50  ) segment++;
        if (touched(0) ) { 
            speedDelay=random(20); 
            gap=random(10); 
            segment=random(10); 
        }
        
        // show current settings for debugging on serial line
        Serial.println("delay="+String(speedDelay)+"  gap="+String(gap)+"  segment="+String(segment));
 
        // show current settings for the user on the TFT display
        tftPrint(1,"speed ="+String(speedDelay));
        tftPrint(2,"gap  ="+String(gap));
        tftPrint(3,"segment ="+String(segment));
         
        // wait for the configured time (msecs)        
        delay(speedDelay);
    }
}
 
// ===================== COLOR WHEEL ================
  
byte *wheel(byte wheelPos) {
    // implements a color circle ("wheel") beginning with (1) red, changing to (2) green and (3) to blue
    // the wheel if divided into 256 steps, so 0=red, 256/3=green, 256*2/3=blue, etc.
    // the <wheelPos> parameter is a number between 0..255
    // the function returns an RGB array of three bytes
      
    static byte c[3];   // the resulting RGB triple
  
    // we have three segments (0..84, 85..169, 170..255)
    // in each segment one RGB color is completely missing (i.e. it has a value of 0)
    // another one is growing from 0..255 and the third color goes down from 255 to 0
    // this means that we have equal brightness over the whole spectrum
  
    if(wheelPos < 85) {             // first segment 0..84
        c[0]= 255 - wheelPos * 3;   // declining RED
        c[1]= wheelPos * 3;         // growing   GREEN
        c[2]= 0;                    // no        BLUE
      
    } else if(wheelPos < 170) {     // second segment 85..169
        wheelPos -= 85;             // make position relative to segment start
        c[0]= 0;                    // no        RED
        c[1]= 255 - wheelPos * 3;   // declining GREEN
        c[2]= wheelPos * 3;         // growing   BLUE
          
    } else {                        // third segment  170..255
        wheelPos -= 170;            // make position relative to segment start
        c[0]= wheelPos * 3;         // growing   RED
        c[1]= 0;                    // no        GREEN 
        c[2]= 255 - wheelPos * 3;   // declining BLUE
    }
  
    return c;                       // return the RGB triple
}
 
// ===================== TOUCH DETECTION ================
 
boolean touched(int arm) {
    // return true if the user touches the arm
    // if a touch is detected the function will delay the return for 100 msecs
    // this allows finer control for the user
     
    int t= touchRead(touchPins[arm]);   // high values:untouched, lower values: maybe touched
    if (t==0) return false;             // ignore a value of zero
    if (t< 30) {                     // a reasonable to detect a touch is a value of 30..60
        delay(100);                     // wait a moment so that the user can release the touch
        return true;
    }
    return false;                       // retun immediately if no touch was detected
}
 
// ===================== DISPLAY ================
 
String tftLines[4] = {"","","",""};     // the current four lines shown on the display
 
void tftPrint(int nr, String text) {
    // print text into the specified line (0..3)
 
    // we must fill the text to be shown with spaces; 
    // otherwise portions of previous contents would still be visible 
    // if the new text was shorter than the previous text
    String line = (text+"                    ").substring(0,20);
     
    // In case the text has not changed: do nothing (avoiding flickering of the display)
    if (tftLines[nr]==line) return;
 
    // store line
    tftLines[nr]=line;
     
    // print the line, calculating the vertical position from the line number
    tft.drawString(line,0,nr*33,1); 
}
 
// ===================== END ================

/*
    This program shows rotation rainbow colors and offers a game
    where you try to match a given random color
 
    The program is made of the following components:
        ------------------------------------------------------------
        * Touch pin recognition
        * TFT display control
        * LED strip control and color wheel
        ------------------------------------------------------------
        * Rainbow patterns: arms #1..6 control the pattern, #0=EXIT  
        * ColorMatcher:     arms #1..6 change colors, #0=EXIT
        ------------------------------------------------------------
        * SETUP and LOOP
         ------------------------------------------------------------
 
    VERSION: 5
*/
 
// ===================== TOUCH DETECTION ================
 
int touchPins[]={32,27,12,13,15,2,33};  // pins (#0..#6) connected to touch contacts
 
#define TOUCH_THRESHOLD 20              // values below mean "touched" 
 
boolean touched(int arm, int wait=0) {
    // return true if the user touches the given arm
    // if a touch is detected the function will delay the return for 100 msecs
    // this allows finer control for the user
       
    int t= touchRead(touchPins[arm]);   // high values:untouched, lower values: maybe touched
    if (t==0) return false;             // ignore a value of zero
    if (t<= TOUCH_THRESHOLD) {          // a reasonable to detect a touch is a value of 30..60
        delay(5);                       // try a second time after a short pause
        t =touchRead(touchPins[arm]);
        if (t==0 || t > TOUCH_THRESHOLD) return false;
        delay(wait);                    // wait a moment so that the user can release the touch
        return true;
    }
    return false;                       // return immediately if no touch was detected
}
 
 
// ===================== DISPLAY ================
    
#include <SPI.h>                            // SPI interface for TFT display
#include <TFT_eSPI.h>                       // Hardware-specific TFT library                                
TFT_eSPI tft = TFT_eSPI();                  // define a variable for the TFT display
 
String tftLines[4] = {"","","",""};         // the current four lines shown on the display
 
void tftClear() {
    tft.fillScreen(TFT_BLACK);     
}
void tftPrint(int nr, String text) {
    // print text into the specified line (0..3)
   
    // we must fill the text to be shown with spaces; 
    // otherwise portions of previous content might still be visible 
    // if the new text was shorter than the previous text
    String line = (text+"                    ").substring(0,20);
       
    // In case the text has not changed: do nothing (avoiding flickering of the display)
    if (tftLines[nr]==line) return;
   
    // store line
    tftLines[nr]=line;
       
    // print the line, calculating the vertical position from the line number
    tft.drawString(line,0,nr*33,1); 
}
 
 
// ===================== SOUND BUZZER ================
 
#define BUZZER_PIN      25
#define BUZZER_CHANNEL  0
 
void buzzerSetup() {
    int vol = 64; // 127 = 50% duty cycle = max volume
    int freq = 443;
    int resolution = 8;
    ledcSetup(BUZZER_CHANNEL, freq, resolution);
    ledcAttachPin(BUZZER_PIN, BUZZER_CHANNEL);
    ledcWrite(BUZZER_CHANNEL,vol);              // set duty cycle (aka volume)
    ledcWriteTone(BUZZER_CHANNEL,0);            // mute
}
 
void buzzerPlay(int freq, int duration, int vol) {
    Serial.println("buzzer "+String(freq)+" "+String(duration)+" "+String(vol));
    ledcWrite(BUZZER_CHANNEL,vol); // set duty cycle 0..127 (=50%)
    ledcWriteTone(BUZZER_CHANNEL, freq);
    delay(duration);
    ledcWriteTone(BUZZER_CHANNEL,0);   // mute
}
 
void buzzerPlay(int freq, int duration) {
    buzzerPlay(freq,duration,127);              // use max. volume
}
 
void buzzerBeep() {
    buzzerPlay(443,100,127);    // short note "a"
}
 
 
// ===================== LED STRIP and COLOR WHEEL ============
 
#define NUM_ARMS  7                                 // the star has 7 arms ("legs")
#define NUM_LEDS (2*NUM_ARMS)                       // we have two LEDs per arm
 
#include <Adafruit_NeoPixel.h>
Adafruit_NeoPixel strip = Adafruit_NeoPixel(        // define the LED strip (type WS2812)
    NUM_LEDS,                                       // number of color triples
    26,                                             // the pin# connected to the strip
    NEO_GRB + NEO_KHZ800                            // 800 kHz bit stream in GRB sequence
);
byte colorPosition  = 0;                            // initial position of color wheel (0 = red)
    
byte *wheel(byte wheelPos) {
    // implements a color circle ("wheel") beginning with (1) red, changing to (2) green and (3) to blue
    // the wheel if divided into 256 steps, so 0=red, 256/3=green, 256*2/3=blue, etc.
    // the <wheelPos> parameter is a number between 0..255
    // the function returns an RGB array of three bytes
        
    static byte c[3];   // the resulting RGB triple
    
    // we have three segments (0..84, 85..169, 170..255)
    // in each segment one RGB color is completely missing (i.e. it has a value of 0)
    // another one is growing from 0..255 and the third color goes down from 255 to 0
    // this means that we have equal brightness over the whole spectrum
    
    if(wheelPos < 85) {             // first segment 0..84
        c[0]= 255 - wheelPos * 3;   // declining RED
        c[1]= wheelPos * 3;         // growing   GREEN
        c[2]= 0;                    // no        BLUE
        
    } else if(wheelPos < 170) {     // second segment 85..169
        wheelPos -= 85;             // make position relative to segment start
        c[0]= 0;                    // no        RED
        c[1]= 255 - wheelPos * 3;   // declining GREEN
        c[2]= wheelPos * 3;         // growing   BLUE
            
    } else {                        // third segment  170..255
        wheelPos -= 170;            // make position relative to segment start
        c[0]= wheelPos * 3;         // growing   RED
        c[1]= 0;                    // no        GREEN 
        c[2]= 255 - wheelPos * 3;   // declining BLUE
    }
    
    return c;                       // return the RGB triple
}
 
   
   
// ===================== RAINBOW ================
    
void rainbowCycle() {
 
    tftClear();
    tftPrint(0,"Rotating Rainbow");
 
    unsigned long   speedDelay; // delay between iterations in msecs
    int             gap;        // gap between color increments (wheel steps)
    int             segment;    // segment size of color circle (10=full, 20=half, ..)
 
    // start with random settings:
    speedDelay  = random(20); 
    gap         = random(10); 
    segment     = random(10); 
 
    byte *c;                            // a triple of color values obtained from the wheel
    boolean changed=true;
    for(;;) {   // forever
           
        colorPosition = (colorPosition+gap) % 256;      // increment color position
   
        // divide the circle into equi-distant colors for the LEDs
        // if segments==10 use full spectrum, else use less (e.g. 10%) or more (eg 200%)
        // assign a color to each LED starting from the current color position
            
        for(int l=0; l< NUM_LEDS; l++) {
            c= wheel(((l * 256 / NUM_LEDS * 10 / segment) + colorPosition) % 256);
            strip.setPixelColor(l, *c, *(c+1), *(c+2));
        }
    
        strip.show();               // now transfer the LED memory to the LED strip
    
        // check touch sensors and modify settings if desired
        if (touched(1,100) && speedDelay < 1000 ) { changed=true; speedDelay++; } // slower
        if (touched(2,100) && speedDelay >    1 ) { changed=true; speedDelay--; }
        if (touched(3,100) && gap>1             ) { changed=true; gap--;        } // closer
        if (touched(4,100) && gap<100           ) { changed=true; gap++;        }
        if (touched(5,100) && segment>1         ) { changed=true; segment--;    } // smaller
        if (touched(6,100) && segment<50        ) { changed=true; segment++;    }
          
        // show current settings for debugging on serial line
        if (changed) {
            Serial.println("delay="+String(speedDelay)+"  gap="+String(gap)+"  segment="+String(segment));
            changed=false;
        }
   
        // show current settings for the user on the TFT display
        tftPrint(1,"delay   ="+String(speedDelay));
        tftPrint(2,"gap     ="+String(gap));
        tftPrint(3,"segment ="+String(segment));
           
        // wait for the configured time (msecs)        
        delay(speedDelay);
 
        if (touched(0,400)) break;     // EXIT rainbow if user touches arm #0
    }
}
 
 
// ===================== COLOR MATCH GAME ================
    
void colorMatch(boolean withSound, boolean withHints) {
 
    tftClear();
    tftPrint(0,"Color Matcher");
    tftPrint(1,withSound? "SOUND" : "SILENT");
    tftPrint(2,withHints? "HINTS" : "NO HINTS");
 
    uint8_t r,rr,g,gg,b,bb;
 
    boolean success=true;   // triggers a new color to be chosen
     
    for(;;) {   // forever
 
        if (success) {

            // choose a new color
            rr=random(256), gg=random(256), bb=random(256);    // the color to be matched
            r=10, g=10, b=10;                                  // the current color
            for(int l=0; l< NUM_LEDS; l++) {
                if(l>=3 && l<=10)   strip.setPixelColor(l, r, g, b );
                else                strip.setPixelColor(l, rr,gg,bb);
            }
            strip.show();               // now transfer the LED memory to the LED strip
            success=false;
            tftPrint(3,"");                
        }
 
        // check touch sensors and modify settings if desired
        if (touched(1,5)) if (r<255) r++;
        if (touched(2,5)) if (g<255) g++;
        if (touched(3,5)) if (b<255) b++;
        if (touched(4,5)) if (b>0) b--;
        if (touched(5,5)) if (g>0) g--;
        if (touched(6,5)) if (r>0) r--;
 
        if (touched(1) || touched(2) || touched(3) || touched(4) || touched(5) || touched(6)) {
             
            for(int l=3; l<=10; l++) strip.setPixelColor(l, r ,g ,b );
            strip.show();
             
            int distance = (r-rr)*(r-rr)+(g-gg)*(g-gg)+(b-bb)*(b-bb);   // sum of squares
             
            if (abs(r-rr)<=5 && abs(g-gg)<=5 && abs(b-bb) <=5) {   // success
                tftPrint(3,"well done!");
				// play tone scale
				for (int f=264;f<=264;f++) {
					float freq=f;
					for(int n=0;n<=12;n++) {
						if (n==0||n==2||n==4||n==5||n==7||n==9||n==11|| n==12) buzzerPlay(round(freq),200);
						freq=freq*1.059463;
						delay(100);     
					}
					delay(500);
				}
                success=true;
                for(int n=0;n<5;n++) {
                    delay(200);
                    for(int l=3; l<=10; l++) strip.setPixelColor(l,0,0,0);
                    strip.show();
                    delay(200);
                    for(int l=3; l<=10; l++) strip.setPixelColor(l, r ,g ,b );
                    strip.show();
                }
            }
            else if (abs(r-rr)<=10 && abs(g-gg)<=10 && abs(b-bb) <=10) {   // close
                if (withHints) tftPrint(3,"looks good");
            }
            else if (abs(r-rr)<=20 && abs(g-gg)<=20 && abs(b-bb) <=20) {   // closer
                if (withHints) tftPrint(3,"not bad");
            }
            else {
                tftPrint(3,"");                
            }
            if (withSound && distance<3000) buzzerPlay(800-distance/6,100);   // buzzer feed back
             
            Serial.printf("red %d %d    green %d %d      blue %d %d \n",
                rr,r-rr,gg,g-gg,bb,b-bb);
        }
        if (touched(0,400)) break;     // EXIT rainbow if user touches arm #0
    }
}
 
   
// ===================== SETUP ================
    
void setup() {
    Serial.begin(115200);                           // for monitoring
    delay(100);
   
    tft.begin();                                    // initialize, 240 x 135 pixels (~ 20x4 chars)
    tft.setRotation(1);                             // 1=landscape orientation
    tft.setTextDatum(TL_DATUM);                     // top left reference point for texts
    tft.setTextColor(TFT_WHITE, TFT_BLACK);         // white on black
    tft.fillScreen(TFT_BLACK);                      // clear screen, all black
    tft.setFreeFont(&FreeSans12pt7b);               // fairly large font (allows for 4 lines)
       
    strip.begin();                                  // initialize LED strip
     
    buzzerSetup();                                  // a piezo electric buzzer
    buzzerBeep();
}
    
void loop() {
    // toggle between rainbow and color matching game
    rainbowCycle();
    colorMatch(random(2) ? true:false,random(2) ? true:false);               
}
 
// ===================== END ================