Code für das Lightning Kit


Im mitgelieferten Handbuch zum Starter Kit findest du alle Erläuterungen zum Code und natürlich alle Bauteile, damit dir jedes Projekt gelingt!



#include <CodinoLightning.h>

#define anzahlPixel 60

#define PIN 6

#define ledTyp WS2811

#define farbanordnung GRB

#define helligkeit 96

CRGB leds[anzahlPixel];

 

void setup() {    /* Weiter geht’s mit dem Set-Up Bereich! */

 

delay(2000);

FastLED.addLeds<ledTyp,PIN,farbanordnung>(leds, anzahlPixel).setCorrection(TypicalLEDStrip);

 

FastLED.setBrightness(helligkeit);

 

for(int i = 0; i <= anzahlPixel; i++)

 {

   leds[i] = CRGB::White;

delay(100);

FastLED.show();

 } /* Jetzt endet die for-Schleife und die Variable i wird um 1 erhöht. */

 

 

} /* Hier endet die void-Setup Funktion. */

 

void loop() {

 

}

#include <CodinoLightning.h>

 

CodinoLightning codino = CodinoLightning();

 

#define anzahlPixel 60

#define PIN 6

 

#define ledTyp    WS2811

#define farbanordnung GRB

 

#define helligkeit 50

#define taster 8

int tasteDruck = 0;

int animation;

 

CRGB leds[anzahlPixel];

 

void setup() {

 

 delay(2000);

 FastLED.addLeds<ledTyp,PIN,farbanordnung>(leds, anzahlPixel).setCorrection(TypicalLEDStrip);

 

 FastLED.setBrightness(helligkeit);

 

 pinMode(taster,INPUT);

}

 

void loop()

{

 

 

tasteDruck = digitalRead(taster);

 

if(tasteDruck == HIGH){

 animation = random(4);

 switch(animation) {

 

 

   case 0:

   FastLED.clear();

 

   for(int i = 0; i < anzahlPixel; i++)

 {

   codino.rainbowWithGlitter(leds, anzahlPixel);

   delay(150);

   FastLED.show();

 }

 break;

 

 case 1:

   FastLED.clear();

   for(int i = 0; i < anzahlPixel; i++)

 {

   codino.juggle(leds, anzahlPixel);

   delay(150);

   FastLED.show();

 }

 break;

 

 case 2:

   FastLED.clear();

   for(int i = 0; i < anzahlPixel; i++)

 {

   

   codino.confetti(leds, anzahlPixel);

   delay(150);

   FastLED.show();

 }

 break;

 

 case 3:

   int gFarbton = 0;

   FastLED.clear();

   for(int i = 0; i < anzahlPixel; i++)

 {

   codino.bpm(leds, anzahlPixel, 62, gFarbton, PartyColors_p);

   delay(150);

   FastLED.show();

 }

 break;

 }

}

}

#include <CodinoLightning.h>

 

/* Part I: Konstanten und Variablendefinition.  */

#define anzahlPixel 60

#define pin 6

#define ledTyp WS2811

#define farbanordnung GRB

#define helligkeit 50

CRGB leds[anzahlPixel];

 

/* Part II: void setup.  */

void setup() {

 delay(2000);

 FastLED.addLeds<ledTyp, pin, farbanordnung>(leds, anzahlPixel).setCorrection(TypicalLEDStrip);

 

 FastLED.setBrightness(helligkeit);

}

 

/* Part III void loop */

 

void loop() {

 

int farbton = 0;

 

for(int i = 1; i <= 10; i++)

 {

   farbton = farbigePixels(1, true, i, farbton);

   farbton = farbigePixels(1, false, i, farbton);

 }

}

 

/* Part IV: Eigene Funktionen*/

 

int farbigePixels(int farbtonVeraenderung, bool vorwaerts, int verzoegerung, int farbton) {

 

for (int i = 0; i <= anzahlPixel; i++)

 

 {

    farbton = farbton + farbtonVeraenderung;

 

   if(vorwaerts == true){

     leds[i] = CHSV(farbton, 255, 255);

   } else {

     leds[anzahlPixel – i] = CHSV(farbton, 255, 255);

   }

 

FastLED.show();

delay(verzoegerung);

 

}

return farbton;

}

