Re: 16 LED Ringlicht

Sehr cool!

ein kurzes Video würde den Code noch verständlicher machen.

Gruß

Sebastian

Hallo Megaionstorm,

was kann man sich unter einem "16 LED Singlecolor Ringlicht" vorstellen?

Gruß

@Megaionstorm: Was genau soll die Funktion "Drehen()" machen...?

Damit wäre dann folgendes machbar: Equinox Clock - YouTube

Und noch viel mehr ...

@r.Merk:
Ringlicht bedeutet das die Leds so angeordnet sind das sie einen Ring ergeben.

Wenn ich mir zwei neue 9V 1,2A Netzteile gekauft habe werde ich dieses Projekt auf 32 singlecolor Leds erweitern und ein weiteres Ringlicht mit 16 RGB Leds entwerfen und programmieren.

Als Anwendunngsmöglichkeiten könnte ich mir den Einsatz im Partykeller oder als Weihnachtsbeleuchtung vorstellen.

Zur Zeit ist das ganze noch eine Breadboardschaltung. In der Endversion werden alle Bauteile, Atmega328, TLC5940 und die Leds auf eine Platine gebracht. Also etwas wie ein Ringlicht Arduino. Mit einem Anschluss für ein Arduino USB zu Seriell Adapter.
http://www.watterott.com/de/Arduino-USB-Serial-Adapter

Damit das Ringlicht wie ein Arduino mit der Arduino IDE programmiert und aktualisiert werden kann.

Zur Zeit arbeite in an einem 16 LED singlecolor Ringlicht.

Unter Benutzung der TLC5940 Bibliothek.
http://code.google.com/p/tlc5940arduino/downloads/list

Interessierten möchte ich hiermit die aktuellste Version des Codes zur Verfügung stellen.

#include "Tlc5940.h"

