RGB LED Streifen

http://sites.prenninger.com/arduino-uno-r3/rgb-led-streifen

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                        Wels, am 2015-12-12

BITTE nützen Sie doch rechts OBEN das Suchfeld  [                                                              ] [ Diese Site durchsuchen]

DIN A3 oder DIN A4 quer ausdrucken
**********************************************************************************
DIN A4  ausdrucken
*********************************************************


        5m  RGB-LED-Streifen
  /  RGB-LED-Strips



01    RGB-LED-Streifen von Müller Licht  € 34,95 
 Müller-Licht LED Strip  Artikel Nr. 400092  320lm (13,33lm/W)   230Vac  24W  150Stk. RGB-LEDs    5m
http://www.mueller-licht.de/leuchten/mueller-licht/strips_und_lichtleisten/


02    Müller Licht Dekobeleuchtung LED Stripe 24W,
150 RGB-LEDs auf 5 m,  57003 LED,   CONRAD Bestell-Nr.: 779276-62
779276-an-01-de-LED_STRIP_FARBWECHSEL__5_M__36W_150_LEDS.pdf
300_a_MÜLLER-x_ MÜLLER-LICHT 5m RGB LED-Strip #57003 12V-36W mit Farbwechsel - Bedienungsanleitung_1a.pdf   
https://www.conrad.at/de/mueller-licht-dekobeleuchtung-led-stripe-24-w-5-m-57003-led-779276.html


03    Müller Licht 5-m-RGB-LED-Streifen inkl. Controller und Netzteil, IP44    ELV Artikel-Nr.: 68-116434  
  • 5-m-RGB-LED-Lichtstreifen, LED-Leistung: 24 W
  • Für Innen- und Außenbetrieb, IP44
  • 15 Farben plus Reinweiß sofort einstellbar, in 16 Stufen dimmbar
  • Blinkbetrieb in 7 bzw. 3 verschiedenen Farben
  • Fließender Farbwechsel
  • Geschwindigkeitseinstellung bei Blink- und Farbwechselbetrieb

300_a_MÜLLER-x_ MÜLLER-LICHT 5m RGB LED-Strip #57003 12V-36W mit Farbwechsel - Bedienungsanleitung_1a.pdf  

http://www.elv.de/mueller-licht-5-m-rgb-led-streifen-inkl-controller-und-netzteil-ip-44.html


MÜLLER-LICHT International
Goeblstr. 61/63
D-28865 Lilienthal
Tel . 0043 (0)4298 / 93700
mailto:service@mueller-licht.de



04    Nut & Bolt RGB LED strip
LPD8806 digital adressierbaren RGB LED Streifen an einem Arduino angeschlossen.
ARDUINO controlled HL1606 LED strip

http://nut-bolt.nl/2012/rgb-led-strips/

04    sparkfun RGB LED Strip - 32 LED/m Addressable - 1m
WS2801
3-Channel Constant Current LED Driver With Programmable PWM Outputs



https://www.adafruit.com/datasheets/WS2801.pdf

Die
WS2801 ist ein "3-Kanal-Konstantstrom-LED-Treiber mit programmierbaren PWM Ausgänge".
Es ermöglicht Ihnen,
die Helligkeit jeder LED in 256 Schritten mit PWM einzustellen.
Ein
WS2801-Chip steuert drei Kanäle, so dass Sie einen Chip für jede RGB-LED benötigen.
Theoretisch
bedeutet dies die WS2801 Streifen können neben jeder LED geschnitten werden, aber ich habe noch keine Streifen, wo dies der Fall ist zu sehen.
Der Chip
wird auf 3.3-5.5V.
https://www.sparkfun.com/products/retired/10312


05    Adafruit  Digital RGB LED Weatherproof Strip - LPD8806   32LEDs
Digital adressierbarer RGB-LED-Strip vom Typ LPD8806   
Die LPD8806 ist ein viel wie der WS2801 mit den folgenden Unterschieden: es funktioniert von 2.7V und verfügt über sechs Kanäle so dass sie zwei RGB-LEDs zu steuern.
Der Nachteil
ist, dass es nur 7-Bit-PWM, was 127 Helligkeitsstufen pro LED für bis zu 21-bit Farbtiefe (2 Millionen Farben).
Es gibt keine
englischen Datenblättern zur Verfügung und die Protokollbeschreibung ist nicht geöffnet.
Glücklicherweise sind die
Leute bei Adafruit Reverse Engineering das Protokoll und veröffentlicht eine LPD8806 Arduino Bibliothek.

https://github.com/adafruit/LPD8806
https://www.adafruit.com/products/306



*********************************************************

06    Arduino mit RGB Leiste verbinden  
 Fa. Seeed Studio    LED Strip Driver   LED05241P  Da gehört ein Shield und eine Libary dazu.
http://www.exp-tech.de/seeed-studio-grove-led-strip-driver

Hier der Code vom MicroController


/*
  Reading a serial ASCII-encoded string.

 This sketch demonstrates the Serial parseInt() function.
 It looks for an ASCII string of comma-separated values.
 It parses them into ints, and uses those to fade an RGB LED.

 Circuit: Common-anode RGB LED wired like so:
 * Red cathode: digital pin 9
 * Green cathode: digital pin 10
 * blue cathode: digital pin 11
 * anode: +5V

 created 13 Apr 2012
 by Tom Igoe
 edited by Max Johenneken on January 2013

 This example code is in the public domain.
 */

// pins for the LEDs:
const int redPin = 9;
const int greenPin = 10;
const int bluePin = 11;

void setup() {
  // initialize serial:
  Serial.begin(9600);
  // make the pins outputs:
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);

}

void loop() {
  // if there's any serial available, read it:
  while (Serial.available() > 0) {

    // look for the next valid integer in the incoming serial stream:
    int red = Serial.parseInt();
    // do it again:
    int green = Serial.parseInt();
    // do it again:
    int blue = Serial.parseInt();

    // look for the newline. That's the end of your
    // sentence:
   if (Serial.read() == '\n') {
      // constrain the values to 0 - 255 and invert
      // if you're using a common-cathode LED, just use 
"constrain(color, 0, 255);"
      red = 255 - constrain(red, 0, 255);
      green = 255 - constrain(green, 0, 255);
      blue = 255 - constrain(blue, 0, 255);

      // fade the red, green, and blue legs of the LED:
      analogWrite(redPin, red);
      analogWrite(greenPin, green);
      analogWrite(bluePin, blue);

      //nicht umbedingt notwendig gibt die werte die an die led gehen
      //an den Serial Monitor. Zu finden unter "Tools","Serial Monitor"
      // print the three numbers in one string as hexadecimal:
      Serial.print(red, HEX);
      Serial.print(green, HEX);
      Serial.println(blue, HEX);
   }
  }
}

https://www.mikrocontroller.net/topic/286141




*********************************************************

07    RGB-Lichterketten mit ARDUINO steuern   
Eine Kette Buntes Artikel aus c't 2014-25s172

RGB-Lichterketten mit Arduino steuern

Farblichterketten steuern Tim Gerber
Eine Kette Buntes RGB-Lichterketten mit Arduino steuern RGB-Lichterketten [...] Euro im Elektronik-Handel zu bekommen
[1]. Noch bunter Noch eleganter als die Standard-RGB-Streifen aus [...] Querschnitt verwenden.
Die Ansteuerung solcher LED-Ketten mit WS2812B-Controllern per Arduino ist ausgesprochen

http://www.heise.de/ct/

ct.14.25.172-173.pdf
300_d_ct-x_ ct-2014-25s172  RGB-Lichterketten mit ARDUINO UNO steuern dazu RGB-LED-Shield_1a.pdf

Bei LED-Leuchtstreifen mit WS2812B-Controllern kann man jede einzelne LED separat ansteuern und so beispielsweise
Farbpunkte wandern lassen oder einen Wabereffekt in den Farben des Lieblingssportvereins erzeugen.


Arduino und RGB LED Streifen mit WS2812B Controller

Hallo,

eine wirklich gute Weiterführung des Artikels aus Heft 24/2014!

Da ich kein Elektronikexperte bin, habe ich nach dem Lesen des Artikels noch einige Fragen:

1. RGB LED Streifen mit WS2812B Controller haben drei Anschlüsse (GND, 5V und einen Datenanschluß).

Wie genau ist der Arduino mit solch einem RGB LED Streifen zu verbinden?

2. Eine RGB LED eines solchen Streifens zieht max. 60 mA.
Ist es richtig, dass sich via Arduino somit höchstens ca. 30 RGB LED (~ 2A / 60mA) betreiben lassen?

3. Gibt es eine einfache Möglichkeit mehr als 30 RGB LED eines solchen RGB LED Streifen mit einem Arduino anzusteuern?
Wie kann man z.B. ein 1m Stück eines RGB LED Streifens mit 144 LED (je m) betreiben?

(Wenn ich richtig gerechnet habe, bräuchte man dafür eine 5V Stromversorgung mit ca. 9A.)
Was ist bei solchen Strömen zu beachten?

4. Für Standard LED Streifen, die keine Ansteuerung einzelner LED zulassen, ist der Velleman RGB Shield eine Lösung da der eine externe Stromversorgung zuläßt.
Gibt es auch eine ähnliche Lösung für RGB LED Streifen mit WS2812B Controller?

Der Datenanschluss wird direkt mit dem Arduino-Pin verbunden.

Für mehr LEDs brauchst du ein Netzteil, zB. SNT RS 50 5 mit 10A bei reichelt für ~15€.

Ich hab das hier mit 240 LEDs problemlos laufen.


RGB LED Streifen Sketch siehe

https://learn.adafruit.com/adafruit-neopixel-uberguide





LicheffektKinect.ino


#include "FastLED.h"

// How many leds in your strip?
#define NUM_LEDS 60

// For led chips like Neopixels, which have a data line, ground, and power, you just
// need to define DATA_PIN.  For led chipsets that are SPI based (four wires - data, clock,
// ground, and power), like the LPD8806, define both DATA_PIN and CLOCK_PIN
#define DATA_PIN 3
#define CLOCK_PIN 13
char bytes[3] = {0, 0, 0};

// Define the array of leds
CRGB leds[NUM_LEDS];

void setup() {
FastLED.addLeds<NEOPIXEL, DATA_PIN>(leds, NUM_LEDS);
fill_solid( &(leds[0]), NUM_LEDS, CRGB(0, 0, 0) );
for (int x = 0; x < NUM_LEDS; x++) leds[x] = CRGB(255,255,255); //Schwarz
FastLED.show();
Serial.begin(9600);
delay(1000);
}

void loop() {

if (Serial.available() == 3) {
  Serial.readBytes(bytes, 3);
  for (int x = 0; x < NUM_LEDS; x++) leds[x] = CRGB(0, 50, 0);
  if (bytes[0] < NUM_LEDS) leds[bytes[0]] = CRGB(255, 0, 0);
  FastLED.show();
  }
}




*.ino Datei für den RGB_Regler

int rPin = 3;
int gPin = 5;
int bPin = 6;
byte pins[3] = {0, 0, 0};

void setup() {
pinMode(rPin, OUTPUT);
pinMode(gPin, OUTPUT);
pinMode(bPin, OUTPUT);
Serial.begin(9600);
}

void loop() {
if (Serial.available() >= 3) Serial.readBytes(pins, 3);
analogWrite(rPin, pins[0]);
analogWrite(gPin, pins[1]);
analogWrite(bPin, pins[2]);
}



Link zum Arduino Code (Arduino_Fader.ino)


/* Walter Baumgartner 2013
   
   Setzt die LED Werte entsprechend den Vorgaben aus Processing Code
   Fader_pde
   Dieser erhält die Werte über OSC von iPhone
*/

int rPIN = 5;
int bPIN = 3;
int gPIN = 6;

// Array um die 3 Werte vom serial port zu speichern
int incomingByte[3]; 
 
void setup() {
  // Initialisiert die Serielle Kommunikation
  Serial.begin(9600);

  pinMode(rPIN, OUTPUT);
  pinMode(bPIN, OUTPUT);
  pinMode(gPIN, OUTPUT);
  
}
 
/*  3 pins are stored in an array, 3 values from the serial buffer
are stored in an array, by looping through both we can light up the LEDs
using the values sent from the Processing sketch. NOTE: the values sent over
the serial port didn't seem to be in order, rather than RGB I got GBR so it
looks like it misses the first byte - so its just trial and error matching
the correct pin to the correct value.
*/
 
void loop() {
  // Abfragen ob drei Werte von Processing gesendet wurden
  if (Serial.available() >= 3) 
  {
    // liest den ältesten Wert in den serial buffer:
    for (int i=0; i<3; i++) 
    {
      // iiest alle Werte
      incomingByte[i] = Serial.read();
      // Übergibt die Werte den PIN's
      
      if (i == 0){
        analogWrite(rPIN, incomingByte[i]);
        Serial.println(incomingByte[i]);
      }
      if (i == 1){
        analogWrite(bPIN, incomingByte[i]);
        Serial.println(incomingByte[i]);
      }
      if (i == 2){
        analogWrite(gPIN, incomingByte[i]);
        Serial.println(incomingByte[i]);
      }
      
    }
  }
 
}






[1] Tim Gerber, Arduino-Shields zum Selbstlöten, c’t Hacks 3/14, S. 13
[2] Tim Gerber, Wandleuchten, Ambilight für den PC selbst gebaut, c’t 1/14, S. 158
[3] Tim Gerber, Sternstunden, Einsteiger-Projekt: LED-Lichteffekte mit Arduino, c’t 24/14, S. 204
[4] Tim Gerber, Schrumpfkur, Arduino-IDE zum Programmieren von ATtiny-Microcontrollern zweckentfremden (im Beispiel LEDs dimmen), c’t 4/14, S. 178