#include <CodinoLightning.h>

 

/* Part I. Konstanten */

#define PIN 6

#define ledTyp WS2811

#define farbanordnung GRB

#define anzahlPixel 60

#define helligkeit  50

 

#define lichtsensor A0

#define potentiometer A1

 

#define minWert 80.0

#define maxWert 350.0

#define piezo 7

CRGB leds[anzahlPixel];

 

void setup() {

  delay(2000);

   FastLED.addLeds<ledTyp,PIN,farbanordnung>(leds, anzahlPixel).setCorrection(TypicalLEDStrip);

   FastLED.setBrightness(helligkeit);

  Serial.begin(9600);

 pinMode(lichtsensor, INPUT_PULLUP);

  pinMode(piezo,OUTPUT);

 pinMode(potentiometer, INPUT);

 

}

 

/* Part III. void loop */

 

void loop() 

  int sensorWert = analogRead(lichtsensor);

 

 

  int farbton = ((sensorWert – minWert) / (maxWert – minWert)) * 255;

 

int potiWert = (analogRead(potentiometer)/1024.0) * 255;

 

 

  if(farbton > 255) {

    farbton = 255;

  } else if (farbton < 0) {

    farbton = 0;

  }

 

Serial.println(sensorWert);

Serial.print(“,”);

Serial.println(potiWert);

for(int i = 0; i < anzahlPixel; i++)

  {

    leds[i] = CHSV(farbton, 255, 255);

  }

 

 

  tone(piezo, farbton*2 + 2*potiWert);

 

  FastLED.show();

}

#include <CodinoLightning.h>

 

CodinoLightning codino = CodinoLightning();

 

/* Part I: Konstanten

Wie in den vorherigen Projekten auch definierst du erst einmal die Konstanten für den Projektaufbau. */

 

#define PIN 6

#define ledTyp WS2811

#define farbanordnung GRB

#define anzahlPixel    60

#define helligkeit  50

#define temperaturSensor A0

#define spannungBerechnung 5

 

CRGB leds[anzahlPixel];

 

/* Part II:

Im Set Up Bereich initialisierst du wie immer deinen Lightning-Streifen */

 

void setup() {

 

  delay(2000);

 

   FastLED.addLeds<ledTyp,PIN,farbanordnung>(leds, anzahlPixel).setCorrection(TypicalLEDStrip);

   FastLED.setBrightness(helligkeit);

 

  codino.reset_leds(leds, anzahlPixel); 

 Serial.begin(9600);

 

}

 

/* Part III: void loop

Im loop Bereich programmierst du den Lightning-Streifen darauf die Temperatur auszugeben – indem genauso viele LEDs leuchten, wie die Temperatur in deiner Umgebung aktuell ist.
*/

 

 

/* Part III: Loop-Bereich */

void loop()

{

 

 int temperatur = temperaturMessung();

 Serial.println(temperatur);

 

 for(int i = 0; i < temperatur; i++)

 {

 leds[i] = ColorFromPalette(HeatColors_p, 255 – i*4);

 FastLED.show();

 }

 delay(2000);

}

 

/* Part IV: Eigene Funktionen

Mit der Funktion temperaturMessung rechnest du die Temperatur in Grad Celsius aus. Diesen Wert übergibst du im loop Bereich an die Variable temperatur. */

 

double temperaturMessung() {

 

int wert = analogRead(temperaturSensor);

 

 double spannung = wert * spannungBerechnung;

 spannung = spannung / 1024.0;

 

 double temperaturCelsius = (spannung – 0.5) * 100;

 

 return temperaturCelsius;

}

#include <CodinoLightning.h>

 

/* Part I. Konstanten

Wie in den bisherigen Projekten auch definierst du deine Konstanten, mit denen du nachher den Lightning-Streifen startest.*/

 

#define anzahlPixel   60

#define PIN 6

#define ledType    WS2811

#define farbanordnung GRB