char* PatternFrame[] = { "0000000000000000",
                         "0f0f0f0f0f0f0f0f",
                         "f0f0f0f0f0f0f0f0",
                         "000000f00000000f"
};
char* Frame;
int Light1[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int Light2[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
byte Zaehler;

void setup()
{
   Tlc.init();
   Tlc.clear();
   Tlc.update();
}

void loop() // Hier kommt deine Lichtchoreographie hin !!!
{
   PatternFading(Light1, PatternFrame[1], 25);
   delay(1000);
   PatternFading(Light1, PatternFrame[2], 25);
   delay(1000);
   for (Zaehler = 0; Zaehler <= 25; Zaehler += 1)
   {
     SetPattern(Light1, PatternFrame[1]);
     delay(150);
     SetPattern(Light1, PatternFrame[2]);
     delay(150);
   }   
   PatternFading(Light1, PatternFrame[3], 25);
   delay(1000);
   Drehen(Light1, 50, 0, 150);
   Drehen(Light1, 50, 1, 150);
   delay(1000);
   DeclareParam(0,1000,2250,4095,4095,2250,1000,0,0,1000,2250,4095,4095,2250,1000,0);
   ParamFading(Light1, Light2, 25);
   delay(1000);
   DeclareParam(4095,2250,1000,0,0,1000,2250,4095,4095,2250,1000,0,0,1000,2250,4095);
   ParamFading(Light1, Light2, 25);
   delay(1000);
   for (Zaehler = 0; Zaehler <= 25; Zaehler += 1)
   {
     DeclareParam(0,1000,2250,4095,4095,2250,1000,0,0,1000,2250,4095,4095,2250,1000,0);
     SetParam(Light1, Light2);
     delay(150);
     DeclareParam(4095,2250,1000,0,0,1000,2250,4095,4095,2250,1000,0,0,1000,2250,4095);
     SetParam(Light1, Light2);
     delay(150);
   }
}

void DeclareParam(int Param1, int Param2, int Param3, int Param4, int Param5, int Param6, int Param7, int Param8, int Param9, int Param10, int Param11, int Param12, int Param13, int Param14, int Param15, int Param16)
{
  Light2[0] = Param1;
  Light2[1] = Param2;
  Light2[2] = Param3;
  Light2[3] = Param4;
  Light2[4] = Param5;
  Light2[5] = Param6;
  Light2[6] = Param7;
  Light2[7] = Param8;
  Light2[8] = Param9;
  Light2[9] = Param10;
  Light2[10] = Param11;
  Light2[11] = Param12;
  Light2[12] = Param13;
  Light2[13] = Param14;
  Light2[14] = Param15;
  Light2[15] = Param16;
}

void SetParam(int LightOld[16], int LightNew[16])
{
  float Fade[16];
  int Helligkeit[16];
  for (int LightNr = 0; LightNr <= 15; LightNr += 1)
  {
    Helligkeit[LightNr] = LightNew[LightNr];
    if (Helligkeit[LightNr] < 0) Helligkeit[LightNr] = 0;
    if (Helligkeit[LightNr] > 4095) Helligkeit[LightNr] = 4095;
  }
  for (int Channel = 0; Channel <= 15; Channel += 1)
  {
    Tlc.set(Channel, Helligkeit[Channel]);
    Light1[Channel] = Helligkeit[Channel];
  }
  Tlc.update();
}

void ParamFading(int LightOld[16], int LightNew[16], int Geschw)
{
  float Fade[16];
  int Helligkeit[16];
  for (int LightNr = 0; LightNr <= 15; LightNr += 1)
  {
    Helligkeit[LightNr] = LightNew[LightNr];
    if (Helligkeit[LightNr] < 0) Helligkeit[LightNr] = 0;
    if (Helligkeit[LightNr] > 4095) Helligkeit[LightNr] = 4095;
    Fade[LightNr] = (Helligkeit[LightNr] - LightOld[LightNr])/100;
  }
  for (int Anzahl = 1; Anzahl <= 100; Anzahl += 1)
  {
    for (int Channel = 0; Channel <= 15; Channel += 1)
    {
       Tlc.set(Channel, LightOld[Channel] + (Anzahl * Fade[Channel]));
    }
    Tlc.update();
    delay(Geschw);
  }
  for (int Channel = 0; Channel <= 15; Channel += 1)
  {
    Tlc.set(Channel, Helligkeit[Channel]);
    Light1[Channel] = Helligkeit[Channel];
  }
  Tlc.update();
}

void PatternFading(int LightOld[16], char* LightNew, int Geschw)
{
  float Fade[16];
  int Helligkeit[16];
  for (int LightNr = 0; LightNr <= 15; LightNr += 1)
  {
    Helligkeit[LightNr] = byte(char(LightNew[LightNr])) -48;
    if (Helligkeit[LightNr] > 9) Helligkeit[LightNr] -= 39;
    if (Helligkeit[LightNr] > 0) Helligkeit[LightNr] = (Helligkeit[LightNr] + 1) * 256;
    if (Helligkeit[LightNr] > 0) Helligkeit[LightNr] -= 1;
    Fade[LightNr] = (Helligkeit[LightNr] - LightOld[LightNr])/100;
  }
  for (int Anzahl = 1; Anzahl <= 100; Anzahl += 1)
  {
    for (int Channel = 0; Channel <= 15; Channel += 1)
    {
       Tlc.set(Channel, LightOld[Channel] + (Anzahl * Fade[Channel]));
    }
    Tlc.update();
    delay(Geschw);
  }
  for (int Channel = 0; Channel <= 15; Channel += 1)
  {
    Tlc.set(Channel, Helligkeit[Channel]);
    Light1[Channel] = Helligkeit[Channel];
  }
  Tlc.update();
}

void SetPattern(int LightOld[16], char* LightNew)
{
  int Helligkeit[16];
  for (int LightNr = 0; LightNr <= 15; LightNr += 1)
  {
    Helligkeit[LightNr] = byte(char(LightNew[LightNr])) -48;
    if (Helligkeit[LightNr] > 9) Helligkeit[LightNr] -= 39;
    if (Helligkeit[LightNr] > 0) Helligkeit[LightNr] = (Helligkeit[LightNr] + 1) * 256;
    if (Helligkeit[LightNr] > 0) Helligkeit[LightNr] -= 1;
  }
  for (int Channel = 0; Channel <= 15; Channel += 1)
  {
    Tlc.set(Channel, Helligkeit[Channel]);
    Light1[Channel] = Helligkeit[Channel];
  }
  Tlc.update();
}

void Drehen(int LightOld[16], int Anzahl, byte Richtung, int Geschw)
{
  int Hilfs;
  for (int Schritt = 1; Schritt <= Anzahl; Schritt += 1)
  {
     for (int Channel = 0; Channel <= 15; Channel += 1)
     {
        Tlc.set(Channel, LightOld[Channel]);
     }
     Tlc.update();
     delay(Geschw);
     if (Schritt < Anzahl)
     {
       for (int Channel = 15; Channel >= 1; Channel -= 1)
       {
         if (Richtung > 0)
         { 
            Hilfs = LightOld[Channel];
            LightOld[Channel] = LightOld[Channel - 1];
            LightOld[Channel - 1] = Hilfs;
         }
            else
            {
               Hilfs = LightOld[15 - Channel];
               LightOld[15 - Channel] = LightOld[15 - (Channel - 1)];
               LightOld[15 - (Channel - 1)] = Hilfs;               
            } 
       }
     }
  }
  for (int Channel = 0; Channel <= 15; Channel += 1)
  {
    Light1[Channel] = LightOld[Channel];
  }
}

Dies ist die neue Version des Codes. Grösse = 6064 Bytes

In char* PatternFrame[] werden die Pattern definiert. Es sind sogenannte Sollzustände. Für jede der 16 Leds ein Zeichen, wobei 0 für 0, 1 für 511 und f für 4095 steht. Hexadezimalsystem. Es sind 16 verschiedene Helligkeitswerte möglich.

In Light1 stehen die Helligkeitswerte für die Darstellung. Diese Werte werden durch die einzelnen Funktionen verändert.

DeclareParam(Led1, Led2, Led3 ... Led15, Led16) NEW
Hier wird der Inhalt von Light2 definiert. Dies ist für die Benutzung der Funktionen ParamFading und SetParam nötig !

ParamFading(Istzustand, Sollzustand, Geschwindigkeit) NEW
In dieser Funktion wird von den Helligkeitswerte die in Light1 enhalten sind auf die Helligkeitswerte gefadet welche in Light2 definiert sind. Es sind hierbei für jede Led Werte von 0 - 4095 möglich. Dann wird die Diferenz zwischen der alten Led Helligkeit und der neuen Led Helligkeit errechnet und dieser Wert durch 100 geteilt. Er wird dann in 100 Schritten von der alten zur neuen Helligkeit gefadet. Am Ende der Routine wird Light1 aktualisiert. Vor der Benutzung dieser Funktino muss mit DeclareParam der Inhalt von Light2 definiert werden.

SetParam(Istzustand, Sollzustand) NEW
Wie ParamFading, jedoch mit dem Unterschied das hier der neue Zustand sofort gesetzt wird. Also ohne Fading. Vor der Benutzung dieser Funktino muss mit DeclareParam der Inhalt von Light2 definiert werden.

PatternFading(Istzustand, Sollzustand, Geschwindigkeit)
In dieser Funktion wird von den Helligkeitswerte die in Light1 enhalten sind auf die Helligkeitswerte gefadet welche im ausgewählten Pattern definiert sind. Dazu werden die Patternwerte zuerst in Werte von 0 - 15 umgerechnet und dann mit 256 multipliziert. Dann wird die Diferenz zwischen der alten Led Helligkeit und der neuen Led Helligkeit errechnet und dieser Wert durch 100 geteilt. Er wird dann in 100 Schritten von der alten zur neuen Helligkeit gefadet. Am Ende der Routine wird Light1 aktualisiert.

SetPattern(Istzustand, Sollzustand) NEW
Wie PatternFading, jedoch mit dem Unterschied das hier der neue Zustand sofort gesetzt wird. Also ohne Fading.

Drehen(Istzustand, Anzahl der Schritte, Drehrichtung, Geschwindigkeit)
Drehrichtung: 0 = gegen den Uhrzeigersinn, 1 = im Uhrzeigersinn.
Die Darstellung wird also entweder im oder gegen den Uhrzeigersinn gedreht/rotiert. Hierzu wird Bubble-Sort benutzt. Also ein Lauflichteffekt.

Zur Zeit arbeite in an einem 16 LED singlecolor Ringlicht.

Unter Benutzung der TLC5940 Bibliothek.
http://code.google.com/p/tlc5940arduino/downloads/list

Interessierten möchte ich hiermit den Code zur Verfügung stellen.

#include "Tlc5940.h"

char* PatternFrame[] = { "0000000000000000",
                         "0f0f0f0f0f0f0f0f",
                         "f0f0f0f0f0f0f0f0",
                         "000000f00000000f",
                         "5555555555555555",
                         "cccccccccccccccc",
                         "ffffffffffffffff"
};
char* Frame;
int Light1[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int Light2[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
byte Zaehler;

void setup()
{
   Tlc.init();
   Tlc.clear();
   Tlc.update();
   Serial.begin(9600);
}

void loop()
{
  PatternFading(Light1, PatternFrame[1], 25);
  delay(1000);
  PatternFading(Light1, PatternFrame[2], 25);
  delay(1000);
  for (Zaehler = 0; Zaehler <= 25; Zaehler += 1)
  {
    SetPattern(Light1, PatternFrame[1]);
    delay(150);
    SetPattern(Light1, PatternFrame[2]);
    delay(150);
  }   
  PatternFading(Light1, PatternFrame[3], 25);
  delay(1000);
  Drehen(Light1, 50, 0, 150);
  Drehen(Light1, 50, 1, 150);
  delay(1000);
  DeclareParam(0,1000,2250,4095,4095,2250,1000,0,0,1000,2250,4095,4095,2250,1000,0);
  ParamFading(Light1, Light2, 25);
  delay(1000);
  DeclareParam(4095,2250,1000,0,0,1000,2250,4095,4095,2250,1000,0,0,1000,2250,4095);
  ParamFading(Light1, Light2, 25);
  delay(1000);
  for (Zaehler = 0; Zaehler <= 25; Zaehler += 1)
  {
    DeclareParam(0,1000,2250,4095,4095,2250,1000,0,0,1000,2250,4095,4095,2250,1000,0);
    SetParam(Light1, Light2);
    delay(150);
    DeclareParam(4095,2250,1000,0,0,1000,2250,4095,4095,2250,1000,0,0,1000,2250,4095);
    SetParam(Light1, Light2);
    delay(150);
  }
  delay(850);
  RandomLightFading(Light1, 25, 2);
  delay(1000);
  RandomLight(Light1, 50, 1);
  delay(1000);
  DeclareParam(1931,3229,4095,3229,1931,740,200,740,1931,3229,4095,3229,1931,740,200,740);
  ParamFading(Light1, Light2, 25);
  delay(1000);
  Drehen(Light1, 100, 1, 75);
  delay(1000);
  PatternFading(Light1, PatternFrame[0], 25); 
  delay(1000);
  for (Zaehler = 1; Zaehler <= 5; Zaehler += 1)
  {  
    Flash(Light1);
    delay(250); 
  }
  for(byte Anzahl = 1; Anzahl <= 5; Anzahl += 1)
  {
    FlashStorm(25, Anzahl * 2);
  }
  delay(1000);
}

void Flash(int LightOld[16])
{
   SetPattern(LightOld, PatternFrame[0]);
   delay(1);
   PatternFading(LightOld, PatternFrame[4], 1);   
   SetPattern(LightOld, PatternFrame[0]);
   PatternFading(LightOld, PatternFrame[5], 1);  
   SetPattern(LightOld, PatternFrame[0]); 
   PatternFading(LightOld, PatternFrame[6], 1);
   delay(1);
   SetPattern(LightOld, PatternFrame[0]); 
}

void FlashStorm(int AnzahlBlitze, byte MaxAnzahlLeds)
{
  float Flash1Fade = 13.65;
  float Flash2Fade = 27.3;
  float Flash3Fade = 40.95;
  int Helligkeit[16];
  int BlitzeBisher = 0;
  int BlitzeAktiv = 0;
  int BlitzAktiv[16];
  for(int LedNr = 0; LedNr <= 15; LedNr += 1)
  {
    Helligkeit[LedNr] = 0;
    BlitzAktiv[LedNr] = 0;
    Tlc.set(LedNr, Helligkeit[LedNr]);
  }
  Tlc.update();
  delay(1);
  while(BlitzeBisher < AnzahlBlitze)
  {
    for(byte BlitzNr = 1; BlitzNr <= MaxAnzahlLeds; BlitzNr += 1)
    {
      int LedNr;
      LedNr = random(15);
      if((BlitzAktiv[LedNr] == 0) and (BlitzeAktiv < MaxAnzahlLeds) and (BlitzeBisher < AnzahlBlitze))
      {
        BlitzAktiv[LedNr] = 1;
        BlitzeAktiv = BlitzeAktiv + 1;
      }
    }
    for (int FlashFadingStep = 1; FlashFadingStep <= 100; FlashFadingStep += 1)
    {
      for (int Channel = 0; Channel <= 15; Channel += 1)
      {
        if(BlitzAktiv[Channel] == 1) Helligkeit[Channel] = Flash1Fade * FlashFadingStep;
        if(BlitzAktiv[Channel] == 2) Helligkeit[Channel] = Flash2Fade * FlashFadingStep;
        if(BlitzAktiv[Channel] == 3) Helligkeit[Channel] = Flash3Fade * FlashFadingStep;
        Tlc.set(Channel, Helligkeit[Channel]);
      }
      Tlc.update();
      delayMicroseconds(1500); // delay(1);   
    }  
    for (int Channel = 0; Channel <= 15; Channel += 1)
    {
      if(BlitzAktiv[Channel] != 0) BlitzAktiv[Channel] = BlitzAktiv[Channel] + 1;
      if(BlitzAktiv[Channel] > 3) 
      {
        BlitzAktiv[Channel] = 0;
        BlitzeAktiv = BlitzeAktiv - 1;
        Helligkeit[Channel] = 0;
        BlitzeBisher = BlitzeBisher + 1;
      }
    }
    for (int Channel = 0; Channel <= 15; Channel += 1)
    {
      Tlc.set(Channel, Helligkeit[Channel]);
    }
    Tlc.update();
    delay(1);
  }
  for (int Channel = 0; Channel <= 15; Channel += 1)
  {
    Light1[Channel] = 0;
    Tlc.set(Channel, 0);
  }
  Tlc.update();
  delay(1);
}

void RandomLightFading(int LightOld[16], int Wiederholung, int Geschw)
{
  float Fade[16];
  int Helligkeit[16];
  for (int Nr = 1; Nr <= Wiederholung; Nr += 1)
  {
    for (int LightNr = 0; LightNr <= 15; LightNr += 1)
    {
      Helligkeit[LightNr] = random(4095);
      Fade[LightNr] = (Helligkeit[LightNr] - LightOld[LightNr])/100;
    }
    for (int Anzahl = 1; Anzahl <= 100; Anzahl += 1)
    {
      for (int Channel = 0; Channel <= 15; Channel += 1)
      {
         Tlc.set(Channel, LightOld[Channel] + (Anzahl * Fade[Channel]));
      }
      Tlc.update();
      delay(Geschw);
    }
    for (int Channel = 0; Channel <= 15; Channel += 1)
    {
      Tlc.set(Channel, Helligkeit[Channel]);
      Light1[Channel] = Helligkeit[Channel];
    }
    Tlc.update();
  }
}

void RandomLight(int LightOld[16], int Wiederholung, int Geschw)
{
  int Helligkeit[16];
  for (int Nr = 1; Nr <= Wiederholung; Nr += 1)
  {
    for (int LightNr = 0; LightNr <= 15; LightNr += 1)
    {
      Helligkeit[LightNr] = random(4095);
    }
    for (int Anzahl = 1; Anzahl <= 100; Anzahl += 1)
    {
      for (int Channel = 0; Channel <= 15; Channel += 1)
      {
         Tlc.set(Channel, Helligkeit[Channel]);
      }
      Tlc.update();
      delay(Geschw);
    }
  }
  for (int Channel = 0; Channel <= 15; Channel += 1)
  {
    Light1[Channel] = Helligkeit[Channel];
  }
}

void DeclareParam(int Param1, int Param2, int Param3, int Param4, int Param5, int Param6, int Param7, int Param8, int Param9, int Param10, int Param11, int Param12, int Param13, int Param14, int Param15, int Param16)
{
  Light2[0] = Param1;
  Light2[1] = Param2;
  Light2[2] = Param3;
  Light2[3] = Param4;
  Light2[4] = Param5;
  Light2[5] = Param6;
  Light2[6] = Param7;
  Light2[7] = Param8;
  Light2[8] = Param9;
  Light2[9] = Param10;
  Light2[10] = Param11;
  Light2[11] = Param12;
  Light2[12] = Param13;
  Light2[13] = Param14;
  Light2[14] = Param15;
  Light2[15] = Param16;
}

void ParamFading(int LightOld[16], int LightNew[16], int Geschw)
{
  float Fade[16];
  int Helligkeit[16];
  for (int LightNr = 0; LightNr <= 15; LightNr += 1)
  {
    Helligkeit[LightNr] = LightNew[LightNr];
    if (Helligkeit[LightNr] < 0) Helligkeit[LightNr] = 0;
    if (Helligkeit[LightNr] > 4095) Helligkeit[LightNr] = 4095;
    Fade[LightNr] = (Helligkeit[LightNr] - LightOld[LightNr])/100;
  }
  for (int Anzahl = 1; Anzahl <= 100; Anzahl += 1)
  {
    for (int Channel = 0; Channel <= 15; Channel += 1)
    {
       Tlc.set(Channel, LightOld[Channel] + (Anzahl * Fade[Channel]));
    }
    Tlc.update();
    delay(Geschw);
  }
  for (int Channel = 0; Channel <= 15; Channel += 1)
  {
    Tlc.set(Channel, Helligkeit[Channel]);
    Light1[Channel] = Helligkeit[Channel];
  }
  Tlc.update();
}

void SetParam(int LightOld[16], int LightNew[16])
{
  float Fade[16];
  int Helligkeit[16];
  for (int LightNr = 0; LightNr <= 15; LightNr += 1)
  {
    Helligkeit[LightNr] = LightNew[LightNr];
    if (Helligkeit[LightNr] < 0) Helligkeit[LightNr] = 0;
    if (Helligkeit[LightNr] > 4095) Helligkeit[LightNr] = 4095;
  }
  for (int Channel = 0; Channel <= 15; Channel += 1)
  {
    Tlc.set(Channel, Helligkeit[Channel]);
    Light1[Channel] = Helligkeit[Channel];
  }
  Tlc.update();
}

void PatternFading(int LightOld[16], char* LightNew, int Geschw)
{
  float Fade[16];
  int Helligkeit[16];
  for (int LightNr = 0; LightNr <= 15; LightNr += 1)
  {
    Helligkeit[LightNr] = byte(char(LightNew[LightNr])) -48;
    if (Helligkeit[LightNr] > 9) Helligkeit[LightNr] -= 39;
    if (Helligkeit[LightNr] > 0) Helligkeit[LightNr] = (Helligkeit[LightNr] + 1) * 256;
    if (Helligkeit[LightNr] > 0) Helligkeit[LightNr] -= 1;
    Fade[LightNr] = (Helligkeit[LightNr] - LightOld[LightNr])/100;
  }
  for (int Anzahl = 1; Anzahl <= 100; Anzahl += 1)
  {
    for (int Channel = 0; Channel <= 15; Channel += 1)
    {
       Tlc.set(Channel, LightOld[Channel] + (Anzahl * Fade[Channel]));
    }
    Tlc.update();
    delay(Geschw);
  }
  for (int Channel = 0; Channel <= 15; Channel += 1)
  {
    Tlc.set(Channel, Helligkeit[Channel]);
    Light1[Channel] = Helligkeit[Channel];
  }
  Tlc.update();
}
void SetPattern(int LightOld[16], char* LightNew)
{
  int Helligkeit[16];
  for (int LightNr = 0; LightNr <= 15; LightNr += 1)
  {
    Helligkeit[LightNr] = byte(char(LightNew[LightNr])) -48;
    if (Helligkeit[LightNr] > 9) Helligkeit[LightNr] -= 39;
    if (Helligkeit[LightNr] > 0) Helligkeit[LightNr] = (Helligkeit[LightNr] + 1) * 256;
    if (Helligkeit[LightNr] > 0) Helligkeit[LightNr] -= 1;
  }
  for (int Channel = 0; Channel <= 15; Channel += 1)
  {
    Tlc.set(Channel, Helligkeit[Channel]);
    Light1[Channel] = Helligkeit[Channel];
  }
  Tlc.update();
}

void Drehen(int LightOld[16], int Anzahl, byte Richtung, int Geschw)
{
  int Hilfs;
  for (int Schritt = 0; Schritt <= Anzahl; Schritt += 1)
  {
     for (int Channel = 0; Channel <= 15; Channel += 1)
     {
        Tlc.set(Channel, LightOld[Channel]);
     }
     Tlc.update();
     delay(Geschw);
     if (Schritt < Anzahl)
     {
       for (int Channel = 15; Channel >= 1; Channel -= 1)
       {
         if (Richtung > 0)
         { 
            Hilfs = LightOld[Channel];
            LightOld[Channel] = LightOld[Channel - 1];
            LightOld[Channel - 1] = Hilfs;
         }
            else
            {
               Hilfs = LightOld[15 - Channel];
               LightOld[15 - Channel] = LightOld[15 - (Channel - 1)];
               LightOld[15 - (Channel - 1)] = Hilfs;               
            } 
       }
     }
  }
  for (int Channel = 0; Channel <= 15; Channel += 1)
  {
    Light1[Channel] = LightOld[Channel];
  }
}

Der Code in beiden Fenstern gehört zusammen. Passte aber aufgrund seiner Grösse nicht mehr in ein einzelnes Fenster.

Dies ist die neueste Version des Codes. Grösse = 8638 Bytes

In char* PatternFrame[] werden die Pattern definiert. Es sind sogenannte Sollzustände. Für jede der 16 Leds ein Zeichen, wobei 0 für 0, 1 für 511 und f für 4095 steht. Hexadezimalsystem. Es sind 16 verschiedene Helligkeitswerte möglich.

In Light1 stehen die Helligkeitswerte für die Darstellung. Diese Werte werden durch die einzelnen Funktionen verändert.

DeclareParam(Led1, Led2, Led3 ... Led15, Led16)
Hier wird der Inhalt von Light2 definiert. Dies ist für die Benutzung der Funktionen ParamFading und SetParam nötig !

Flash(IstZustand) NEW
Erzeugt auf allen Leds einen Blitzeffekt.

FlashStorm(Anzahl der Blitze, Max Anzahl der Leds) NEW
Erzeugt den Effekt eines Blitzlichtgewitters.
Hier kann man angeben wieviel Blitzlichteffekte insgesamt erzeugt werden sollen.
Desweiteren auf wievielen Leds maximal zur selben Zeit.
Die Position der Blitzeffekte ist hierbei zufällig.
50, 10 bedeutet hierbei 50 Blitze aber nur maximal 10 zur selben Zeit.

RandomLightFading(Istzustand, Anzahl der Lichtwechsel, Geschwindigkeit)
Wie ParamFading, nur werden hier die neuen Helligkeiten per Zufall festgelegt. Hier kann auch angegeben werden wieviele Lichtwechsel stattfinden sollen.

**RandomLight(Istzustand, Anzahl der Lichtwechsel, Geschwindigkeit)**Wie RandomLightFading, auch hier werden die neuen Helligkeiten per Zufall festgelegt. Nur das die neuen Werte direkt gesetzt werden, es wird nicht gefadet.

ParamFading(Istzustand, Sollzustand, Geschwindigkeit)
In dieser Funktion wird von den Helligkeitswerte die in Light1 enhalten sind auf die Helligkeitswerte gefadet welche in Light2 definiert sind. Es sind hierbei für jede Led Werte von 0 - 4095 möglich. Dann wird die Diferenz zwischen der alten Led Helligkeit und der neuen Led Helligkeit errechnet und dieser Wert durch 100 geteilt. Er wird dann in 100 Schritten von der alten zur neuen Helligkeit gefadet. Am Ende der Routine wird Light1 aktualisiert. Vor der Benutzung dieser Funktino muss mit DeclareParam der Inhalt von Light2 definiert werden.

SetParam(Istzustand, Sollzustand)
Wie ParamFading, jedoch mit dem Unterschied das hier der neue Zustand sofort gesetzt wird. Also ohne Fading. Vor der Benutzung dieser Funktino muss mit DeclareParam der Inhalt von Light2 definiert werden.

PatternFading(Istzustand, Sollzustand, Geschwindigkeit)
In dieser Funktion wird von den Helligkeitswerte die in Light1 enhalten sind auf die Helligkeitswerte gefadet welche im ausgewählten Pattern definiert sind. Dazu werden die Patternwerte zuerst in Werte von 0 - 15 umgerechnet und dann mit 256 multipliziert. Dann wird die Diferenz zwischen der alten Led Helligkeit und der neuen Led Helligkeit errechnet und dieser Wert durch 100 geteilt. Er wird dann in 100 Schritten von der alten zur neuen Helligkeit gefadet. Am Ende der Routine wird Light1 aktualisiert.

SetPattern(Istzustand, Sollzustand)
Wie PatternFading, jedoch mit dem Unterschied das hier der neue Zustand sofort gesetzt wird. Also ohne Fading.

Drehen(Istzustand, Anzahl der Schritte, Drehrichtung, Geschwindigkeit)
Drehrichtung: 0 = gegen den Uhrzeigersinn, 1 = im Uhrzeigersinn.
Die Darstellung wird also entweder im oder gegen den Uhrzeigersinn gedreht/rotiert. Hierzu wird Bubble-Sort benutzt. Also ein Lauflichteffekt.

Die Videoqualität ist leider nicht die beste !

Als nächstes wird die Schaltung auf 32 Leds, weis und kristallklar, erweitert und diese aufgelötet. Danach wird das Programm entsprechend angepasst.

Anbei könnt Ihr schonmal die Vorabversion des Fritzing-Files meiner 32 Led Schaltung laden:
http://rapidshare.com/files/435539960/32_LED_Ringlicht_Schaltung.fz

Arbeite zur Zeit noch am Platinenlayout für das Shield.

Es werden 32 Leds unterstützt und das Shield hat eine externe Stromversorgung ! 7 - 12 V. Desweiteren kann man daran einen externen Ledträger anschliessen dessen Form und Aussehen jeder für sich selber definieren kann. Für jede Kathode ist ein einzelner Anschluss vorhanden. Die Anoden der einzelnen Leds müssen zusammengeführt werden.

Bauteileliste:
2 X 10µF Elkos
1 X L7805
2 X TLC5940NT
2 X 2k Ohm Widerstände
2 X 10k Ohm Widerstände
1 X Netzteil 9V 800mA

Moin,

drei Punkte:

  1. Sehr cool die Datei zur Verfügung zu stellen.
  2. Fritzing fehlen etliche Komponenten, kann also leider nix damit anfangen.
  3. auf http://www.file-upload.net kann man sehr unkompliziert(ohne Anmeldung) und vor allem fix Daten zum Download bereit stellen.

Gruß

Sebastian

Fritzing Bauteile:

Einfach die obrige und diese Datei laden !

Wenn das Shield Layout fertig ist entwerfe ich mit Fritzing eine Standalone Schaltung mit einem Atmega328 auf der Platine.

Ein erstes Photo vom 32 Led Ringlicht Prototypen.
Die Kabel sind noch nicht angelötet !

Uploaded with ImageShack.us

Denke mal das das ich den Deckel mit Silberfarbe lackieren werde !

Natürlich könnte der Led Träger auch viereckig, oval oder sternförmig sein !

Cool!
Und lass den Dekel wie er ist :slight_smile: Sieht klasse aus so!

...und jetzt warte ich auf den youtube film, der das Ding in Action zeigt :smiley:

Ein Foto der Breadboard Atmega328 Schaltung, der Atmega328 wird mit 16MHz getaktet.

Uploaded with ImageShack.us

Der zweite TLC5940, für die nächsten 16 Leds, ist noch nicht angeschlossen !

Ich habe meine Breadboard Ringlichtschaltung, so wie sie oben auf dem Foto zu sehen ist, mit einem L7805 und zwei Kerkos zu je 330nF und 100nF betrieben. So wie es im Datasheet des L7805 empfohlen wird. Zwischendurch sah es allerdings so aus als ob die Schaltung spinnen würde. So blieb der Ablauf zwischendurch manchmal hängen und ähnlich.

Als ich die beiden Kondensatoren am L7805 jedoch gegen zwei Elkos mit 10µF ausgetauscht hatte funktionierte die Schaltung auf Anhieb konstant fehlerfrei.

Kann mir jemand erklären woran dies liegt ?
Ist da zwischendurch die Spannung zusammengebrochen ?

Du hast die einfach zu klein dimensioniert.

So brach wohl manchmal die Spannung zusammen.

Das Datenblatt nennt zwar diese Kapazitäten, ich benutze aber zB immer 10µF oder 100µF