c't Beispielcode und mehr:
ct.de/y2tn
http://www.heise.de/ct/ausgabe/2014-25-RGB-Lichterketten-mit-Arduino-steuern-2450561.html?wt_mc=print.ct.2014.25.172#zsdb-article-links



http://www.heise.de/ct/ausgabe/2014-25-RGB-Lichterketten-mit-Arduino-steuern-2450561.html



*********************************************************


08    RGB Led Strip controlled by an Arduino   


ARDUINO UNO R3
RGB LED Strip
MOSFET,
Temperatur-Sensor
Licht
-Sensor


Ich kaufte mir vor ein paar Wochen  recht günstig einen 5m RGB LED-Streifen (60 LEDs pro Meter) auf eBay.
Meine Absicht
ist es, sie mit einem benutzerdefinierten Arduino Empfangen von Befehlen über einige XBees fahren.
Ich war in der Notwendigkeit MOSFETs, um die 3 RGB-Kanäle fahren, und wieder fand einige billigen bei eBay erhielt ich vor ein paar Tagen.
Heute war eine gute Gelegenheit dafür einige grundlegende Tests.
Mein
erster Schritt war, die Farbe der Streifen RGB-LED mit Hilfe der MOSFETs und einem Arduino steuern.

Bevor Ihr lesen Sie den Rest dieses Blog-Post, sollten Sie
Adafruit
Tutorial auf RGB-LED-Streifen https://learn.adafruit.com/rgb-led-strips
und

Bildr tutorial on MOSFETs http://bildr.org/2012/03/rfp30n06le-arduino/
lesen.

Ich meistens tat, was Adafruit Tutorial erklärt, mit der Ausnahme, fügte ich 10k Widerstände, zwischen je Controll-pin / Gate-pin und GND
(so 3 Widerstände für eine RGB-Streifen), um das Signal zu geringe Kraft, bis die Arduino schlägt sich an!






Ansteuerung der LEDs über RGB-Farben, wie die Adafruit Beispiel ist schön, aber wenn Sie wollen, glattere Farbübergänge HSV oder HSL
(Farbton, Sättigung und Helligkeit) ist ein besserer Weg, es zu tun.
Normalerweise werden Sie die gleiche Sättigung und Helligkeit und einzige Änderung Farbton halten.


Beispiel Sketch

RGB_LED_Strip_Mosfet.ino

// HSV fade/bounce for Arduino - scruss.com - 2010/09/12
// Note that there's some legacy code left in here which seems to do nothing
// but should do no harm ...

// don't futz with these, illicit sums later

#define RED 9// pin for red LED
#define GREEN 10 // pin for green - never explicitly referenced
#define BLUE 11 // pin for blue - never explicitly referenced
#define SIZE 255 #define DELAY 20
#define HUE_MAX 6.0 #define HUE_DELTA 0.01

usw.
https://gist.github.com/jeje/4191271#file-rgb_led_strip_mosfet-ino



RGB_LED_Strip_Mosfet_Temp.ino

// HSV fade/bounce for Arduino - scruss.com - 2010/09/12
// Note that there's some legacy code left in here which seems to do nothing
// but should do no harm ...


#include "OneWire.h"
//#include "Streaming.h"

const int DS18S20_Pin = 2; //DS18S20 Signal pin on digital 2
#define MIN_TEMP 18
#define MAX_TEMP 30

usw.
https://gist.github.com/jeje/4191267#file-rgb_led_strip_mosfet_temp-ino


http://www.jerome-bernard.com/blog/2013/01/12/rgb-led-strip-controlled-by-an-arduino/




*********************************************************


09    Anschluss einer RGB-LED Leiste an ARDUINO Uno  

Transistor-Array
RBG LEDs Typ SMD 5050, 150Stk. auf 5m und und 12Vdc Eingangsspannung.
2Stk.  ULN2803 sind für Standard LEDs brauchbar
MOSFET   IRLIZ44N






http://forum.arduino.cc/index.php?topic=247214.0


*********************************************************

10    RGB LED Strips | Adafruit Learning System 
Last update 2015-12-07  


300_d_lady ada-x_ adafruit learning system  RGB-LED-Strip mit ARDUINO UNO steuern (13 Seiten)_1a.pdf
https://learn.adafruit.com/rgb-led-strips?view=all





Schematische
Analog Typ RGB LED-Streifen werden auf eine Rolle und werden von 3-LED-Abschnitte, die 10 cm lang sind gemacht.
Sie sind einfach zu
an der Grenze der einzelnen Abschnitte geschnitten, theres ein wenig Schnittmarke Bereich und einige Kupfer Registerkarten können Sie zu löten.
Jede LED
in einem Abschnitt ist ein "5050" tri-Farbtyp, enthaltend einen roten, grünen und blauen LED.
Das bedeutet, dass jeder Abschnitt hat wirklich 9 insgesamt LEDs - Drei rote, drei grüne und drei blau.
Die LEDs sind
in Reihe angeordnet, wie in der folgenden schematischen gezeigt:


Stromaufnahme:
Da gibt es 3 LEDs in der Reihe, kann man nicht fahren diese Lieds aus einer 5V Versorgung.
Die LED-Streifen sagen +12V auf sie, um die Anode zu markieren, und das ist die maximale Spannung, die wir vorschlagen.

Wir haben festgestellt, dass, wenn Sie in Ordnung mit ihnen, ein wenig Dimmer sind, dann funktioniert auch 9Vdc sehr gut.
Jedes Segment 3 LEDs zieht etwa 20mA von einer 12V Versorgung, per LED-Kette.
So für jedes Segment gibt es eine maximale 20mA zu ziehen aus den roten Lieds, 20mA zu ziehen aus der grünen und 20mA aus heiterem Himmel.

Wenn Sie die LED-Streifen auf weißem Voll haben (alle Lieds leuchtet), die 60mA pro Segment wäre.
Um die maximale Gesamtstromaufnahme pro Meter zu finden, würden wir uns 60mA x 10 (zehn Segmenten pro Meter für den 30. / LED pro Meter Leiste) = 0,6 Ampere pro Meter oder 60mA x 20 (zwanzig Segmente pro Meter für den 60 zu multiplizieren / LED pro Meter-Streifen) = 1,2 Ampere pro Meter.
Auch das ist vorausgesetzt, Sie würden alle Lieds auf einmal haben, und dass Sie von 12V betreiben Sie ihn.
Wenn Sie vorhaben, PWM-Fading zwischen den Farben sein wirst, vielleicht 1/2 von dem ist, was werden Sie zeichnen.
Dennoch, Sie brauchen, um eine recht ordentliche Stromversorgung müssen diesen Streifen laufen, all diese Lieds addieren!

Verwendung:
Da diese LED-Streifen sind sehr einfach, können wir einfach nutzen sie mit jedem Mikrocontroller.
Wir empfehlen die Verwendung von PWM-Dimming-Techniken, um den Streifen zu steuern.

Da jede "LED" Stift kann am Ende erfordert einen Amp oder mehr zu Boden sinken, sind Leistungstransistoren erforderlich!
Versuchen Sie nicht, die Stifte direkt in Ihren Alltag Mikrocontroller zu verbinden, werden sie ausbrennen und / oder nicht.
Sie können jede beliebige Strom NPN oder N-Kanal-MOSFET verwenden, stellen Sie sicher, dass der Transistor wird bewertet, um in der Lage, so viel Strom, wie Sie benötigen weiterzugeben.
Zum Beispiel, denn wir ziehen über 0.2Amps pro Kanal pro Meter, wenn Sie ein 5-Meter Streifen Sie benötigen, um zu 1 Ampere verzichten pro Transistor haben.

Holen Sie sich die bullige "TO-220" Pakete, nicht die dinky kleinen Jungs.