#define helligkeit  50

#define trigPIN 9

#define echoPIN 10

 

CRGB leds[anzahlPixel];

 

 

float maxEntfernung = 60.0;     

 

long const max_zeit = ((2 * (maxEntfernung)) / 0.0343)*3;

 

int const fade_rate = 0.05 * 255;   

 

long letzter_zeitpunkt = 0;

 

float const max_zeit_angeschaltet = 3000;

float zeit_angeschaltet = max_zeit_angeschaltet;

bool angeschaltet = false;

 

/*Part II. void setup

Im setup loop initialisierst du deinen Lightning-Streifen und definierst die Pins von deinem Sonar Sensor. */

 

void setup() {

 delay(2000);

 

 FastLED.addLeds<ledType, PIN, farbanordnung>(leds, anzahlPixel).setCorrection(TypicalLEDStrip);

 FastLED.setBrightness(helligkeit);

 pinMode(trigPIN, OUTPUT);

 pinMode(echoPIN, INPUT);

 

 Serial.begin(9600);

}

 

/*Part III. void loop

Im loop passieren nun verschiedene Dinge, die du im Flow-Diagramm siehst. Im ersten Schritt soll der Lightning-Streifen an- oder ausgeschaltet werden. Dann kommt eine Messung der einfachen Distanz zu einem Objekt. Diese Variable wird dann genutzt um zu prüfen, ob die Entfernung innerhalb der in den Konstanten definierten Bandbreite liegt, und ob der Lightning-Streifen schon länger als die maximale Zeit angeschaltet ist. Schließlich wird die Zeit gemessen, die der Lightning-Streifen schon aktiviert ist. */

 

void loop() {

 

 if (angeschaltet==true) {

   for(int i = 0; i < anzahlPixel; i++){

     leds[i] = CRGB::White;

   }

 } else {

 

   for(int i = 0; i < anzahlPixel; i++){

     leds[i].fadeLightBy( fade_rate );

   }

 }

 FastLED.show();

 

  long einfache_distanz = sonar_messung();

 

 

 

 

 if(einfache_distanz != 0.0) {

/*Wenn die gemessene Distanz ungleich 0 ist…*/

 

   if (einfache_distanz <= maxEntfernung) {

/* …folgt die Prüfung ob die gemessene Distanz in der angegebenen Bandbreite ist, also unterhalb von maxEntfernung… .*/

   

     angeschaltet = true;

     zeit_angeschaltet = 0;

 

   } else if (zeit_angeschaltet > max_zeit_angeschaltet) {

 

     angeschaltet = false;
 
 } /* Hier endet die else if Anweisung */

 

   Serial.print(maxEntfernung);

   Serial.print(“, “);

   Serial.println(einfache_distanz);

 } /* Diese Klammer beendet die „erste/oberste“ if-Anweisung. */

 

 

 zeit_angeschaltet += millis() – letzter_zeitpunkt;

 letzter_zeitpunkt = millis();

 

 

}

 

/*Part IV. Eigene Funktionen

Gleich ist es geschafft! Hier definierst du die sonar_messung Funktion. Mit dieser Funktion kannst du Ultraschall Impulse von dem Sonar Sensor ausgeben und die Reflektionen ablesen. Diesen Prozess kannst du dann in eine Distanz in cm umrechnen lassen. Die Funktion definierst du als Datentyp long. */

 

long sonar_messung() {

 

 

 digitalWrite(trigPIN, LOW);

 delayMicroseconds(2);

 digitalWrite(trigPIN, HIGH);

 delayMicroseconds(10);

 digitalWrite(trigPIN, LOW);

 long dauer = pulseIn(echoPIN, HIGH, max_zeit);

 return (dauer*.0343)/2;

}

#include <CodinoLightning.h>

 

/*Part I. Konstanten

Wie in den bisherigen Projekten, definierst du die Konstanten, um deinen Lightning-Streifen an den Start zu bringen. */

 

#define anzahlPixel   60

#define ledsPerMeter 60

#define PIN    6

#define ledType    WS2811

#define farbanordnung GRB

#define helligkeit  50

#define trigPIN 9

#define echoPIN 10

CRGB leds[anzahlPixel];

float const maxEntfernung = 100.0;     

long const max_zeit = (2 * (5 * maxEntfernung)) / 0.0343;

int const fade_rate = 0.25 * 256;   

long letzter_zeitpunkt = 0;

int const stichprobe = 40;

int stichprobe_idx = 0;

float distanzen[stichprobe] = { 0 };

 

/*Part II. Void Setup

Im setup Teil initialisierst du wie immer den Lightning-Streifen und definierst die Pins für den Sonar Sensor. */

 

void setup() {

 delay(2000);

 

 FastLED.addLeds<ledType, PIN, farbanordnung>(leds, anzahlPixel).setCorrection(TypicalLEDStrip);

 

 FastLED.setBrightness(helligkeit);

 

 pinMode(trigPIN, OUTPUT);

 pinMode(echoPIN, INPUT);

 

 Serial.begin(9600);

}

 

 

/*Part III. Void loop.*/

 

void loop() {

 int position_pixel = 0;

 long einfache_distanz = sonar_messung();

 if(einfache_distanz > 0.0) {

   long geglaettete_distanz = daten_glaetten(einfache_distanz);

   position_pixel = (geglaettete_distanz / 100.0) * ledsPerMeter;

 

   Serial.print(einfache_distanz);

   Serial.print(“, “);

   Serial.println(geglaettete_distanz);

 }

 

 for(int i = 0; i < anzahlPixel; i++){

   leds[i].fadeToBlackBy(fade_rate);

 

 

 leds[position_pixel] = CRGB::White;

 FastLED.show();

}

 

/*Part IV. Eigene Funktionen */

 

/* Hier nutzt du die gleiche Funktion, um die Signale aus deinem Sonar Sensor auszulesen, wie im vorherigen Projekt. */

long sonar_messung() {

 

 digitalWrite(trigPIN, LOW);

 delayMicroseconds(2);

 digitalWrite(trigPIN, HIGH);

 delayMicroseconds(10);

 digitalWrite(trigPIN, LOW);

 

 long dauer = pulseIn(echoPIN, HIGH, max_zeit);

 

 return (dauer*.0343)/2;

}

 

long daten_glaetten(long distanz) {

 stichprobe_idx ++;

 

 if(stichprobe_idx == stichprobe){

   stichprobe_idx = 0;

 }

 distanzen[stichprobe_idx] = distanz;

 long summe = 0.0;

 

 for(int i = 0; i < stichprobe; i++){

   summe += distanzen[i];

 }

 

 return summe / stichprobe;

}

#include <CodinoLightning.h>

 

CodinoLightning codino = CodinoLightning();

/*Mit dieser Code Zeile ermöglichst du, dass du die CodinoLightning Bibliothek mit dem einfachen Wort codino aufrufen kannst. Das vereinfacht den Code weiter unten spürbar. */

 

/* Part I. Konstanten

Wie immer definierst du im ersten Teil die Konstanten für dein Projekt. Hier setzt du die Grenzwerte fest, definierst die Werte zur Initialisierung des Lightning-Streifens und zum Auslesen der Werte vom Mikrophon. */

 

/* Setze wie in jedem Projekt die Konstanten für den Lightning-Streifen auf. */

#define anzahlPixel   60

#define PIN 6

#define ledType    WS2811

#define farbanordnung GRB

#define helligkeit  100

CRGB leds[anzahlPixel];

 

#define messung 32              

#define messungGeschwindigkeit 2000

/* Die Konstanten messung und messungGeschwindigkeit nutzt du im void setup mit einer Funktion aus der CODINO Bibliothek um Tonsignale auszulesen. Die Konstante messung gibt dabei die Anzahl an Tonsignalen an, die gezogen werden. Bei einem Wert von 32 werden 32 Messungen durchgeführt. Die Konstante messungGeschwindigkeit gibt die Geschwindigkeit in Hertz an, mit der Tonsignale gemessen werden. Aus technischen Gründen muss messung immer ein Vielfaches von 2 und messungGeschwindigkeit kleiner als 10.000 sein. */

 

const int mikro_pin = A0;   

/* Das Mikrophon ist an Slot A0 mit dem CODINO Controller verbunden. */

 

/* Der Lightning-Streifen soll bei einer bestimmten Tonhöhe angehen. Damit du nicht perfekt diesen Ton treffen musst, definierst du eine Toleranz, bei der der Lightning-Streifen angehen soll. */

const int tonhoehe = 300;

const int maximale_abweichung_tonhoehe = 50;

/* Die Variable tonhoehe gibt die Tonhöhe an, bei der der Lightning-Streifen angeschaltet werden soll. Die Variable maximale_abweichung_tonhoehe gibt an, wie die Abweichung von dieser Tonhöhe sein darf. Wenn du später zum Beispiel einen Ton in Höhe 275 pfeifst, wird mit einer maximalen Abweichung von 50 der Lightning-Streifen trotzdem leuchten. Da 300-50 = 250 beträgt, liegt der Wert 275 also noch in dem Bereich, in dem der Lightning-Streifen leuchten wird. Ob ein Pfeifen oder ein Ton im relevanten Bereich liegt, kannst du später im seriellen Plotter ablesen. Für das Beispiel haben wir unten noch ein Bild eingefügt. */

 

/* Aber nicht nur die Höhe, sondern auch die Länge des Tons musst du festlegen (d.h. wie lange soll der Ton erklingen, bis der Lightning-Streifen angeht?). */

const unsigned int dauer_tonhoehe = 500;

const unsigned int dauer_lightning = 5000;

/*Hier stellst du die zeitlichen Grenzwerte ein – die Variable dauer_tonhoehe gibt an, wie lange der Ton in der Tonhöhe hörbar sein soll, im Beispiel hier 500 Millisekunden. Die Variable dauer_lightning gibt an wie lange der Lightning-Streifen angeschaltet sein soll. Der Zusatz unsigned bedeutet übrigens, dass die Variable nur positiv sein kann. */

 

/* Du wirst später im Code sehen, dass du für beide Zeitwerte eine Hilfsvariable brauchst. Diese führst du hier ein und setzt sie auf 0. */

unsigned long dauer_tonhoehe_messung = 0;

unsigned long dauer_lightning_messung = 0;

 

/* Wie schon in einigen vorherigen Projekten nutzt du eine Variable vom Typ Boolean, die speichert, ob der Lightning-Streifen an oder aus ist. Die fade_rate gibt an, wie schnell der Lightning-Streifen sich verdunkeln wird. */

bool angeschaltet = false;

int const fade_rate = 0.1 * 256;   

 

/*Part II void setup

Im void setup initialisierst du die relevanten Funktionen und Bibliotheken für den Lightning-Streifen und den CODINO Controller, um die Signale am Mikrophon auszulesen. */

 

void setup() {

/* Zuerst initialisierst du den Ausgabemonitor (serielle Kommunikation)… */

   Serial.begin(9600);

 

/* …anschließend den LED Streifen. */  

delay(2000);

FastLED.addLeds<ledType, PIN, farbanordnung>(leds, anzahlPixel).setCorrection(TypicalLEDStrip);

 FastLED.setBrightness(helligkeit);

 

/* Und schließlich die init_FFT Funktion aus der CODINO Bibliothek mit der du die Tonhöhen ausliest. Zur Erinnerung: das heißt, dass die init_FFT Funktion bereits in der CODINO Bibliothek mit #include <CodinoLightning.h> in den Code eingebunden hast. */

   codino.init_FFT(mikro_pin, messung, messungGeschwindigkeit);

}

 

/* Part III void loop

Im loop lässt du das Programm schließlich ablaufen – wie im Flow Diagramm dargestellt – dafür nutzt du einige selbst geschriebene Funktionen, die weiter unten beschrieben werden. Es passieren im Prinzip nur drei Dinge. Erst wird der Lightning-Streifen an- oder ausgeschaltet über die Funktion licht_anschalten. Dann wird ein neuer Ton ausgelesen über die Funktion get_peak_pitch. Und schließlich wird dieser ausgelesene Ton in der Funktion tonhoehe_pruefung daraufhin überprüft, ob er innerhalb der in den Konstanten definierten Grenzwerten liegt. */

void loop() {

 

/* Die Funktion licht_anschalten gibt an, ob der LED Streifen an- oder ausgeschaltet sein soll. Sie ist das Ergebnis aus der Funktion tonhoehe_pruefung. */

   licht_anschalten();

 

/* In diesem Projekt willst du den Ton messen & prüfen. Deshalb brauchst du natürlich eine Variable, die die aktuelle Tonhöhe misst und speichert. Dafür nimmst du die Variable dominanter_ton mit dem Tonsignal, das gerade im Moment in deinem Raum präsent ist, zum Beispiel ein Pfeifen. Dafür kannst du die Funktion aus der CODINO-Bibliothek get_peak_pitch nutzen. Sie hilft dir dabei diese dominanten Töne aus allen anderen Tönen herauszufiltern. */

   float dominanter_ton = codino.get_peak_pitch();

 

/* Oben in der Konstantendefinition hast du die Grenzwerte für die Tonhöhe festgelegt, ab der der Lightning-Streifen leuchten soll. Genau dafür dient die Funktion tonhoehe_pruefung – diese überprüft ob alle Variablen, das heißt die Tonhöhe und die Zeit, in den oben definierten korrekten Grenzwerten liegen. */

   tonhoehe_pruefung(dominanter_ton);

 

/* Für eventuelle Fehlerüberprüfungen („debuggen“) knipst du wieder den Ausgabemonitor über die bekannten Serial.print Befehle an.

Die Variable angeschaltet (Datentyp: Boolean – also TRUE oder FALSE) kannst du dir auch im Plotter ausgeben lassen, indem du sie durch den Zusatz DEC in eine Dezimalzahl umwandeln lässt. Durch die Multiplikation mit 100 stellst du sicher, dass sie auch im Plotter angezeigt wird, falls der Dezimalwert zu niedrig wäre. */

   Serial.print(100*angeschaltet, DEC);

   Serial.print(“,”);

   Serial.println(dominanter_ton);

}

 

/*Part IV: Eigene Funktionen */

/* In Part III greifst du auf zwei selbst definierte Funktionen zurück: tonhoehe_pruefung, die als Input eine Tonmessung benötigt und licht_anschalten – diese baust du jetzt in diesem Teil. */

 

/* Mit der Funktion tonhoehe_pruefung wirst du prüfen, ob die Grenzwerte für Tonhöhe und Zeit eingehalten werden. Falls ja, wird die Variable angeschaltet auf TRUE gesetzt, sonst auf FALSE. Damit die Funktion funktioniert, brauchst du als Input eine Tonmessung (tatsaechlich_tonhoehe). */

void tonhoehe_pruefung(float tatsaechlich_tonhoehe){

/* Du musst zwei Sachen prüfen: Ist der Ton innerhalb der tolerierten Abweichung und wie lange ist der Ton in dieser Range?

 

Im ersten Teil wird geprüft: Ist der Ton innerhalb der tolerierten Abweichung */

float tonhoehe_abweichung = abs(tonhoehe – tatsaechlich_tonhoehe);

/* Die Variable tonhoehe_abweichung soll die Differenz aus dem oben definierten Zielwert tonhoehe und der tatsächlichen Tonhöhe sein (tatsaechliche_tonhoehe). Damit es keinen Unterschied macht, ob der Wert positiv oder negativ ist, nutzt die Funktion abs() um den absoluten Wert zu bekommen (-50 wird so zu 50).*/

   if(tonhoehe_abweichung < maximale_abweichung_tonhoehe){

 

/* Wenn die Tonhöhe im akzeptablen Bereich liegt, folgt die zweite Prüfung – nämlich ob der Ton auch lang genug erklungen ist. */

       if(millis() – dauer_tonhoehe_messung > dauer_tonhoehe) {

/* Mit millis() misst du wie in einem vorherigen Projekt die insgesamt vergangene Zeit. Davon ziehst du die Zeitdauer ab, in der sich der Ton in der angegebenen Range befindet (dauer_tonhoehe_messung). Wenn dieser Wert höher als der untere Grenzwert für Tondauer ist (dauer_tonhoehe), dann… */

           angeschaltet = true;

           dauer_lightning_messung = millis();

/* … wird die Variable angeschaltet auf TRUE gesetzt und eine neue Zeitmessung begonnen, nämlich wie lange der Lightning-Streifen schon an ist (brauchst du für die Funktion licht_anschalten().*/

 

       } /* Ende der zweiten if-Anweisung */

 

/* Wenn die zweite if-Anweisung nicht zutrifft (d.h. die Tonhöhe zu kurz gemessen wurde, soll die Zeitmessung mit millis() wieder starten. */

   } else {

       dauer_tonhoehe_messung = millis();

   } /* Ende der ersten if-Anweisung */

} /* Ende der Funktion tonhoehe_pruefung */

 

/* Jetzt zur zweiten Funktion licht_anschalten(). Mit dieser Funktion wird in Abhängigkeit der Variable angeschaltet der Lightning-Streifen an- oder ausgeschaltet. */

void licht_anschalten() {

 

/* Im ersten Schritt prüfst du, ob die Variable angeschaltet = true gesetzt ist, die Grenzwerte für Tonhöhe und Dauer also eingehalten werden. */

    if(angeschaltet == true) {

/* Wenn dies der Fall ist, prüfst du noch, ob der Lightning-Streifen bereits länger angeschaltet ist, als er laut oben definiertem Grenzwert sein soll. */

       if(millis() – dauer_lightning_messung > dauer_lightning) {

/* Wenn dies der Fall ist soll die Variable angeschaltet = false gesetzt werden. Das heißt der Lightning-Streifen wird ausgeschaltet. */

           angeschaltet = false;

        else {

 

/* Wenn die Variable angeschaltet = true ist, und der Grenzwert eingehalten wird, soll der Lightning-Streifen angeschaltet werden. */

 

           for(int i = 0; i < anzahlPixel; i++)

           {

               leds[i] = CRGB::White;

           }

       }

   } else {

 

/*Wenn die Variable angeschaltet = false ist, soll der Lightning-Streifen ausgeschaltet werden. Dieses else bezieht sich also auf die obere if-Schleife (Prüfung, ob die Variable angeschaltet = true ist). */

 

       for(int i = 0; i < anzahlPixel; i++)

       {

           leds[i].fadeToBlackBy(fade_rate);

       }

   }

   FastLED.show();

}

#include  <CodinoLightning.h>

CodinoLightning codino = CodinoLightning();

 

/*Part I Konstanten*/

#define PIN    6

#define ledTyp    WS2811

#define farbanordnung GRB

#define anzahlPixel    60

#define helligkeit  96

 

CRGB leds[anzahlPixel];

const int mikroPIN = A0;

int index = 0;

int durchschnitt = 0;

float Signalhoehe_Grenzwert = 20;

float Steigung_Grenzwert = 15;

float Steigung_Summe = 0;

bool peaked = false;

float letzter_wert = 0;

 

/*Wie in einigen Vorprojekten führst du eine fade_rate ein.*/

int const fade_rate = 0.25 * 256;

FilterTwoPole tiefpassFilter;

 

/* Part II void setup */

 

void setup() {

   Serial.begin(9600);

   FastLED.addLeds<ledTyp,PIN,farbanordnung>(leds, anzahlPixel).setCorrection(TypicalLEDStrip);

   FastLED.setBrightness(helligkeit);

 

tiefpassFilter.setAsFilter(LOWPASS_BUTTERWORTH, 2);

}

 

/*Part III. Void Loop*/

 

void loop() {

   float signal = codino.mean_offset(analogRead(mikroPIN), durchschnitt, index);

float positives_signal = abs(signal);

float Umschlag = tiefpassFilter.input(positives_signal);

   bool Hochpunkt = Hochpunkt_Entdeckung(Umschlag);

    Serial.print(Umschlag);

    Serial.print(“,”);

    Serial.print(Hochpunkt * 5, DEC);

    Serial.print(“,”);

    Serial.println(Steigung_Summe);

 

/* Die letzte Code Anpassung ist sehr einfach – wenn in der Funktion hochpunkt_entdeckung ein Hochpunkt vorliegt (also Hochpunkt = TRUE), soll der Lightning-Streifen weiß aufleuchten. */

   if(Hochpunkt == true){

       for(int i = 0; i < anzahlPixel; i++)

       {

           leds[i] = CRGB::White;

       }

   } else {

/* Sonst soll er ausfaden. */

       for(int i = 0; i < anzahlPixel; i++)

       {

           leds[i].fadeLightBy( fade_rate );

       }

   }

 

   FastLED.show();

}

 

/*Part IV Eigene Funktionen*/

 

bool Hochpunkt_Entdeckung(float signalhoehe){

   bool Hochpunkt = false;

   float Steigung = signalhoehe- letzter_wert;

   if(Steigung > 0){

       Steigung_Summe = Steigung_Summe + Steigung;

       peaked = false;

   }

   else {

 

       if(signalhoehe > Signalhoehe_Grenzwert && Steigung_Summe > Steigung_Grenzwert && peaked == false){

           Hochpunkt = true;

       }

       peaked = true;

       Steigung_Summe = 0;

   

  letzter_wert = signalhoehe;

   return Hochpunkt;  

}

#include <CodinoLightning.h>

CodinoLightning codino = CodinoLightning();

 

/*Part I Konstanten

Wie in jedem Projekt definierst du erst einmal die Konstanten, die du für den Lightning-Streifen nutzt. Zusätzlich definierst du Konstanten für den Einsatz des Mikrophons. */

 

#define PIN    6

#define ledTyp    WS2811

#define farbanordnung GRB

#define anzahlPixel    60

#define helligkeit  96

 

CRGB leds[anzahlPixel];

uint8_t farbton = 0;

const int mikroPIN = A0;

int index = 0;

int durchschnitt = 0;

 

FilterTwoPole lowpassFilter;

float min_wert = 0;

float max_wert = 120;

const int animation_period = 40;

 

/* Part II void setup

Im vorherigen Projekt hast du im Setup die serielle Kommunikation, den LED Streifen und die Signalverarbeitung initialisiert – das sind die Schritte, die du nun auch hier durchführst. */

 

void setup() {

   Serial.begin(9600);

 

   FastLED.addLeds<ledTyp,PIN,farbanordnung>(leds, anzahlPixel).setCorrection(TypicalLEDStrip);

   FastLED.setBrightness(helligkeit);

 

   lowpassFilter.setAsFilter(LOWPASS_BUTTERWORTH, 2);

}

 

/* Part III void loop */

void loop() {

float signal = codino.mean_offset(analogRead(mikroPIN), durchschnitt, index);

float positives_signal = abs(signal);

float umschlag = lowpassFilter.input(positives_signal);

float normalisiere_umschlag = (umschlag – min_wert) / (max_wert – min_wert);

   signalhoehe_auf_lightning_streifen(normalisiere_umschlag, OceanColors_p);

 

/* Du willst ja etwas Variation in der Animation haben, oder? */

   EVERY_N_MILLISECONDS(animation_period ) { farbton++; }

 

   Serial.print(umschlag);

   Serial.print(“,”);

   Serial.print(max_wert);

   Serial.print(“,”);

   Serial.println(min_wert);

   }

 

/*Part IV Eigene Funktionen*/

void signalhoehe_auf_lightning_streifen(float normalisierte_signalhoehe, CRGBPalette16 palette) {

 

   float lightning_signalhoehe = normalisierte_signalhoehe * 255;

 

   for(int i = 0; i < anzahlPixel; i++) {

       leds[i] = ColorFromPalette(palette, farbton + (i*2), lightning_signalhoehe + (i*10));

   }

   FastLED.show();  

}


Cart

View cart