Stellen Sie sicher, sie sehen so aus:
Für grundlegende, kostengünstige Nutzung empfehlen wir, N-Kanal-MOSFETs (http://adafru.it/cwE) wie die IRLB8721 (http://adafru.it/ijf) - sie sind sehr beliebt und preiswert und die Arbeit mit 3,3V oder 5V-Logik.
Wenn Sie nicht bekommen kann diesen sind TIP120 (http://adafru.it/976) auch gut, aber es gibt noch mehr Spannungsverlust in einem Transistor als in einem MOSFET weshalb empfehlen wir diejenigen zuerst (weniger Wärmeverlust, mehr Licht
!)
Dieses Diagramm zeigt den Anschluss von bis zu N-Kanal-MOSFETs, wo das Tor ist Pin 1 ist die Drain-Pin 2 und die Quelle ist Pin 3
Die IRLB8721 kann bis zu 16 Ampere Dauerstrom umgehen - das ist also mindestens 750 LEDs, und wenn Sie nicht haben, sie alle auf helle, weiße, 1500 LEDs.
Möglicherweise müssen Sie Körper in Abhängigkeit von der Dauer / Gesamtstromverbrauch / disappation erhitzen

Für längere Streifen mehr als 1 Amp, Draht die Kraft auf den Streifen erfordern direkt, dann führen Sie Strom- und Masseleitungen zurück zum Arduino.
Dieses Diagramm zeigt den Anschluss mit Strom NPN-Transistoren, wie TIP120, wo Basis ist pin-1 ist Collector pin-2 und Emitter ist pin-3.
Es ist sehr
ähnlich, außer dieser Zeit haben wir 100 bis 220 Ohm-Widerstände zwischen dem PWM-Ausgangsstift und der Basis .
Bei längeren Streifen, die mehr als 1A, Draht Strom direkt auf den Streifen, dann führen Sie Strom- und Masseleitungen zurück zum Arduino.

Schließen Sie ein 9..12Vdc Stromversorgung des ARDUINO UNO R3, so dass Vin liefert die Hochspannung an die LED-Leiste.
Wenn Sie
möchten, können Sie auch einfach einen separaten Draht, der an eine Stromversorgung, die über +12V bietet verbindet.
Achten Sie darauf, um den Boden zu dieser Leistung auf den Boden der Arduino / MOSFETs verbinden!
TIP120 kann bis zu 5 A Dauerstrom umgehen - das ist also mindestens 250 LEDs, und wenn Sie nicht haben, sie alle auf helle, weiße, 500 LEDs.


// color swirl! connect an RGB LED to the PWM pins as indicated
// in the #defines
// public domain, enjoy!

#define REDPIN 5
#define GREENPIN 6
#define BLUEPIN 3

#define FADESPEED 5 // make this higher to slow down


void setup() {
  pinMode(REDPIN, OUTPUT);
  pinMode(GREENPIN, OUTPUT);
  pinMode(BLUEPIN, OUTPUT);
}


void loop() {
  int r, g, b;

  // fade from blue to violet
  for (r = 0; r < 256; r++) {
     analogWrite(REDPIN, r);
     delay(FADESPEED);
  }
  // fade from violet to red
  for (b = 255; b > 0; b--) {
     analogWrite(BLUEPIN, b);
     delay(FADESPEED);
  }
  // fade from red to yellow
  for (g = 0; g < 256; g++) {
     analogWrite(GREENPIN, g);
     delay(FADESPEED);
  }
  // fade from yellow to green
  for (r = 255; r > 0; r--) {
     analogWrite(REDPIN, r);
     delay(FADESPEED);
  }
  // fade from green to teal
  for (b = 0; b < 256; b++) {
     analogWrite(BLUEPIN, b);
     delay(FADESPEED);
  }
  // fade from teal to blue
  for (g = 255; g > 0; g--) {
     analogWrite(GREENPIN, g);
     delay(FADESPEED);
  }
}



Fa. Adafruit Industries
Adafruit Tutorial auf RGB-LED-Streifen
03 https://learn.adafruit.com/rgb-led-strips/overview
05 https://learn.adafruit.com/rgb-led-strips/schematic
06 https://learn.adafruit.com/rgb-led-strips/current-draw
07 https://learn.adafruit.com/rgb-led-strips/wiring
10 https://learn.adafruit.com/rgb-led-strips/usage
12 https://learn.adafruit.com/rgb-led-strips/example-code
https://learn.adafruit.com/rgb-led-strips





*********************************************************

11    Digital adressierbarer RGB-LED-Strip vom Typ LPD8806  led strip

300_d_Rothen-x_Digital adressierbarer RGB-LED-Strip mit Arduino_1a.pdf

https://learn.adafruit.com/digital-led-strip

Digital adressierbarer RGB-LED-Strip vom Typ LPD8806, Länge 1 Meter
Netzteil AC/DC-Adapter 5Vdc, für 1 Meter 2Amp.

Wichtig zu erwähnen ist, dass die LEDS einzeln adressierbar sind. Sie sind hintereinander mit einem Schieberegister verbunden,
d.h. Frequenz skaliert mit der Länge.
5m haben eine max. Updatefrequenz von ca. 500..600 Hertz.
Die LEDs haben eine PWM integriert - alles in allem einfach genau das was man braucht.
LPD-8806  8-bit  2 LEDs  (der Vorgänger war LPD6803 6-bit eine LED)







Für die RGB-LED-Strips gibt es eine fertige Library namens LPD8806 von Adafruit
Arduino library for LPD8806

Der Code ist für einen 1-Meter-Strip mit 32 LED, lässt sich mit etwas herumrechnen aber auch für andere Längen anpassen.
https://github.com/adafruit/LPD8806


#include "LPD8806.h"
#include "SPI.h"
 
/*
 * digitale RGB LED Strips vom Typ LPD8806 steuern
 * Weiterentwicklung des Tutorials von Adafruit
 * Autorin: Silvia Rothen, rothen ecotronics, Bern, Switzerland
*/
 
/*****************************************************************************/
 
// Anzahl RGB LEDs
int nLEDs = 32;
 
// Die zwei Arduino-Pins, mit denen der LED Strip verbunden ist
int dataPin  = 2;   //  Data-Pin mit pin-2
int clockPin = 3;   // Clock-Pin mit pin-3
usw.



beide GND-Anschlüsse, jener des ATX-Steckers und jener des LED-Strips kommen in die zwei GND-Anschlüsse des Arduino-Boards.
Das USB-Kabel kommt natürlich  zwischen PC und Arduino-Board


Fa. Adafruit
Digital Addressable RGB LED w/ PWM waterproof flexi strip (LPD8806)
Digital RGB LED Weatherproof Strip - LPD8806 32 LED $29.95
https://www.adafruit.com/products/306


Miyole 5 MT LPD8806 LED-Streifen Licht Digital Pixel Seil Licht 36 LED/m 6 IC/m IP67 Rohr wasserdichte magische Traumfarbe Band
Bunten led 1m/5m lpd8806 dc5v 32leds/m, 48leds/m, 52leds/m, 60leds/m optional wasserdichtes oder nicht- wasserdicht digitale rgb-led-streifen
DC5V 5 MT LPD8806 LED-Streifen 32 leds/M 16 Pixel/m Flexible RGB 5050 LED Band Licht Addressable Nicht-Wasserdichte Freies Verschiffen
Dc5v 5m lpd8806 led-streifen adressierbare rgb led streifen weiß/schwarz pcb 48leds/m 24 Pixel/m nicht- wasserdicht, fabrik großhandel
IP65 LPD8806 adressierbaren LED digital Streifen; 32/48/52/60 leds/m; DC5V Eingang; wasserdicht durch Silikonbeschichtung; Weiß und Schwarz PCB

http://ecotronics.ch.honorius.sui-inter.net/wordpress/2012/digital-adressierbarer-rgb-led-strip-mit-arduino/


*********************************************************
12 LED-Stripe-Digital-Ansteuerung
Ansteuerung digitaler LED-Stripes (vornehmlich via DMX  im Selbstbau).
digitalen LED-Stripes (TM1829),  LED-Stripe-digital-TM1829-via-DMX
Eine DMX-Ansteuerung geschieht bei digitalen Stripes gemeinhin über so genannte DMX to SPI Konverter welche die „Üebersetzung“ zwischen DMX-Protokoll und den spezifischen Controller-Protokollen übernehmen.

LED- / Controller

3-Draht-Typen (Vcc, GND, Data): TM1829, WS1812B
4-Draht-Typen (Vcc, GND, Data, Clock): LPD8806, TLC5947

TM1829 vs. WS2812 und die Stripelaenge

DMX to SPI Konverter-01 (TM1829, WS2811, WS2812, WS2812B) a


http://www.dmxcontrol.de/wiki/Kategorie:Selbstbau-Projekte
http://www.dmxcontrol.de/wiki/LED-Stripe-Digital-Ansteuerung
http://forum.dmxcontrol-projects.org/index.php?thread/9183-led-stripe-digital-tm1829-via-dmx/



*********************************************************

13    Full-Color RGB LED-Strip-Treibermodul für Arduino    SKU: 314667
Auf der Grundlage einer P9813; Kann kaskadiert alle Lichter der das Antriebsmodul;
Nur zwei Steuerleitungen und zwei Netzkabel können fünf Meter lange Farbe (RGB) Lichtleiste Steuern;
Können auch kaskadiert werden mehr Antriebsmodule Steuern mehr Licht bar;
Setzen Sie einfach das Programm von rot, grün und blau entspricht derjenigen des entsprechenden Kanals;
weit verbreitet im Geländer Kontrolle, Zimmer Dekor und andere Anlässe;
Geeignet für 5V MCU-System, Arduino UNO R3 und kompatibles Motherboard.



http://www.dx.com/de/p/full-color-rgb-led-strip-driver-module-for-arduino-blue-black-314667?tc=EUR&gclid=CK_k7_Sh0ckCFQMIwwodFqABDA#.VmlsLOKo0jA




Adafruit 24-Channel 12-bit PWM LED Driver - SPI Interface - TLC5947

physicalcomputing.at  Artikel-Nr.: K-10829

adafruit TLC5947
24-Chanel 12-bit PWM
Open-drain outputs
Ub=5..24Vdc
Logic: 3..5Vdc


Beschreibung:
Mit diesem Breakout-Board für den TLC5947 PWM-Treiber-Chip können 24 getrennte Kanäle mit 12-Bit-PWM-Ausgängen gesteuert werden. Dieses Board wurde für die Steuerung von LED´s entwickelt und ist nicht gut für das Antreiben von Servos geeignet. 

Für den Antrieb von mehreren Servos verwenden Sie z.B. den USB Servo Controller.

Für den Betrieb des LED Drivers sind nur drei "SPI" Pins erforderlich (die Adafruit Arduino Library zeigt, wie Sie die digitalen Microcontroller Pins verwenden). Das Driver Board ist auch mit weiteren Boards erweiterbar. Solange genug Strom für alle Boards vorhanden ist können Sie so viele miteinander verbinden wie Sie wollen. Jeder der 24 Ausgänge liefert konstanten Strom und Open-Drain. Sie können mehrere LEDs, mit einer V+ Anode mit einer Stromversorgung von bis zu 30V, in Serie schalten. Wenn Sie etwas mit digitalem Input antreiben wollen, müssen Sie einen Pullup-Widerstand vom Antriebspin zu Ihrem Logic Level verwenden um die volle Wellenform zu erstellen.

Ein Widerstand wird verwendet, um den Strom für jeden Ausgang einzustellen, der  konstante Strom bedeutet, dass die LED-Helligkeit bei Stromversorgungseinbrüchen nicht variiert. Wir empfehlen einen 3.3K Widerstand bei etwa 15mA, aber Sie können einen Durchgangs-Widerstand darüber löten, wenn Sie diesen Wert verändern möchten. Überprüfen Sie das TLC5947 Datenblatt für Details zu Widerstand zu Strom Werten.

Für die einfachere Bedienung dieses Board wurden ein paar Extras integriert: ein dauerhafter 5V Low-Dropout-Regler (mit Verpolungsschutz), eine grüne Power-LED, vier Befestigungslöcher und ein Strom-Sollwiderstand. Eine Stiftleiste ist ebenfalls enthalten, diese könne Sie einlöten und somit das Board auf einem Breadboard verwenden.

Getting Started: Power V + mit 5-30VDC und Ground mit dem Common Ground verbinden. Dann senden Sie 3-5V Logik SPI Daten auf DIN (data in), CLK (clock) und LAT (latch). Wenn Sie schnell alle Ausgänge ausschalten möchten, setzen Sie den OE Pin auf HIGH.

Die Adafruit Arduino Bibliothek bietet als Startprojekt einen Beispielcode, der Leds blinken lässt.  

https://github.com/adafruit/Adafruit_TLC5947

Hier finden Sie einTutorial von Adafruithttps://learn.adafruit.com/tlc5947-tlc59711-pwm-led-driver-breakout



http://physicalcomputing.at/epages/f46ab952-295a-4f65-8ffa-38a4b8eec267.sf/de_DE/?ObjectPath=/Shops/f46ab952-295a-4f65-8ffa-38a4b8eec267/Products/K-10829





LED-Balken Anzeige - Kit

SparkFun Bar Graph Breakout Kit    DEV-10936

sparkfun 30-LED Bargraph

mit 3Stk. 10 Segment LED Balken


https://www.sparkfun.com/products/10936

Fa. sparkfun electronics   Bargraph Breakout Kit

www.sparkfun.com/tutorials/106

https://learn.sparkfun.com/tutorials

http://forum.sparkfun.com

Beschreibung:
Dieser Kit beinhaltet alle Teile die für die Darstellung eines 30-teiligen LED-Balken benötigt werden. Dieses Board kann mit einem Arduino oder einem anderen Mikrocontroller angesteuert werden.
Bei diesem Kit werden das Shiftregister 74HC595 und 3 Stk. 10-Segment LED Balken in den Farben grün, gelb und rot verwendet.
Dieses Display kann einfach mit einem Mikrocontroller über das SSI Interface gesteuert werden (jede einzelne LED kann angesteuert werden).

Bemerkung:
Dieses Set wird als "Kit" ausgeliefert und muss selbst zusammen gebaut werden. Einfache Lötkenntnisse sind erforderlich.

Abmessungen:

  • ca 51mm x 76mm

Mekmale:

  • 5V @ 250mA max (alle LED´s ein)
  • Synchronous Serial Interface (SSI)
  • durch Anschlussleiste erweiterbar (für größere Display´s)

 

Links:
Schematic
Eagle files
Datasheet (LEDs)
Datasheet (74HC595)
Arduino library and example code
Kit Guide

http://physicalcomputing.at/epages/f46ab952-295a-4f65-8ffa-38a4b8eec267.sf/de_DE/?ObjectPath=/Shops/f46ab952-295a-4f65-8ffa-38a4b8eec267/Products/A-10267



19    Adressierbarer RGB LED-Streifen 1m

Addressable RGB 30-LED Strip, 5V, 1m, (Low-Speed TM1804) 

Addressable RGB 150-LED Strip, 5V, 5m (WS2812B)

physicalcomputing.at  Artikel-Nr.: A-10131




RGB LED-Streifen, frei adressierbar, 1m
Beschreibung:
Dieser 1m lange RGB LED-Streifen enthält 30 RGB LEDs.
Diese sind über ein "one-wire Interface" frei adressierbar.
So kann für jede LED die Farbe individuell eingestellt werden.
Der Streifen ist wasserdicht.
Auf der Rückseite befindet sich ein Klebestreifen von 3M.
Die LEDs werden mit 5Vdc betrieben.
Der LED-Streifen kann entweder nach Wunsch abgeschnitten, oder auch verlängert werden.

Weitere Information bei Pololu

PololuLedStrip.h
LedStripColorTester.ino
https://github.com/pololu/pololu-led-strip-arduino

https://www.pololu.com/product/2548

http://physicalcomputing.at/Adressierbarer-RGB-LED-Streifen-1m



*********************************************************

14    Arduino RGB LED Strip Controller   

3x Potentiometer 10k
RGB-LED strip
3x BC547B  oder  TIP31  max. 100mA



    RGB-LED-Streifen haben in der Regel 4 Leitungen: eine für die Betriebsspannung, und je eine für Rot, Grün und Blau.
Wenn der Streifen mit Strom versorgt wird, zieht eine der Steuerleitungen an Masse bewirkt, dass die Farb-LED, um bei voller Helligkeit leuchten.

Verwenden von Pulsweitenmodulation (PWM) auf diesen Steuerleitungen können Sie die Helligkeit der Lichter zu modulieren.
    
Ein 1m Streifen kann lang fast 1A zu ziehen, wenn die roten, grünen und blauen LEDs sind auf volle Helligkeit. Ausgangspins ein Arduino kann nur liefern rund 40mA jeden, so müssen Sie, um es zu helfen, mit einer Treiberschaltung, um die Leistung zu steigern.
Diese Schaltung nimmt 3 PWM-Signale von der Arduino und nutzt sie, um 3-Transistoren Versorgung der roten, grünen und blauen LEDs zu fahren - damit haben Sie volle Kontrolle über die Helligkeit jeder Farbe, so können Sie sie mischen jede Farbe in das erstellen
Spektrum.
    
HINWEIS: Möchten Sie 1 oder 2 LEDs statt einer ganzen Streifen?
Ignorieren Sie die Transistoren und verbinden die LEDs direkt an Ausgangs-Pins des Arduino.
    
Die Treiberschaltung (Bild) ist eine grundlegende Transistorverstärker 3 mal wiederholt. Ub=5V, Niederstrom-PWM-Signal kommt aus dem Arduino, um die Basis des Transistors (B) über einen 1k Widerstand. Dieses Signal schaltet den Transistor, so dass sie höhere Strom bei 12V über dem Kollektor (C) und dem Emitter (E) durch die LEDs durchzuführen.
Der Transistor kann schnell genug zu schalten, so dass der LED-Leistung ist genau wie das Eingangssignal PWM, was zu dem gewünschten Helligkeitsregelung.
    
HINWEIS: Darauf achten, dass gerade die Transistor steuern, welche Farben-LED, und verbinden Sie den Transistoren richtig herum zu halten, nach der Belegung des TIP31-Transistor 
Und vergessen Sie nicht, den Arduino-GND auch auf Masse des 12V-Netzteil anschließen!
   
Die vollständigen Schaltung sollte wie unten aussehen.
Die Ausgänge der Schaltung auf einen 4-Pin-Header zu gehen auf der rechten Seite, bereit, ein RGB-LED-Streifen anzunehmen.
grüne Leitungen zur Transistor bases-pin durch 1k Widerstand ersetzen.





Beispiel Sketch

// RGB-LED-strip.ino
int const rPotPin = A2;
int const gPotPin = A1;
int const bPotPin = A0;

int const rOutPin = 3;
int const gOutPin = 5;
int const bOutPin = 6;

int rVal;
int gVal;
int bVal;

void setup() { pinMode(rOutPin, OUTPUT); pinMode(gOutPin, OUTPUT); pinMode(bOutPin, OUTPUT); }
void loop() { rVal = analogRead(rPotPin) / 4; gVal = analogRead(gPotPin) / 4; bVal = analogRead(bPotPin) / 4; analogWrite(rOutPin, rVal); analogWrite(gOutPin, gVal); analogWrite(bOutPin, bVal); }

http://www.instructables.com/id/Arduino-RGB-LED-Strip-Controller/








*********************************************************
15    RGB LED Strips    

Siehe unter 10    https://learn.adafruit.com/rgb-led-strips

http://www.ladyada.net/products/rgbledstrip/




*********************************************************
16    RGB-LED vom Typ NeoPixel, der von Adafruit    WS2812

siehe auch
http://sites.prenninger.com/arduino-uno-r3/beginner


RGB-LED, die so heist, da sie einen roten (R), grünen (G) und blauen (B) Farbkanal hat und somit 16 Millionen Farben darstellen kann, da jeder Kanal Werte zwischen 0 und 255 annehmen kann.

NeoPixel Stick - 8 x WS2812 5050 RGB LED


https://learn.adafruit.com/adafruit-neopixel-uberguide?view=all

Fa. Adafruit NeoPixel Bibliothek (Library)
Adafruit_NeoPixel.h
Adafruit_NeoPixel-master.zip
C:\Programme\Arduino\libraries\Adafruit_NeoPixel\Adafruit_NeoPixel.h

Dokumente:
Datenblatt WS2812
 
Adafruit NeoPixel Library
https://github.com/adafruit/Adafruit_NeoPixel
 
Adafruit NeoPixel Überguide
https://learn.adafruit.com/adafruit-neopixel-uberguide
 
Boxtec LED Pixel Guide
http://playground.boxtec.ch/doku.php/led/ledpixel_guide


Die Farbinformation für alle Pixel wird in einem Array gespeichert und beim Aufruf der Routine show() in einem Schwung an die seriell verbundenen Pixel geschickt.

Damit hat man also die jeweiligen Pixelwerte immer parat und kann sie entsprechend abfragen und muss sie nicht selbst zwischenspeichern.

WS2801, WS2811, WS2812, WS2812S, WS2812B - was nun?

Ich habe hier die RGB-LEDs des Neopixel Produkts von Adafruit besprochen.

Diese basieren auf den WS2812 LEDs bzw. WS2811 Treibern.

Den Streifen, welchen ich gekauft habe, verwenden den WS2812S, neuere verwenden den WS2812B.

Was ist denn nun der Unterschied:

    WS2811 - das ist der Treiberchip
    WS2812S - ältere Version, besteht aus einer 5050-RGB-LED und dem WS2811 Treiber in einem kompakten Gehäuse, hat 6-pins
    WS2812B - neuere Version, Aufbau wie WS2812S, aber nur 4 -pins

Die LED WS2801 wird komplett anders angesprochen und ist nicht mit den hier beschriebenen LEDs kompatibel.


#include <Adafruit_NeoPixel.h>
#define PIN 10
Adafruit_NeoPixel strip = Adafruit_NeoPixel(8, PIN, NEO_GRB + NEO_KHZ800);
int wc = 0;

void setup() {
  strip.begin();
  strip.show(); // Initialize all pixels to 'off'
}

void loop() {
  // knight rider LEDs
  int t;
  for (int i = 0; i < strip.numPixels(); i++) {
    strip.setPixelColor(i, Wheel(wc));
    t = i - 1;
    if (t < 0) t = strip.numPixels() - 1;
    strip.setPixelColor(t, strip.Color( 0, 0, 0));
    strip.show();
    delay(50);
  }
  for (int i = strip.numPixels()-1; i >= 0; i--) {
    strip.setPixelColor(i, Wheel(wc));
    t = i + 1;
    if (t >= strip.numPixels()) t = 0;
    strip.setPixelColor(t, strip.Color( 0, 0, 0));
    strip.show();
    delay(50);
  }
  wc++;
  if (wc>255) wc=0;
}

uint32_t Wheel(byte WheelPos) {
  if (WheelPos < 85) {
    return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
  } else if (WheelPos < 170) {
    WheelPos -= 85;
    return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  } else {
    WheelPos -= 170;
    return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
}


https://shop.boxtec.ch/neopixel-stick-ws2812-5050-rgb-led-p-41919.html
http://www.mathias-wilhelm.de/arduino/beginner/schritt-5-jetzt-wird-es-bunt/





*********************************************************
18    Arduino Controlled RGB LED Light Strips   




//   RGB_LED_Flash_PWM.ino
// by Desta Courtney      www.usLEDsupply.com

int BluePin = 9;                   // Digital Pin 9 Connected to B on Amp
int GreenPin = 10;                 // Digital Pin 10 Connected to G on Amp
int RedPin = 11;                   // Digital Pin 11 Connected to R on Amp

int a = 1200;     // Blue on Time
int b = 0;
int c = 1200;     // Green on Time
int d = 0;
int e = 1200;     // Red on Time
int f = 0;
int g = 1200;     // Yellow on Time
int h = 0;
int i = 1200;     // Light Blue on Time
int j = 0;
int k = 1200;     // Puple on Time
int l = 0;
int x = 240;     // Sets On Level 0 = 100% (Lower Number will be brighter)
int y = 255;     // Sets Off Level 255 = 0% (Higher Number will be dimmer)


void setup()
{
  pinMode(BluePin, OUTPUT);      // sets the digital pin as output
  pinMode(GreenPin, OUTPUT);      // sets the digital pin as output
  pinMode(RedPin, OUTPUT);      // sets the digital pin as output
  analogWrite(BluePin, y);
  analogWrite(GreenPin, y);
  analogWrite(RedPin, y);
  
}

void loop()
{
    analogWrite(BluePin, x);
    delay(a);
    analogWrite(BluePin, y);
     
    delay(b);  
    
    analogWrite(GreenPin, x);
    delay(c);
    analogWrite(GreenPin, y);
    
    delay(d);
    
    analogWrite(RedPin, x);
    delay(e);
    analogWrite(RedPin, y);
    
    delay(f);
    
    analogWrite(BluePin, x);
    analogWrite(GreenPin, x);
    delay(g);
    analogWrite(BluePin, y);
    analogWrite(GreenPin, y);
    delay(h);
    
    analogWrite(RedPin, x);
    analogWrite(GreenPin, x);
    delay(i);
    analogWrite(RedPin, y);
    analogWrite(GreenPin, y);
    delay(j);
    
    analogWrite(BluePin, x);
    analogWrite(RedPin, x);
    delay(k);
    analogWrite(BluePin, y);
    analogWrite(RedPin, y);
    delay(l);
    

}

  

http://www.ledstyles.de/index.php/Thread/18454-RGB-Stripe-mit-Arduino-ansteuern/
http://fritzing.org/projects/arduino-controlled-rgb-led-light-strips
http://fritzing.org/projects/arduino-knight-rider-with-8-blue-12v-led-modules/





*********************************************************

20    LPD8806 RGB LED Streifen - 32 LED/m im Silikonschlauch (5m)   

RGB LED Streifen mit dem LPD8806 Controller.
Bei diesem ist es möglich jede einzelne LED in Farbe und Helligkeit zu steuern.
Pro Meter sind 32 RGB LEDs verbaut.


Arduino library for the NEWER LPD8806-based strip
LPD8806.h
strandtest.ino
LEDbeltKit.pde
 https://github.com/adafruit/LPD8806

Arduino library for the OLDER HL1606-based LED strip (on/off only)
HL1606strip.h
basicPatterns.pde
https://github.com/adafruit/HL1606-LED-Strip

Arduino library for the OLDER HL1606-based LED strip (basic PWM control)
HL1606stripPWM.h
colorswirl.pde
pulse.pde
https://github.com/adafruit/HL1606-LED-Strip-PWM


http://www.watterott.com/de/Digital-Addressable-RGB-LED





*********************************************************
21    Steuerung von RGB LED strip   
Anleitung um mit dem Arduino eine 12V RGB-LED zu betreiben.

Der Aufbau

Benötigte Bauteile 

Für den Aufbau braucht man folgende Bauteile:

  3x Transistor MOSFET IRL540N
  3x Diode 1N4007
  1x RGB-Strip (z.B. Conrad mann kan auch eine längere Strip benutzen)
  1x 12V Netzteil (Conrad ich benutze ein altes Computernetzteil)
  1x Taster (Schließer)
  1x Widerstand 10k
  1x Arduino Board (bei mir ARDUINO UNO R3)

Außerdem sollte man ein Steckboard besitzen (Conrad) da man so ohne zu Löten Schaltungen aufbauen kann.
Desweiteren benötigt man einer Leitung, dafür eignet sich am besten Klingeldraht (Conrad).


Der Stromlaufplan


Wie schließe ich den Transistor richtig an?

In dem nächsten Bild wird gezeigt wo man das Gate [G], Drain [D] und Source [S] findet:



Bei Fragen wie ein MOSFET Transistor funktioniert kann ich diesen Artikel empfehlen.

Was ist eine RGB-Strip

Am besten fange ich damit an was eine RGB-LED ist.
Bei dieser LED handelt es sich im Grunde um drei LEDs in einer, nämlich eine Rote, eine Grüne und eine Blaue.
Diese drei LEDs besitzen in der RGB-LED gemeinsame +12V. Folglich hat einer RGB-LED 4 Pinne einen für +12V, einen für die Rote LED, eine für die Grüne LED und einen für die Blaue LED.
Eine RGB-Strip ist nichts anderes als, einige RGB-LEDs die auf einem Band hintereinander Gelötet wurden.
Diese haben die Anschlüsse +12V, Rot [R], Grün [G] und Blau[B]. die Vorwiederstände für die LEDs sind bereits draufgelötet.

So sieht mein Aufbau der Schaltung aus:


Der Code

RGB___Programm_1.ino


// RGB___Programm_1_1.ino
// Programm zum steuern von RGB Stipen
// Das ist mein 1. Programm zum steuern von RGB-Stripen. Die funktion besteht darin das die Zeit, in der
// der Farbwechsel statfinden soll mit der Variabele TIME eingestellt werden soll. Außerdem kann man an den
// Variabelen DIM_B, DIM_G und DIM_R Die Start Farbe beinflussen und so eine Farb obtimierung durchführen.

// Fals es Fragen zu dem Programm gibt könnt ihr mich unter Pilot.Arduino@gmail.com erreichen.
// Vergest nicht meinen Blog zu abonieren unter http://arduino-pilot.blogspot.de/

const int LED_B = 11; // Blaue LED an PIN 11
const int LED_G = 10; // Grüne LED an PIN 10
const int LED_R = 9; // Rote LED an PIN 9
const int SCHALTER= 12; // EIN/AUS auf pin 12

int val = 0; // Einlesen des Tasters
int old_val = 0; // für den Siegnal wechsel
int state = 0; // Siegnal speichern bis nächste betätigung
int DIM_B = 80; // Startwert LED Dimmer Blau
int DIM_G = 160; // Startwert LED Dimmer Grün
int DIM_R = 240; // Startwert LED Dimmer Rot
int TIME = 0; // Variabele für die geschwindichkeit der Farbänderung in ms.

// Variabelen für Hin und zurück Dimmung
int Blau = 1;
int Gruen = 1;
int Rot = 1;



void setup() {
pinMode(LED_B, OUTPUT); // PIN zuweisung als Ausgang
pinMode(LED_G, OUTPUT); // PIN zuweisung als Ausgang
pinMode(LED_R, OUTPUT); // PIN zuweisung als Ausgang

pinMode(SCHALTER, INPUT); // PIN zuweisung als Eingang
}



void loop() {

val = digitalRead(SCHALTER); // Status von Taster einlesen

if ((val == HIGH) && (old_val == LOW)) { // bedingung für Signalwechsel
state = 1 - state; // Siegnalwechsel
delay(10); // Zeit für Entprellung
}

old_val = val; // Zuweisung für old_val_A

if (state == 1) { // Licht einschalten

// Dimm programm für RGB-LED

// Blaue LED
if ((DIM_B < 255) && (Blau == 1)) { // Maximalen wert und Zählrichtung (aufwärts) festlegen.
DIM_B = DIM_B + 1; // Bei jedem durchlauf den DIM Wert um 1 erhöhen
delay(TIME); // TIME Warten
} else {
Blau = 0; // Runterzählen Aktivieren
delay(10); // 10ms Warten
}
if ((DIM_B > 1) && (Blau == 0)) { // Maximalen wert und Zählrichtung (abwärts) festlegen.
DIM_B = DIM_B - 1; // Bei jedem durchlauf den DIM Wert um 1 verringern
delay(TIME); // TIME Warten
} else {
Blau = 1; // Hochzählen Aktivieren
delay(10); // 10ms Warten
}

// Güne LED
if ((DIM_G < 255) && (Gruen == 1)) { // Maximalen wert und Zählrichtung (aufwärts) festlegen.
DIM_G = DIM_G + 1; // Bei jedem durchlauf den DIM Wert um 1 erhöhen
delay(TIME); // TIME Warten
} else {
Gruen = 0; // Runterzählen Aktivieren
delay(10); // 10ms Warten
}
if ((DIM_G > 1) && (Gruen == 0)) { // Maximalen wert und Zählrichtung (abwärts) festlegen.
DIM_G = DIM_G - 1; // Bei jedem durchlauf den DIM Wert um 1 verringern
delay(TIME); // TIME Warten
} else {
Gruen = 1; // Hochzählen Aktivieren
delay(10); // 10ms Warten
}

// Rote LED
if ((DIM_R < 255) && (Rot == 1)) { // Maximalen wert und Zählrichtung (aufwärts) festlegen.
DIM_R = DIM_R + 1; // Bei jedem durchlauf den DIM Wert um 1 erhöhen
delay(TIME); // TIME Warten
} else {
Rot = 0; // Runterzählen Aktivieren
delay(10); // 10ms Warten
}
if ((DIM_R > 1) && (Rot == 0)) { // Maximalen wert und Zählrichtung (abwärts) festlegen.
DIM_R = DIM_R - 1; // Bei jedem durchlauf den DIM Wert um 1 verringern
delay(TIME); // TIME Warten
} else {
Rot = 1; // Hochzählen Aktivieren
delay(10); // 10ms Warten
}

analogWrite(LED_B, DIM_B); // Schreiben auf Ausgangs PIN
analogWrite(LED_G, DIM_G); // Schreiben auf Ausgangs PIN
analogWrite(LED_R, DIM_R); // Schreiben auf Ausgangs PIN

} else {
digitalWrite(LED_B, LOW); // Ausgang auf LOW setzen
digitalWrite(LED_G, LOW); // Ausgang auf LOW setzen
digitalWrite(LED_R, LOW); // Ausgang auf LOW setzen
}
}




RGB___Programm_2.ino


// RGB___Programm_2.ino
// Programm zum steuern von RGB Stipen

// Das ist mein 2. Programm zum steuern von RGB-Stripen. Die funktion besteht darin das die Zeit, in der
// einen der drei Grundfarben (Rot, Grün, Blau) leuchten soll mit der Variabele TIME_F in Millisekunden
// eingestellt werden kann. Wie lange der Farbwechsel dauern soll kann mit der Variabele TIME_W eingestellt
// werden.

// Fals es Fragen zu dem Programm gibt könnt ihr mich unter Pilot.Arduino@gmail.com erreichen.
// Vergest nicht meinen Blog zu abonieren unter http://arduino-pilot.blogspot.de/

const int LED_B = 11; // Blaue LED an PIN 11
const int LED_G = 10; // Grüne LED an PIN 10
const int LED_R = 9; // Rote LED an PIN 9
const int SCHALTER = 12; // EIN/AUS auf pin 12

int val = 0; // Einlesen des Tasters
int old_val = 0; // für den Siegnal wechsel
int state = 0; // Siegnal speichern bis nächste betätigung
int DIM_B = 255; // Startwert LED Dimmer Blau
int DIM_G = 0; // Startwert LED Dimmer Grün
int DIM_R = 0; // Startwert LED Dimmer Rot
int TIME_F = 3000; // Zeit die, die ereichte Farbe bleiben soll
int TIME_W = 50; // Zeeit für wechseln der Farbe

int R_B = 0; // Rot hochzälen, Blau runterzählen
int G_R = 0; // Grün hochzählen Rot runterzählen
int B_G = 0; // Blau hochzählen Grün runterzählen




void setup() {
pinMode(LED_B, OUTPUT); // PIN zuweisung als Ausgang
pinMode(LED_G, OUTPUT); // PIN zuweisung als Ausgang
pinMode(LED_R, OUTPUT); // PIN zuweisung als Ausgang

pinMode(SCHALTER, INPUT); // PIN zuweisung als Eingang
}



void loop() {
val = digitalRead(SCHALTER); // Status von Taster einlesen
if ((val == HIGH) && (old_val == LOW)) { // bedingung für Signalwechsel
state = 1 - state; // Siegnalwechsel
delay(10); // Zeit für Entprellung
}

old_val = val; // Zuweisung für old_val_A
if (state == 1) { // Licht einschalten

// Dimm programm für RGB-LED
// Bedingungen für Schritte
if ((DIM_R == 0) && (DIM_G == 0) && (DIM_B == 255)) { // Bedingung für den Ersten Schritt in dem
R_B = 1; // Rot auf 255 und Blau auf 0 gezählt wird
delay(TIME_F); // Zeit wie lange Blau Bleibt
}
if ((DIM_R == 255) && (DIM_G == 0) && (DIM_B == 0)) { // Bedingung für den zweiten Schritt in dem
G_R = 1; // Grün auf 255 und Rot auf 0 gezählt wird
delay(TIME_F); // Zeit wie lange Rot Bleibt
}
if ((DIM_R == 0) && (DIM_G == 255) && (DIM_B == 0)) { // Bedingung für den driten Schritt in dem
B_G = 1; // Blau auf 255 und Rot auf 0 gezählt wird
delay(TIME_F); // Zeit wie lange Grün Bleibt
}

// Program zum ersten Schritt

if ((R_B == 1) && (DIM_B > 0)) { // Der Schritt beginnt
DIM_B = DIM_B - 1; // Der Wert wird runtergezählt
delay(TIME_W); // Zeit für Farb wechsel
DIM_R = DIM_R + 1; // Der Wert wird hochgezählt
delay(TIME_W); // Zeit für Farb wechsel
}
else {
R_B = 0; // Wenn DIM_B 0 ist wird R_B ebenfals 0
}

// Program zum zweiten Schritt

if ((G_R == 1) && (DIM_R > 0)) { // Der Schritt beginnt
DIM_R = DIM_R - 1; // Der Wert wird runtergezählt
delay(TIME_W); // Zeit für Farb wechsel
DIM_G = DIM_G + 1; // Der Wert wird hochgezählt
delay(TIME_W); // Zeit für Farb wechsel
}
else {
G_R = 0; // Wenn DIM_R 0 ist wird G_R ebenfals 0
}

// Program zum zweiten Schritt

if ((G_R == 1) && (DIM_R > 0)) { // Der Schritt beginnt
DIM_R = DIM_R - 1; // Der Wert wird runtergezählt
delay(TIME_W); // Zeit für Farb wechsel
DIM_G = DIM_G + 1; // Der Wert wird hochgezählt
delay(TIME_W); // Zeit für Farb wechsel
}
else {
G_R = 0; // Wenn DIM_R 0 ist wird G_R ebenfals 0
}

// Program zum driten Schritt

if ((B_G == 1) && (DIM_G > 0)) { // Der Schritt beginnt
DIM_G = DIM_G - 1; // Der Wert wird runtergezählt
delay(TIME_W); // Zeit für Farb wechsel
DIM_B = DIM_B + 1; // Der Wert wird hochgezählt
delay(TIME_W); // Zeit für Farb wechsel
}
else {
B_G = 0; // Wenn DIM_G 0 ist wird B_G ebenfals 0
}

analogWrite(LED_B, DIM_B); // Schreiben auf Ausgangs PIN
analogWrite(LED_G, DIM_G); // Schreiben auf Ausgangs PIN
analogWrite(LED_R, DIM_R); // Schreiben auf Ausgangs PIN

} else {
digitalWrite(LED_B, LOW); // Ausgang auf LOW setzen
digitalWrite(LED_G, LOW); // Ausgang auf LOW setzen
digitalWrite(LED_R, LOW); // Ausgang auf LOW setzen
}
}


Ich hab zwei Programme hochgeladen. Siehe hier.

Bei beiden Programmen habe ich einen neuen Befehlverwendet.

analogWrite(LED_R, DIM_R);

Denn digitalWritr() Befehl habe ich ja schon vorgestellt.
Diesen Benutzt man um einen Pin auf HIGH oder LOW zu schalten also 5V oder 0V.
Arduino besitzt auch Analogeausgänge, diese werden mit diesem Zeichen ~ gekennzeichnet und stehen vor der Pin Nummer,
z.B. ~11. Das besondere an Analogenausgängen ist diese einen Wert zwischen HIGH und LOW annehmen können also einen Wert zwischen 5V und 0V.
Bei Arduino beträgt die Stückelung 255, dass bedeutet das die 5V durch 255 geteilt wurden.
Mann kann deshalb mit dem analogWrite() eine Zahl zwischen 255 und 0 ausgeben, bei der Zahl 200 würden so ca. 3,9V am Ausgang anliegen.
In dem oben gezeigten Beispiel steht das LED_R für den Pin der als Ausgang fungieren soll.
Bei DIM_R handelt es sich um eine Variable die den Wert enthält der ausgegeben werden soll.


In meinem Nächsten Beitrag werde ich zeigen wie ich die Bauteile auf eine Platine Löte und diese dann in ein altes PC-Gehäuse einbaue.




http://arduino-pilot.blogspot.co.at/2013/07/steuerung-von-rgb-led-strip.html





*********************************************************

23    RGB LED-Streifen Schaltung mit Arduino   

Schritt 1: Kurze Erläuterung der Elektronik
Schritt 2: Montage eines Transistors mit einem Kühlkörper
Schritt 3: Montieren Sie den Stromkreis
Schritt 4: Schreiben Sie (oder Hack) ein Programm und Hochladen auf Ihre Arduino

Diese Instructable deckt die Montage einer Schaltung, die PWM-ing ( Pulsweitenmodulation ) eines 9-12V RGB LED Streifen und Programmierung eines Arduino, um durch die verschiedenen Farben. Werde ich diskutieren, wie man einen Transistor mit einem Kühlkörper montieren und montieren Sie die Schaltung, aber nicht in Löten zu erhalten, wie einige RGB-LED-Streifen werden mit Leitungen (und es gibt keinen Mangel an großen Tutorials gibt).
 
Bauteile:
- Einen  Mikrocontroller  ARDUINO UNO R3
- BreadBoard
- RGB LED-Streifen
- Batterie (9-12V)
- 3 NPN-Transistoren ( z.B. TIP120s )
- Spannungsregler LM7805 (optional, aber empfohlen)
- (4) 4..40 Schrauben M3
- (4) 4..40 Muttern M3
- (4), Nylon-Unterlegscheiben  für M3
-  1m Schaltdraht Dm  0,64mm


http://www.clickoslo.com/intro-zu-led-streifen.html
http://www.clickoslo.com/rgb-led-streifen-schaltung-mit-arduino.html






*********************************************************

25    Diamex 5-m-RGB-LED-Streifen mit 150 WS2812-RGB-LEDs, hochflexibel

        
24x13  LED-Matrix mit RGB-LEDs 

ELV Artikel-Nr.: 68-117744

RGB-LED-Streifen sind eine feine Sache, aber es sind eben nur alle LEDs gemeinsam mit einem Effekt ansteuerbar. Der RGB-LED-Streifen WS2812B bietet hier etwas völlig Neues für kreative Lichtdesigner – jede LED ist einzeln beliebig über die zum System passenden Controller ansteuerbar!

Jede der 150 RGB-LEDs des hochflexiblen 5-m-Streifens verfügt über einen eigenen internen Controller, der zentral über einen Bus (Single NZR Communication Mode) angesteuert wird. So kann man jede LED völlig individuell ansteuern und tolle Lichteffekte erzeugen. Ordnet man z. B. mehrere Teilstücke des LED-Streifens in einer 2D-Matrix an, so kann man über die Controller des Systems, deren mitgelieferte Demosoftware oder Freeware mit TMP-Protokoll wie Jinx!, Glediator oder Pixel Controller fantastische Bilder und Effekte erzeugen. 

  • 5-m-RGB-LED-Streifen mit 30 LEDs/m, jede LED einzeln abtrennbar, 1 Abschnitt = 33 mm
  • Superflexibler Träger mit Klebeband
  • WS2812B-LEDs: interner WS2811-Controller, Datenformat GRB, Daten-Übertragungsrate 800 kbps, 8 Bit-PWM-Register
  • Versorgungsspannung 3,5–5,3 V, Stromaufnahme 20 mA je LED und Kanal

Hinweis: unter Volllast (Farbeinstellung weiß und höchste Helligkeitsstufe) werden 60 mA pro LED benötigt.



LEDs mit Intelligenz – RGB-LED mit integriertem Controller Teil 1    ELVjournal 2015-04s54
24x13  LED-Matrix mit RGB-LEDs

092_d_ELVjournal-x_2014-04s54  LEDs mit Intelligenz - RGB-LED mit integriertem Controller  WS2812B -1-_1a.pdf

[1] Datenblatt WS2812B
www.world-semi.com/en/Driver/Lighting/WS2811/WS212B/
[2] Datenblatt WS8211
www.world-semi.com/en/Driver/Lighting_LED_driver_chip/WS2811/
[3] Adafruit Neopixel Library 
https://github.com/adafruit/Adafruit_NeoPixel
[4] Glediator (Matrix-Controller-Programm)
www.solderlab.de
[5] Jinx! (Matrix-Controller-Programm)
www.live-leds.de/
[6] PixelController (Programm)
http://pixelinvaders.ch/?page_id=160
[7] tpm2-Protokoll
www.ledstyles.de/ftopic18969.html
[8] Schutzschaltung
www.led-studien.de/2014/06/24/ schutzschaltung-fuer-ws2812-pixel/





LEDs mit Intelligenz – RGB-LED-Matrix mit WS2812B Teil 2     ELVjournal 2015-05s40

15x15  LED-Matrix mit RGB-LEDs

LED-Stripes WS2812B, 4 m Länge mit 240 LEDs, LED-Abstand 17mm

092_d_ELVjournal-x_2015-05s40  LEDs mit Intelligenz - RGB-LED mit integriertem Controller  WS2812B -2-_1a.pdf


[1] ELV-Journal 3/2015
[2] Datenblatt WS2812B:
www.world-semi.com/uploads/soft/150522/1-150522091P5.pdf
[3] Infos zum TMP2-Format:
www.ledstyles.de/index.php/Thread/18969-tpm2-Protokoll-zur-Matrix-Lichtsteuerung 
https://gist.github.com/jblang/89e24e2655be6c463c56

[4] Software Jinx!:
www.live-leds.de
[5] Plexiglas Modulor:
www.modulor.de
Bestellhinweis: Platte in der entsprechenden Größe bestellen (Zuschnitt)!
www.modulor.de/Kunststoff-Gummi/Platten-Matten-Folien/Acrylglas-GS-Platten-und-Bloecke/ Plexiglas-GS-farbig-3-mm-3-0-x-1500-x-2000-mm-mittelgrau-transp-7C83.html
[6] http://hbholzmaus.eshop.t-online.de/
[7] Bopla-Aluplan-Gehäuse:
www.bopla.de/de/gehaeusetechnik/product/aluplan.html
[8] www.led-genial.de/LED-Player-spielt-LED-Effekte-von-SD-Karte-ab
[9] www.led-genial.de/LED-Controller-L-fuer-WS2812-mit-Fernbedienung-TPM2-Protokoll



Datenblatt WS2812B
http://files.elv.de/Assets/Produkte/11/1177/117743/Downloads/117743_streifen_data.pdf

http://www.elv.at/diamex-5-m-rgb-led-streifen-mit-ws2812-rgb-leds-hochflexibel.html





*********************************************************
26    Adressierbare Led Strips mit Arduino


Es gibt für DMX gesteuerte Strips extra Programme wie "Madrix" oder "Ledwalker" mit deren grafischer Oberfläche man quasi Frame für Frame die Leds auf den Bildschirm "malt" und so über die grafische Oberfläche die Licht-Bewegungen in den Led-Strips erzeugt.
Das ganze Programm speichert man anschließend auf SD-Karte und schiebt sie in einen teuren Controller der es dann abspielt und die LEDs steuert.



RGB LED´s mit WS2811


/*
### teldredge
### www.funkboxing.com
### teldredge1979@gmail.com

### FAST_SPI LED FX EXAMPLES
### MOSTLY DESIGNED FOR A LOOP/RING OF LEDS (ORIGINALLY FOR A SIGN)
### BUT PLENTY USEFUL FOR A LINEAR STRIP TOO

### NOTES:
### - THESE ARE EXAMPLES, NOT A 'LIBRARY', MEANING YOU'LL PROBABLY HAVE TO CUT AND PASTE
### - TESTED WITH WS2801 AND WS2811 USING ARDUINO DUEMENELOVE 328, USING THE NEWEST FAST_SPI LIBRARY
###        THE NEWEST ONE FIXES ISSUES WITH WS2801
###        I HAD PROBLEMS WITH THE WS2801 WITH THE OLDER LIBRARY
###        ALSO SET_DATARATE MATTERS
### - USES THE 'SERIALCOMMAND' LIBRARY FOR 'MODES', BUT THESE FXNS COULD BE LOOPED ANYWAY YOU WANT

### LICENSE:::USE FOR WHATEVER YOU WANT, WHENEVER YOU WANT, WHYEVER YOU WANT
### BUT YOU MUST YODEL ONCE FOR FREEDOM AND MAYBE DONATE TO SOMETHING WORTHWHILE
--------------------------------------------------------------------------------------------------
*/


#include <FastSPI_LED.h>
#include <SerialCommand.h>

#define NUM_LEDS 30
//#define NUM_LEDS 23
int BOTTOM_INDEX = 0;
int TOP_INDEX = int(NUM_LEDS/2);
int EVENODD = NUM_LEDS%2;

//-[HARDWARE SPI | CLOCK-13 | DATA-11]
//-[FOR TM1809 (AND WS2811) MUST BE ON A PWM PIN (I THINK)]
#define PIN 3
//#define PIN 4

//-YOU MAY HAVE TO PLAY WITH THE R,G,B ORDER OF THIS TO SUIT YOUR STRIP
struct CRGB { unsigned char g; unsigned char r; unsigned char b; };
//struct CRGB { unsigned char r; unsigned char b; unsigned char g; };
struct CRGB *leds;

int ledsX[NUM_LEDS][3]; //-ARRAY FOR COPYING WHATS IN THE LED STRIP CURRENTLY (FOR CELL-AUTOMATA, ETC)

SerialCommand sCmd;     //-SETUP SerialCommand OBJECT

int ledMode = 888;      //-START IN DEMO MODE
//int ledMode = 5;

//-PERISTENT VARS
int idex = 0;        //-LED INDEX (0 to NUM_LEDS-1
int idx_offset = 0;  //-OFFSET INDEX (BOTTOM LED TO ZERO WHEN LOOP IS TURNED/DOESN'T REALLY WORK)
int ihue = 0;        //-HUE (0-360)
int ibright = 0;     //-BRIGHTNESS (0-255)
int isat = 0;        //-SATURATION (0-255)
int bouncedirection = 0;  //-SWITCH FOR COLOR BOUNCE (0-1)
float tcount = 0.0;      //-INC VAR FOR SIN LOOPS
int lcount = 0;      //-ANOTHER COUNTING VAR

//------------------------------------- UTILITY FXNS --------------------------------------

//-SET THE COLOR OF A SINGLE RGB LED
void set_color_led(int adex, int cred, int cgrn, int cblu) {  
  int bdex;
  
  if (idx_offset > 0) {  //-APPLY INDEX OFFSET
    bdex = (adex + idx_offset) % NUM_LEDS;
  }
  else {bdex = adex;}
  
  leds[bdex].r = cred;
  leds[bdex].g = cgrn;
  leds[bdex].b = cblu;  
  }


//-FIND INDEX OF HORIZONAL OPPOSITE LED
int horizontal_index(int i) {
  //-ONLY WORKS WITH INDEX < TOPINDEX
  if (i == BOTTOM_INDEX) {return BOTTOM_INDEX;}
  if (i == TOP_INDEX && EVENODD == 1) {return TOP_INDEX + 1;}
  if (i == TOP_INDEX && EVENODD == 0) {return TOP_INDEX;}
  return NUM_LEDS - i;  
}


//-FIND INDEX OF ANTIPODAL OPPOSITE LED
int antipodal_index(int i) {
  //int N2 = int(NUM_LEDS/2);
  int iN = i + TOP_INDEX;
  if (i >= TOP_INDEX) {iN = ( i + TOP_INDEX ) % NUM_LEDS; }
  return iN;
}


//-FIND ADJACENT INDEX CLOCKWISE
int adjacent_cw(int i) {
  int r;
  if (i < NUM_LEDS - 1) {r = i + 1;}
  else {r = 0;}
  return r;
}


//-FIND ADJACENT INDEX COUNTER-CLOCKWISE
int adjacent_ccw(int i) {
  int r;
  if (i > 0) {r = i - 1;}
  else {r = NUM_LEDS - 1;}
  return r;
}


//-CONVERT HSV VALUE TO RGB
void HSVtoRGB(int hue, int sat, int val, int colors[3]) {
    // hue: 0-359, sat: 0-255, val (lightness): 0-255
    int r, g, b, base;

    if (sat == 0) { // Achromatic color (gray).
        colors[0]=val;
        colors[1]=val;
        colors[2]=val;
    } else  {
        base = ((255 - sat) * val)>>8;
        switch(hue/60) {
            case 0:
                r = val;
                g = (((val-base)*hue)/60)+base;
                b = base;
                break;
            case 1:
                r = (((val-base)*(60-(hue%60)))/60)+base;
                g = val;
                b = base;
                break;
            case 2:
                r = base;
                g = val;
                b = (((val-base)*(hue%60))/60)+base;
                break;
            case 3:
                r = base;
                g = (((val-base)*(60-(hue%60)))/60)+base;
                b = val;
                break;
            case 4:
                r = (((val-base)*(hue%60))/60)+base;
                g = base;
                b = val;
                break;
            case 5:
                r = val;
                g = base;
                b = (((val-base)*(60-(hue%60)))/60)+base;
                break;
        }
        colors[0]=r;
        colors[1]=g;
        colors[2]=b;
    }
}


void copy_led_array(){
  for(int i = 0; i < NUM_LEDS; i++ ) {
    ledsX[i][0] = leds[i].r;
    ledsX[i][1] = leds[i].g;
    ledsX[i][2] = leds[i].b;
  }  
}


void print_led_arrays(int ilen){
  copy_led_array();
  Serial.println("~~~***ARRAYS|idx|led-r-g-b|ledX-0-1-2");
  for(int i = 0; i < ilen; i++ ) {
      Serial.print("~~~");
      Serial.print(i);
      Serial.print("|");      
      Serial.print(leds[i].r);
      Serial.print("-");
      Serial.print(leds[i].g);
      Serial.print("-");
      Serial.print(leds[i].b);
      Serial.print("|");      
      Serial.print(ledsX[i][0]);
      Serial.print("-");
      Serial.print(ledsX[i][1]);
      Serial.print("-");
      Serial.println(ledsX[i][2]);
    }  
}

//------------------------LED EFFECT FUNCTIONS------------------------

void one_color_all(int cred, int cgrn, int cblu) { //-SET ALL LEDS TO ONE COLOR
    for(int i = 0 ; i < NUM_LEDS; i++ ) {
      set_color_led(i, cred, cgrn, cblu);
      FastSPI_LED.show();
      delay(1);
    }  
}

void one_color_allNOSHOW(int cred, int cgrn, int cblu) { //-SET ALL LEDS TO ONE COLOR
    for(int i = 0 ; i < NUM_LEDS; i++ ) {
      set_color_led(i, cred, cgrn, cblu);
      //FastSPI_LED.show();
      //delay(1);
    }  
}


void rainbow_fade(int idelay) { //-FADE ALL LEDS THROUGH HSV RAINBOW
    ihue++;
    if (ihue >= 359) {ihue = 0;}
    int thisColor[3];
    HSVtoRGB(ihue, 255, 255, thisColor);
    for(int idex = 0 ; idex < NUM_LEDS; idex++ ) {
      set_color_led(idex,thisColor[0],thisColor[1],thisColor[2]);
    }
    FastSPI_LED.show();    
    delay(idelay);
}


void rainbow_loop(int istep, int idelay) { //-LOOP HSV RAINBOW
  idex++;
  ihue = ihue + istep;
  int icolor[3];  

  if (idex >= NUM_LEDS) {idex = 0;}
  if (ihue >= 359) {ihue = 0;}

  HSVtoRGB(ihue, 255, 255, icolor);
  set_color_led(idex, icolor[0], icolor[1], icolor[2]);
  FastSPI_LED.show();
  delay(idelay);
}


void random_burst(int idelay) { //-RANDOM INDEX/COLOR
  int icolor[3];  
  
  idex = random(0,NUM_LEDS);
  ihue = random(0,359);

  HSVtoRGB(ihue, 255, 255, icolor);
  set_color_led(idex, icolor[0], icolor[1], icolor[2]);
  FastSPI_LED.show();
  delay(idelay);
}


void color_bounce(int idelay) { //-BOUNCE COLOR (SINGLE LED)
  if (bouncedirection == 0) {
    idex = idex + 1;
    if (idex == NUM_LEDS) {
      bouncedirection = 1;
      idex = idex - 1;
    }
  }
  if (bouncedirection == 1) {
    idex = idex - 1;
    if (idex == 0) {
      bouncedirection = 0;
    }
  }  
  for(int i = 0; i < NUM_LEDS; i++ ) {
    if (i == idex) {set_color_led(i, 255, 0, 0);}
    else {set_color_led(i, 0, 0, 0);}
  }
  FastSPI_LED.show();  
  delay(idelay);
}


void police_lightsONE(int idelay) { //-POLICE LIGHTS (TWO COLOR SINGLE LED)
  idex++;
  if (idex >= NUM_LEDS) {idex = 0;}
  int idexR = idex;
  int idexB = antipodal_index(idexR);  
  for(int i = 0; i < NUM_LEDS; i++ ) {
    if (i == idexR) {set_color_led(i, 255, 0, 0);}
    else if (i == idexB) {set_color_led(i, 0, 0, 255);}    
    else {set_color_led(i, 0, 0, 0);}
  }
  FastSPI_LED.show();  
  delay(idelay);
}


void police_lightsALL(int idelay) { //-POLICE LIGHTS (TWO COLOR SOLID)
  idex++;
  if (idex >= NUM_LEDS) {idex = 0;}
  int idexR = idex;
  int idexB = antipodal_index(idexR);
  set_color_led(idexR, 255, 0, 0);
  set_color_led(idexB, 0, 0, 255);
  FastSPI_LED.show();  
  delay(idelay);
}


void color_bounceFADE(int idelay) { //-BOUNCE COLOR (SIMPLE MULTI-LED FADE)
  if (bouncedirection == 0) {
    idex = idex + 1;
    if (idex == NUM_LEDS) {
      bouncedirection = 1;
      idex = idex - 1;
    }
  }
  if (bouncedirection == 1) {
    idex = idex - 1;
    if (idex == 0) {
      bouncedirection = 0;
    }
  }
  int iL1 = adjacent_cw(idex);
  int iL2 = adjacent_cw(iL1);
  int iL3 = adjacent_cw(iL2);  
  int iR1 = adjacent_ccw(idex);
  int iR2 = adjacent_ccw(iR1);
  int iR3 = adjacent_ccw(iR2);
  
  for(int i = 0; i < NUM_LEDS; i++ ) {
    if (i == idex) {set_color_led(i, 255, 0, 0);}
    else if (i == iL1) {set_color_led(i, 100, 0, 0);}
    else if (i == iL2) {set_color_led(i, 50, 0, 0);}
    else if (i == iL3) {set_color_led(i, 10, 0, 0);}        
    else if (i == iR1) {set_color_led(i, 100, 0, 0);}
    else if (i == iR2) {set_color_led(i, 50, 0, 0);}
    else if (i == iR3) {set_color_led(i, 10, 0, 0);}    
    else {set_color_led(i, 0, 0, 0);}
  }

  FastSPI_LED.show();  
  delay(idelay);
}


void flicker(int thishue, int thissat) {
  int random_bright = random(0,255);
  int random_delay = random(10,100);
  int random_bool = random(0,random_bright);
  int thisColor[3];
  
  if (random_bool < 10) {
    HSVtoRGB(thishue, thissat, random_bright, thisColor);

    for(int i = 0 ; i < NUM_LEDS; i++ ) {
      set_color_led(i, thisColor[0], thisColor[1], thisColor[2]);
    }
    
    FastSPI_LED.show();  
    delay(random_delay);
  }
}


void pulse_one_color_all(int ahue, int idelay) { //-PULSE BRIGHTNESS ON ALL LEDS TO ONE COLOR

  if (bouncedirection == 0) {
    ibright++;
    if (ibright >= 255) {bouncedirection = 1;}
  }
  if (bouncedirection == 1) {
    ibright = ibright - 1;
    if (ibright <= 1) {bouncedirection = 0;}        
  }  
    
  int acolor[3];
  HSVtoRGB(ahue, 255, ibright, acolor);
  
    for(int i = 0 ; i < NUM_LEDS; i++ ) {
      set_color_led(i, acolor[0], acolor[1], acolor[2]);
    }
    FastSPI_LED.show();
    delay(idelay);
}


void pulse_one_color_all_rev(int ahue, int idelay) { //-PULSE SATURATION ON ALL LEDS TO ONE COLOR

  if (bouncedirection == 0) {
    isat++;
    if (isat >= 255) {bouncedirection = 1;}
  }
  if (bouncedirection == 1) {
    isat = isat - 1;
    if (isat <= 1) {bouncedirection = 0;}        
  }  
    
  int acolor[3];
  HSVtoRGB(ahue, isat, 255, acolor);
  
    for(int i = 0 ; i < NUM_LEDS; i++ ) {
      set_color_led(i, acolor[0], acolor[1], acolor[2]);
    }
    FastSPI_LED.show();
    delay(idelay);
}


void random_red() { //QUICK 'N DIRTY RANDOMIZE TO GET CELL AUTOMATA STARTED  
  int temprand;
  for(int i = 0; i < NUM_LEDS; i++ ) {
    temprand = random(0,100);
    if (temprand > 50) {leds[i].r = 255;}
    if (temprand <= 50) {leds[i].r = 0;}
    leds[i].b = 0; leds[i].g = 0;
  }
  FastSPI_LED.show();
}


void rule30(int idelay) { //1D CELLULAR AUTOMATA - RULE 30 (RED FOR NOW)
  copy_led_array();
  int iCW;
  int iCCW;
  int y = 100;  
  for(int i = 0; i < NUM_LEDS; i++ ) {
    iCW = adjacent_cw(i);
    iCCW = adjacent_ccw(i);
    if (ledsX[iCCW][0] > y && ledsX[i][0] > y && ledsX[iCW][0] > y) {leds[i].r = 0;}
    if (ledsX[iCCW][0] > y && ledsX[i][0] > y && ledsX[iCW][0] <= y) {leds[i].r = 0;}
    if (ledsX[iCCW][0] > y && ledsX[i][0] <= y && ledsX[iCW][0] > y) {leds[i].r = 0;}
    if (ledsX[iCCW][0] > y && ledsX[i][0] <= y && ledsX[iCW][0] <= y) {leds[i].r = 255;}
    if (ledsX[iCCW][0] <= y && ledsX[i][0] > y && ledsX[iCW][0] > y) {leds[i].r = 255;}
    if (ledsX[iCCW][0] <= y && ledsX[i][0] > y && ledsX[iCW][0] <= y) {leds[i].r = 255;}
    if (ledsX[iCCW][0] <= y && ledsX[i][0] <= y && ledsX[iCW][0] > y) {leds[i].r = 255;}
    if (ledsX[iCCW][0] <= y && ledsX[i][0] <= y && ledsX[iCW][0] <= y) {leds[i].r = 0;}
  }
  
  FastSPI_LED.show();
  delay(idelay);
}


void random_march(int idelay) { //RANDOM MARCH CCW
  copy_led_array();
  int iCCW;
  
  int acolor[3];
  HSVtoRGB(random(0,360), 255, 255, acolor);
  
  leds[0].r = acolor[0];
  leds[0].g = acolor[1];
  leds[0].b = acolor[2];
  
  for(int i = 1; i < NUM_LEDS ; i++ ) {  //-GET/SET EACH LED COLOR FROM CCW LED
    iCCW = adjacent_ccw(i);
    leds[i].r = ledsX[iCCW][0];
    leds[i].g = ledsX[iCCW][1];
    leds[i].b = ledsX[iCCW][2];    
  }
  
  FastSPI_LED.show();
  delay(idelay);
}


void rwb_march(int idelay) { //R,W,B MARCH CCW
  copy_led_array();
  int iCCW;
  
  idex++;
  if (idex > 2) {idex = 0;}
  
  switch (idex) {
    case 0:
      leds[0].r = 255;
      leds[0].g = 0;
      leds[0].b = 0;
    break;
    case 1:
      leds[0].r = 255;
      leds[0].g = 255;
      leds[0].b = 255;
    break;
    case 2:
      leds[0].r = 0;
      leds[0].g = 0;
      leds[0].b = 255;
    break;
  }
      
    for(int i = 1; i < NUM_LEDS; i++ ) {  //-GET/SET EACH LED COLOR FROM CCW LED
      iCCW = adjacent_ccw(i);
      leds[i].r = ledsX[iCCW][0];
      leds[i].g = ledsX[iCCW][1];
      leds[i].b = ledsX[iCCW][2];    
    }
  
  FastSPI_LED.show();
  delay(idelay);
}


void white_temps() {
  int N9 = int(NUM_LEDS/9);
  for (int i = 0; i < NUM_LEDS; i++ ) {
    if (i >= 0 && i < N9) {leds[i].r = 255; leds[i].g = 147; leds[i].b = 41;} //-CANDLE - 1900
    if (i >= N9 && i < N9*2) {leds[i].r = 255; leds[i].g = 197; leds[i].b = 143;} //-40W TUNG - 2600
    if (i >= N9*2 && i < N9*3) {leds[i].r = 255; leds[i].g = 214; leds[i].b = 170;} //-100W TUNG - 2850
    if (i >= N9*3 && i < N9*4) {leds[i].r = 255; leds[i].g = 241; leds[i].b = 224;} //-HALOGEN - 3200
    if (i >= N9*4 && i < N9*5) {leds[i].r = 255; leds[i].g = 250; leds[i].b = 244;} //-CARBON ARC - 5200
    if (i >= N9*5 && i < N9*6) {leds[i].r = 255; leds[i].g = 255; leds[i].b = 251;} //-HIGH NOON SUN - 5400
    if (i >= N9*6 && i < N9*7) {leds[i].r = 255; leds[i].g = 255; leds[i].b = 255;} //-DIRECT SUN - 6000
    if (i >= N9*7 && i < N9*8) {leds[i].r = 201; leds[i].g = 226; leds[i].b = 255;} //-OVERCAST SKY - 7000
    if (i >= N9*8 && i < NUM_LEDS) {leds[i].r = 64; leds[i].g = 156; leds[i].b = 255;} //-CLEAR BLUE SKY - 20000  
  }
  FastSPI_LED.show();
  delay(100);
}


void color_loop_vardelay() { //-COLOR LOOP (SINGLE LED) w/ VARIABLE DELAY
  idex++;
  if (idex > NUM_LEDS) {idex = 0;}

  int acolor[3];
  HSVtoRGB(0, 255, 255, acolor);
  
  int di = abs(TOP_INDEX - idex); //-DISTANCE TO CENTER    
  int t = constrain((10/di)*10, 10, 500); //-DELAY INCREASE AS INDEX APPROACHES CENTER (WITHIN LIMITS)
  
  for(int i = 0; i < NUM_LEDS; i++ ) {
    if (i == idex) {
      leds[i].r = acolor[0]; leds[i].g = acolor[1]; leds[i].b = acolor[2];
    }
    else {
      leds[i].r = 0; leds[i].g = 0; leds[i].b = 0;
    }
  }
  
  FastSPI_LED.show();
  delay(t);
}

  
void strip_march_cw(int idelay) { //-MARCH STRIP C-W
  copy_led_array();
  int iCCW;  
  for(int i = 0; i < NUM_LEDS; i++ ) {  //-GET/SET EACH LED COLOR FROM CCW LED
    iCCW = adjacent_ccw(i);
    leds[i].r = ledsX[iCCW][0];
    leds[i].g = ledsX[iCCW][1];
    leds[i].b = ledsX[iCCW][2];    
  }
  FastSPI_LED.show();
  delay(idelay);
}


void strip_march_ccw(int idelay) { //-MARCH STRIP C-W
  copy_led_array();
  int iCW;  
  for(int i = 0; i < NUM_LEDS; i++ ) {  //-GET/SET EACH LED COLOR FROM CCW LED
    iCW = adjacent_cw(i);
    leds[i].r = ledsX[iCW][0];
    leds[i].g = ledsX[iCW][1];
    leds[i].b = ledsX[iCW][2];    
  }
  FastSPI_LED.show();
  delay(idelay);
}


void pop_horizontal(int ahue, int idelay) {  //-POP FROM LEFT TO RIGHT UP THE RING
  int acolor[3];
  HSVtoRGB(ahue, 255, 255, acolor);
  
  int ix;
  
  if (bouncedirection == 0) {
    bouncedirection = 1;
    ix = idex;  
  }
  else if (bouncedirection == 1) {
    bouncedirection = 0;
    ix = horizontal_index(idex);
    idex++;
    if (idex > TOP_INDEX) {idex = 0;}      
  }
  
  for(int i = 0; i < NUM_LEDS; i++ ) {
    if (i == ix) {leds[i].r = acolor[0]; leds[i].g = acolor[1]; leds[i].b = acolor[2];}
    else {leds[i].r = 0; leds[i].g = 0; leds[i].b = 0;}
  }
  
  FastSPI_LED.show();
  delay(idelay);    
}


void quad_bright_curve(int ahue, int idelay) {  //-QUADRATIC BRIGHTNESS CURVER
  int acolor[3];
  int ax;
    
  for(int x = 0; x < NUM_LEDS; x++ ) {
    if (x <= TOP_INDEX) {ax = x;}
    else if (x > TOP_INDEX) {ax = NUM_LEDS-x;}

    int a = 1; int b = 1; int c = 0;
        
    int iquad = -(ax*ax*a)+(ax*b)+c; //-ax2+bx+c
    int hquad = -(TOP_INDEX*TOP_INDEX*a)+(TOP_INDEX*b)+c; //HIGHEST BRIGHTNESS
    
    ibright = int((float(iquad)/float(hquad))*255);
      
    HSVtoRGB(ahue, 255, ibright, acolor);
  
    leds[x].r = acolor[0]; leds[x].g = acolor[1]; leds[x].b = acolor[2];

  
  }
  FastSPI_LED.show();
  delay(idelay);
}


void flame() {
  int acolor[3];
  int idelay = random(0,35);
  
  float hmin = 0.1; float hmax = 45.0;
  float hdif = hmax-hmin;
  int randtemp = random(0,3);
  float hinc = (hdif/float(TOP_INDEX))+randtemp;

  int ahue = hmin;
  for(int i = 0; i < TOP_INDEX; i++ ) {
    
    ahue = ahue + hinc;

    HSVtoRGB(ahue, 255, 255, acolor);
    
    leds[i].r = acolor[0]; leds[i].g = acolor[1]; leds[i].b = acolor[2];
    int ih = horizontal_index(i);
    leds[ih].r = acolor[0]; leds[ih].g = acolor[1]; leds[ih].b = acolor[2];
    
    leds[TOP_INDEX].r = 255; leds[TOP_INDEX].g = 255; leds[TOP_INDEX].b = 255;
  
    FastSPI_LED.show();
    delay(idelay);
  }
}


void radiation(int ahue, int idelay) { //-SORT OF RADIATION SYMBOLISH-
  //int N2 = int(NUM_LEDS/2);
  int N3 = int(NUM_LEDS/3);
  int N6 = int(NUM_LEDS/6);  
  int N12 = int(NUM_LEDS/12);  
  int acolor[3];

  for(int i = 0; i < N6; i++ ) { //-HACKY, I KNOW...
    tcount = tcount + .02;
    if (tcount > 3.14) {tcount = 0.0;}
    ibright = int(sin(tcount)*255);
    
    int j0 = (i + NUM_LEDS - N12) % NUM_LEDS;
    int j1 = (j0+N3) % NUM_LEDS;
    int j2 = (j1+N3) % NUM_LEDS;    
    HSVtoRGB(ahue, 255, ibright, acolor);  
    leds[j0].r = acolor[0]; leds[j0].g = acolor[1]; leds[j0].b = acolor[2];
    leds[j1].r = acolor[0]; leds[j1].g = acolor[1]; leds[j1].b = acolor[2];
    leds[j2].r = acolor[0]; leds[j2].g = acolor[1]; leds[j2].b = acolor[2];    

  }    
    FastSPI_LED.show();
    delay(idelay);    
}


void sin_bright_wave(int ahue, int idelay) {  
  int acolor[3];
    
  for(int i = 0; i < NUM_LEDS; i++ ) {
    tcount = tcount + .1;
    if (tcount > 3.14) {tcount = 0.0;}
    ibright = int(sin(tcount)*255);
  
    HSVtoRGB(ahue, 255, ibright, acolor);
  
    leds[i].r = acolor[0]; leds[i].g = acolor[1]; leds[i].b = acolor[2];
    
    FastSPI_LED.show();
    delay(idelay);
  }
}


void fade_vertical(int ahue, int idelay) { //-FADE 'UP' THE LOOP
  idex++;
  if (idex > TOP_INDEX) {idex = 0;}  
  int idexA = idex;
  int idexB = horizontal_index(idexA);
  
  ibright = ibright + 10;
  if (ibright > 255) {ibright = 0;}
  int acolor[3];
  HSVtoRGB(ahue, 255, ibright, acolor);
  
  set_color_led(idexA, acolor[0], acolor[1], acolor[2]);  
  set_color_led(idexB, acolor[0], acolor[1], acolor[2]);  

  FastSPI_LED.show();
  delay(idelay);
}


void rainbow_vertical(int istep, int idelay) { //-RAINBOW 'UP' THE LOOP
  idex++;
  if (idex > TOP_INDEX) {idex = 0;}  
  ihue = ihue + istep;
  if (ihue > 359) {ihue = 0;}
  Serial.println(ihue);  
  int idexA = idex;
  int idexB = horizontal_index(idexA);

  int acolor[3];
  HSVtoRGB(ihue, 255, 255, acolor);

  set_color_led(idexA, acolor[0], acolor[1], acolor[2]);  
  set_color_led(idexB, acolor[0], acolor[1], acolor[2]);  

  FastSPI_LED.show();
  delay(idelay);
}


void pacman(int idelay) { //-MARCH STRIP C-W
  int s = int(NUM_LEDS/4);
  lcount++;
  if (lcount > 5) {lcount = 0;}
  if (lcount == 0) {
    one_color_allNOSHOW(255,255,0);}
  if (lcount == 1 || lcount == 5) {
      one_color_allNOSHOW(255,255,0);
      leds[s].r = 0; leds[s].g = 0; leds[s].b = 0;}
  if (lcount == 2 || lcount == 4) {
      one_color_allNOSHOW(255,255,0);
      leds[s-1].r = 0; leds[s-1].g = 0; leds[s-1].b = 0;  
      leds[s].r = 0; leds[s].g = 0; leds[s].b = 0;
      leds[s+1].r = 0; leds[s+1].g = 0; leds[s+1].b = 0;}        
  if (lcount == 3) {
      one_color_allNOSHOW(255,255,0);
      leds[s-2].r = 0; leds[s-2].g = 0; leds[s-2].b = 0;  
      leds[s-1].r = 0; leds[s-1].g = 0; leds[s-1].b = 0;  
      leds[s].r = 0; leds[s].g = 0; leds[s].b = 0;
      leds[s+1].r = 0; leds[s+1].g = 0; leds[s+1].b = 0;
      leds[s+2].r = 0; leds[s+2].g = 0; leds[s+2].b = 0;}
  
  FastSPI_LED.show();
  delay(idelay);
}


//------------------SETUP------------------
void setup()  
{


  Serial.begin(9600);      // SETUP HARDWARE SERIAL (USB)
  //Serial.begin(115200);      // SETUP HARDWARE SERIAL (USB)
  
  FastSPI_LED.setLeds(NUM_LEDS);
  //FastSPI_LED.setChipset(CFastSPI_LED::SPI_WS2801);
  FastSPI_LED.setChipset(CFastSPI_LED::SPI_TM1809);
  
  FastSPI_LED.setPin(PIN);
  FastSPI_LED.setDataRate(7);      //-IF LEDS FLICKER, PLAY WITH THIS (0-7)
  
  FastSPI_LED.init();
  FastSPI_LED.start();

  leds = (struct CRGB*)FastSPI_LED.getRGBData();
  
  sCmd.addCommand("m",   set_mode_strip);
  sCmd.setDefaultHandler(unrecognized);      // Handler for command that isn't matched  (says "What?")
  
  one_color_all(0,0,0); //-BLANK STRIP
  
  FastSPI_LED.show();
  Serial.println("---SETUP COMPLETE---");
}



void set_mode_strip() {    //-SETS THE MODE (SOME MODES REQUIRE RANDOM STARTS TO WORK RIGHT
  char *arg;
  arg = sCmd.next();
  
  if (arg != NULL) {
    ledMode = atoi(arg);
  }
  if (ledMode == 13) {  //-FOR CELL AUTO
    random_red();
  }
  
  Serial.print("~~~***NEW MODE-");
  Serial.println(ledMode);
}

void demo_mode(){
  int r = 10;
  for(int i=0; i<r*3; i++) {one_color_all(255,255,255);}
  for(int i=0; i<r*25; i++) {rainbow_fade(20);}
  for(int i=0; i<r*20; i++) {rainbow_loop(10, 20);}
  for(int i=0; i<r*20; i++) {random_burst(20);}
  for(int i=0; i<r*12; i++) {color_bounce(20);}
  for(int i=0; i<r*12; i++) {color_bounceFADE(40);}
  for(int i=0; i<r*5; i++) {police_lightsONE(40);}
  for(int i=0; i<r*5; i++) {police_lightsALL(40);}
  for(int i=0; i<r*35; i++) {flicker(200, 255);}
  for(int i=0; i<r*50; i++) {pulse_one_color_all(0, 10);}
  for(int i=0; i<r*35; i++) {pulse_one_color_all_rev(0, 10);}
  for(int i=0; i<r*5; i++) {fade_vertical(240, 60);}
  random_red();
  for(int i=0; i<r*5; i++) {rule30(100);}
  for(int i=0; i<r*8; i++) {random_march(30);}
  for(int i=0; i<r*5; i++) {rwb_march(80);}
  one_color_all(0,0,0);
  for(int i=0; i<r*15; i++) {radiation(120, 60);}
  for(int i=0; i<r*15; i++) {color_loop_vardelay();}
  for(int i=0; i<r*5; i++) {white_temps();}
  for(int i=0; i<r; i++) {sin_bright_wave(240, 35);}
  for(int i=0; i<r*5; i++) {pop_horizontal(300, 100);}
  for(int i=0; i<r*5; i++) {quad_bright_curve(240, 100);}
  for(int i=0; i<r*3; i++) {flame();}
  for(int i=0; i<r*10; i++) {pacman(50);}
  for(int i=0; i<r*15; i++) {rainbow_vertical(15, 50);}

  for(int i=0; i<r*3; i++) {strip_march_ccw(100);}
  for(int i=0; i<r*3; i++) {strip_march_cw(100);}
  for(int i=0; i<r*2; i++) {one_color_all(255,0,0);}
  for(int i=0; i<r*2; i++) {one_color_all(0,255,0);}
  for(int i=0; i<r*2; i++) {one_color_all(0,0,255);}
  for(int i=0; i<r*2; i++) {one_color_all(255,255,0);}
  for(int i=0; i<r*2; i++) {one_color_all(0,255,255);}
  for(int i=0; i<r*2; i++) {one_color_all(255,0,255);}
}




//------------------MAIN LOOP------------------
void loop() {
  
  // sCmd.readSerial();     //-PROCESS SERIAL COMMANDS

while (Serial.available() > 0) {
     ledMode = Serial.parseInt();
     }
 

  if (ledMode == 0) {one_color_all(0,0,0);}            //---STRIP OFF - "0"
  if (ledMode == 1) {one_color_all(255,255,255);}      //---STRIP SOLID WHITE
  if (ledMode == 2) {rainbow_fade(20);}                //---STRIP RAINBOW FADE
  if (ledMode == 3) {rainbow_loop(10, 20);}            //---RAINBOW LOOP
  if (ledMode == 4) {random_burst(20);}                //---RANDOM
  if (ledMode == 5) {color_bounce(20);}                //---CYLON v1
  if (ledMode == 6) {color_bounceFADE(20);}            //---CYLON v2
  if (ledMode == 7) {police_lightsONE(40);}            //---POLICE SINGLE
  if (ledMode == 8) {police_lightsALL(40);}            //---POLICE SOLID
  if (ledMode == 9) {flicker(200,255);}                //---STRIP FLICKER
  if (ledMode == 10) {pulse_one_color_all(0, 10);}     //--- PULSE COLOR BRIGHTNESS
  if (ledMode == 11) {pulse_one_color_all_rev(0, 10);} //--- PULSE COLOR SATURATION  
  if (ledMode == 12) {fade_vertical(240, 60);}         //--- VERTICAL SOMETHING
  if (ledMode == 13) {rule30(100);}                    //--- CELL AUTO - RULE 30 (RED)
  if (ledMode == 14) {random_march(30);}               //--- MARCH RANDOM COLORS
  if (ledMode == 15) {rwb_march(50);}                  //--- MARCH RWB COLORS
  if (ledMode == 16) {radiation(120, 60);}             //--- RADIATION SYMBOL (OR SOME APPROXIMATION)
  if (ledMode == 17) {color_loop_vardelay();}          //--- VARIABLE DELAY LOOP
  if (ledMode == 18) {white_temps();}                  //--- WHITE TEMPERATURES
  if (ledMode == 19) {sin_bright_wave(240, 35);}       //--- SIN WAVE BRIGHTNESS
  if (ledMode == 20) {pop_horizontal(300, 100);}       //--- POP LEFT/RIGHT
  if (ledMode == 21) {quad_bright_curve(240, 100);}    //--- QUADRATIC BRIGHTNESS CURVE  
  if (ledMode == 22) {flame();}                        //--- FLAME-ISH EFFECT
  if (ledMode == 23) {rainbow_vertical(10, 20);}       //--- VERITCAL RAINBOW
  if (ledMode == 24) {pacman(100);}                     //--- PACMAN

  if (ledMode == 98) {strip_march_ccw(100);}           //--- MARCH WHATEVERS ON THE STRIP NOW CC-W
  if (ledMode == 99) {strip_march_cw(100);}            //--- MARCH WHATEVERS ON THE STRIP NOW C-W

  if (ledMode == 101) {one_color_all(255,0,0);}    //---101- STRIP SOLID RED
  if (ledMode == 102) {one_color_all(0,255,0);}    //---102- STRIP SOLID GREEN
  if (ledMode == 103) {one_color_all(0,0,255);}    //---103- STRIP SOLID BLUE
  if (ledMode == 104) {one_color_all(255,255,0);}  //---104- STRIP SOLID YELLOW
  if (ledMode == 105) {one_color_all(0,255,255);}  //---105- STRIP SOLID TEAL?
  if (ledMode == 106) {one_color_all(255,0,255);}  //---106- STRIP SOLID VIOLET?
  
  if (ledMode == 888) {demo_mode();}              

}


// GETS CALLED BY SERIALCOMMAND WHEN NO MATCHING COMMAND
void unrecognized(const char *command) {
  Serial.println("nothin fo ya...");
}




LED-Streifen mit frei adressierbaren RGB-LEDs.   
http://www.ebay.com/sch/sis.html?_nkw=1m+60+LED+m+RGB+LED+Light+Strip+5V+WS2811+WS2801+Waterproof+Addressable+Color&_itemId=160907739909&_trksid=p2047675.m4099

http://www.arduinoforum.de/arduino-Thread-Adressierbare-Led-Strips-mit-Arduino




*********************************************************

LED-Studien
proffessionelle LED-Beleuchtung

LEDs sind  bis zu 10 x heller als Glühlampen

LED-Studien ist Ihr Partner für alle Fachfragen zur LED-Beleuchtung. Kompetent, professionell, anspruchsvoll.
Wir beraten. Wir entwickeln Sonderlösungen für spezielle Kundenanforderungen.
Wir bieten hochwertige LED-Komponenten sowie Eigenentwicklungen in unserem Onlineshop.


Große Installation (über 5m LED-Streifen) ohne Dimmer

LED-Installation über 10m

Alle 5m Streifenlänge muss eine neue Einspeisung an den LED-Streifen gelegt werden.

Die Leiterbahnen auf den Streifen erhalten sonst eine zu hohe Strombelastung.

Bei einem bis zu 10m langen Streifen können Sie auch genau in der Mitte die Kabel anlöten und haben so in beide Richtungen die 5m-Grenze beachtet.

Wählen Sie Kabel, die für die höhere Stromstärke ausgelegt sind.

Ansonsten halten Sie sich an die Angaben der einfachen LED-Installation (siehe oben).


http://www.led-studien.de/2015/08/30/installationshilfe/
http://www.led-studien.de/






*********************************************************

NeoPixel Ring mit 16 RGB Led´s   

physicalcomputing.at   Artikel-Nr.: A-10650



NeoPixel-Ring mit 16 RGB LEDs

Beschreibung:
Bei diesem NeoPixel Ring sind 16ultrahelle LED-Smart NeoPixels in einem Kreis mit einem Außendurchmesser von 44,5mm angeordnet.

Die LEDs sind so verbunden, dass sie mit nur einem Pin eines Mikrocontrollers gesteuert werden können.

Dabei ist jede LED einzeln programmierbar.

Jede LED zieht sehr konstant 18mA, so dass die Farben sehr konstant leuchten, auch wenn die Spannung schwankt.

Es sind keine externen Widerstände erforderlich. Versorgen Sie den NeoPixel Ring mit 5 V und es kann los gehen.

Es gibt eine einzige Datenleitung mit einem spezifischen Timing Protokoll.

Da das Timing Protokoll sehr empfindlich ist, erfordert es einen Echtzeit Microcontroller wie AVR, Arduino, PIC, mbed...
Mit Linux-basierten Mikrocomputern oder Mikrocontroller wie Netduino kann er nicht verwendet werden.

Die von Adafruit geschriebene Neopixel Bibliothek für Arduino unterstützt diesen NeoPixel-Ring.
Der Ring wird mit 16 einzeln ansteuerbaren LEDs, fertig montiert und getestet ausgeliefert.

(Anschlusskabel sind nicht im Lieferumfang enthalten)

Details:

  • Außendurchmesser: 44,5 mm
  • Innendurchmesser: 31,75 mm
  • Dicke: 2,5 mm
  • Gewicht: 3,03 g
  • WS2812B 4-Pin-Chip LED integriert 

Links:

Datenblatt (WS2812)
http://physicalcomputing.at/WebRoot/Store2/Shops/f46ab952-295a-4f65-8ffa-38a4b8eec267/MediaGallery/Datenblaetter/Datenblatt_10662.pdf

Neopixel Library
https://github.com/adafruit/Adafruit_NeoPixel

Anleitungen bei Adafruit
https://learn.adafruit.com/adafruit-neopixel-uberguide

NeoPixel 1/4Ring mit 15 RGB LEDs

physicalcomputing.at   Artikel-Nr.: A-10661



http://physicalcomputing.at/NeoPixel-Ring-16-x-WS2812-5050-RGB-LED-mit-integriertem-Treiber



Beschreibung von RPB-LEDs

Flußspannung

Infrarot 1,2V
Rot 1,8V
Gelb 2,0V
Grün 2,2V
Grün
(Ultrahell)
3,3V
Blau 3,6V
Weiß 3,6V
Ultraviolett 4.0V

DurchlassStrom

Da LEDs durch einen zu hohen Strom zerstört werden, muss der Strom begrenzt werden.
Der Maximalstrom einer LED ist bei allen Typen sehr ähnlich und liegt bei 20..30mA.
Eine Standard-LED wird üblicherweise mit 20mA betrieben.
Moderne LEDs kommen häufig mit sehr viel weniger Strom aus.
So benötigt eine low-current LED nur 2mA um sehr hell zu leuchten.
In der Praxis werden LEDs oft mit einem weit geringeren als dem maximal zulässigen Durchlassstrom betrieben.
Insbesondere im Entwicklungs- und Experimentierumfeld kann eine für maximal 20mA ausgelegte LED auch mit lediglich 3..5mA betrieben werden.


https://www.mikrocontroller.net/articles/LED






DIN A4 ausdrucken
*********************************************************

Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:schaltungen@schaltungen.at
ENDE








Untergeordnete Seiten (2): in BÜCHER RGB-LED Guide
Comments