INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Laufschrift mit RGB-LEDs
29.04.2015, 13:23 (Dieser Beitrag wurde zuletzt bearbeitet: 29.04.2015 13:30 von scritch.)
Beitrag #25
RE: Laufschrift mit RGB-LEDs
Danke für die Tipps, Thorsten. Ich komme aus dem Norden, genauer gesagt aus Dithmarschen.

Die Variablen die sich nicht ändern, habe ich jetzt angepasst.
Wenn ich es recht verstehe, ist der PROMEM mit der Auslagerungsdatei einer HDD zu vergleichen. Das Schreiben der Buchstaben in den PROGMEM war jetzt nicht so das Problem, beim Auslesen habe ich jetzt aber irgendwie einen Knoten im Kopf, von dem was ich da so gelesen habe.

Edit: Habe jetzt mal etwas damit rumgespielt. Ich habe keinen Plan, wie ich das einsetzen soll Sad Mein Test funktioniert nicht. Da gibt es irgendwie 0 und 1-Chaos...

Code:
#include <Adafruit_NeoPixel.h>

#define PIN_1 8//
#define PIN_2 2
#define PIN_3 3
#define PIN_4 4
#define PIN_5 5
#define PIN_6 6
#define PIN_7 9

#define NUMPIXELS      40 //vorerst für den Prototypen
#define num_spalten  6
#define num_stripes  7

Adafruit_NeoPixel stripe_1 = Adafruit_NeoPixel(NUMPIXELS, PIN_1, NEO_GRB + NEO_KHZ800);//die bezeichnung der Stripes kann verändert werden. so kann man diese auch in einer Zählerschleife ansprechen
Adafruit_NeoPixel stripe_2 = Adafruit_NeoPixel(NUMPIXELS, PIN_2, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel stripe_3 = Adafruit_NeoPixel(NUMPIXELS, PIN_3, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel stripe_4 = Adafruit_NeoPixel(NUMPIXELS, PIN_4, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel stripe_5 = Adafruit_NeoPixel(NUMPIXELS, PIN_5, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel stripe_6 = Adafruit_NeoPixel(NUMPIXELS, PIN_6, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel stripe_7 = Adafruit_NeoPixel(NUMPIXELS, PIN_7, NEO_GRB + NEO_KHZ800);

Adafruit_NeoPixel stripes[] = { stripe_1, stripe_2, stripe_3, stripe_4, stripe_5, stripe_6, stripe_7};

int modus_buchstabenfarbwechsel = 0; int modus_spaltenfarbwechsel = 0; int modus_pixelfarbwechsel = 0; int modus_spaltenfarbuebergang = 0;
int modus_text = 0; // ist für den Moduswechsel damit man z. B. über den seriellen Port den Text (vorher im µController gespeichert) wechseln kann
int arraylaenge = 0; // beinhaltet die Länge des Arrays des Textes
int rot_an = 255; int gruen_an = 0; int blau_an = 0; //Die Farben der LEDs welche die Buchstaben darstellen
int rot_aus = 0; int gruen_aus = 0; int blau_aus = 0; //Die Farben der LEDs welche nicht die Buchstaben darstellen
int verzoegerung = 0; //ist die Verzögerung in ms, mit der die Schrift läuft. Je kleiner der Wert, desto schneller läuft sie.
byte Spalte_1; byte Spalte_2; byte Spalte_3; byte Spalte_4; byte Spalte_5; byte Spalte_6;
byte spalten[6] = {Spalte_1, Spalte_2, Spalte_3, Spalte_4, Spalte_5, Spalte_6};

const PROGMEM byte buchstabe_A[6] = {B0111111, B1000100, B1000100, B1000100, B0111111, B0000000};
const PROGMEM byte buchstabe_B[6] = {B1111111, B1001001, B1001001, B1001001, B0110110, B0000000};
const PROGMEM byte buchstabe_C[6] = {B0111110, B1000001, B1000001, B1000001, B0100010, B0000000};
const PROGMEM byte buchstabe_D[6] = {B1111111, B1000001, B1000001, B0100010, B0011100, B0000000};
const PROGMEM byte buchstabe_E[6] = {B1111111, B1001001, B1001001, B1001001, B1000001, B0000000};
const PROGMEM byte buchstabe_F[6] = {B1111111, B1001000, B1001000, B1001000, B1000000, B0000000};
const PROGMEM byte buchstabe_G[6] = {B0111110, B1000001, B1001001, B1001001, B0101111, B0000000};
const PROGMEM byte buchstabe_H[6] = {B1111111, B0001000, B0001000, B0001000, B1111111, B0000000};
const PROGMEM byte buchstabe_I[6] = {B0000000, B1000001, B1111111, B1000001, B0000000, B0000000};
const PROGMEM byte buchstabe_J[6] = {B0000010, B0000001, B1000001, B1111110, B1000000, B0000000};
const PROGMEM byte buchstabe_K[6] = {B1111111, B0001000, B0010100, B0100010, B1000001, B0000000};
const PROGMEM byte buchstabe_L[6] = {B1111111, B0000001, B0000001, B0000001, B0000001, B0000000};
const PROGMEM byte buchstabe_M[6] = {B1111111, B0100000, B0011000, B0100000, B1111111, B0000000};
const PROGMEM byte buchstabe_N[6] = {B1111111, B0010000, B0001000, B0000100, B1111111, B0000000};
const PROGMEM byte buchstabe_O[6] = {B0111110, B1000001, B1000001, B1000001, B0111110, B0000000};
const PROGMEM byte buchstabe_P[6] = {B1111111, B1001000, B1001000, B1001000, B0110000, B0000000};
const PROGMEM byte buchstabe_Q[6] = {B0111110, B1000001, B1000101, B1000010, B0111101, B0000000};
const PROGMEM byte buchstabe_R[6] = {B1111111, B1001000, B1001100, B1001010, B0110001, B0000000};
const PROGMEM byte buchstabe_S[6] = {B0110001, B1001001, B1001001, B1001001, B1000110, B0000000};
const PROGMEM byte buchstabe_T[6] = {B1000000, B1000000, B1111111, B1000000, B1000000, B0000000};
const PROGMEM byte buchstabe_U[6] = {B1111110, B0000001, B0000001, B0000001, B1111110, B0000000};
const PROGMEM byte buchstabe_V[6] = {B1111100, B0000010, B0000001, B0000010, B1111100, B0000000};
const PROGMEM byte buchstabe_W[6] = {B1111110, B0000001, B0001110, B0000001, B1111110, B0000000};
const PROGMEM byte buchstabe_X[6] = {B1100011, B0010100, B0001000, B0010100, B1100011, B0000000};
const PROGMEM byte buchstabe_Y[6] = {B1110000, B0001000, B0000111, B0001000, B1110000, B0000000};
const PROGMEM byte buchstabe_Z[6] = {B1000011, B1000101, B1001001, B1010001, B1100001, B0000000};
const PROGMEM byte sonderzeichen_punkt[6] = {B0000000, B0000011, B0000011, B0000000, B0000000, B0000000};

const PROGMEM  byte herz[6] = {B0011000, B0100100, B0010011, B0100100, B0011000, B0000000};
const PROGMEM  byte ingo[6] = {B0000100, B0110010, B0000010, B0110010, B0000100, B0000000};
const PROGMEM byte space[6] = {B0000000, B0000000, B0000000, B0000000, B0000000, B0000000};

char buchstabe = ' ';
char atext[255];


void setup() {
Serial.begin(9600);
stripe_1.begin();
stripe_2.begin();
stripe_3.begin();
stripe_4.begin();
stripe_5.begin();
stripe_6.begin();
stripe_7.begin();
}

void loop(){
  modus_buchstabenfarbwechsel = 0;//1 mit überggeben
  modus_spaltenfarbwechsel = 0;//2 übergeben
  modus_pixelfarbwechsel = 0;//3 übergeben
  modus_spaltenfarbuebergang = 4;//4 übergeben
  modus_text = 2;
  verzoegerung = 80; //
  f_helligkeit(50);
  
  
  
  switch(modus_text){
    case 1:
      arraylaenge = 46;
      strcpy(atext, "DIE FESTSTELLTASTE IST MEIN GROESSTER FREUND. ");

    break;
      
    case 2:
      arraylaenge = 26;
      strcpy(atext, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");

    break;
    
    case 3:
      arraylaenge = 7;
      strcpy(atext, "IJKLMNO");
    break;
  }
  
  for(int i=0; i<arraylaenge; i++){
    _farbwechsel(modus_buchstabenfarbwechsel);
      
    buchstabe = atext[i];
    switch(buchstabe){
      
      case '<':
        _anzeigen(herz);
      break;
      
      case 'A':
        _anzeigen(buchstabe_A);
      break;
      
      case 'B':
        _anzeigen(buchstabe_B);
      break;
      
       case 'C':
        _anzeigen(buchstabe_C);
      break;
    
       case 'D':
        _anzeigen(buchstabe_D);
      break;
                
      case 'E':
        _anzeigen(buchstabe_E);
      break;
                  
      case 'F':
        _anzeigen(buchstabe_F);
      break;
      
      case 'G':
        _anzeigen(buchstabe_G);
      break;
                  
      case 'H':
        _anzeigen(buchstabe_H);
      break;
      
      case 'I':
        _anzeigen(buchstabe_I);
      break;
      
       case 'J':
        _anzeigen(buchstabe_J);
      break;
      
       case 'K':
        _anzeigen(buchstabe_K);
      break;
      
      case 'L':
        _anzeigen(buchstabe_L);
      break;
      
      case 'M':
        _anzeigen(buchstabe_M);
      break;
                  
      case 'N':
        _anzeigen(buchstabe_N);
      break;
            
      case 'O':
        _anzeigen(buchstabe_O);
      break;
      
       case 'P':
        _anzeigen(buchstabe_P);
      break;
      
      case 'Q':
        _anzeigen(buchstabe_Q);
      break;
      
      case 'R':
        _anzeigen(buchstabe_R);
      break;
      
      case 'S':
        _anzeigen(buchstabe_S);
      break;
      
      case 'T':
        _anzeigen(buchstabe_T);
      break;
      
      case 'U':
        _anzeigen(buchstabe_U);
      break;
      
      case 'V':
        _anzeigen(buchstabe_V);
      break;
      
      case 'W':
        _anzeigen(buchstabe_W);
      break;
      
      case 'X':
        _anzeigen(buchstabe_X);
      break;
      
      case 'Y':
        _anzeigen(buchstabe_Y);
      break;
      
      case 'Z':
        _anzeigen(buchstabe_Z);
      break;
      
      case '.':
        _anzeigen(sonderzeichen_punkt);
      break;
      
      case ' ':
        _anzeigen(space);
      break;
      
      case 'n':
        _anzeigen(ingo);
      break;
    }
  }
}

void _anzeigen(const PROGMEM byte buchstabe[]){
    for(int i=0; i<num_spalten; i++){
    
      _farbwechsel(modus_spaltenfarbwechsel);
      _farbwechsel(modus_spaltenfarbuebergang);
      
      int var = 0; //Zählervariable für die Stripe-Nummer die angesprochen wird
      for(int j=6; j> -1; j--){ // Es wird an einer niedrigeren Position angefangen zu zählen, da.... bla... irgendwas
        
        _farbwechsel(modus_pixelfarbwechsel);

         if(bitRead(pgm_read_byte(buchstabe[i]), j) == 1){
         //if(bitRead(buchstabe[i], j) == 1){ //Wenn der ausgelesene Bit gleich eins ist, dann...
           stripes[var].setPixelColor(NUMPIXELS - 1, stripes[var].Color(rot_an, gruen_an, blau_an));
         }  
         else{// Wenn der ausgelesene Bit nicht eins ist, dann
           stripes[var].setPixelColor(NUMPIXELS - 1, stripes[var].Color(rot_aus, gruen_aus, blau_aus));
         }  
        var = var + 1;
      }
      stripes[i].show();
      _einruecken();
      
      delay(verzoegerung);
     }
}

void _farbwechsel(int modus){

  switch(modus){
      case 1://buchstabe
        rot_an = random(0, 255);
        gruen_an = random(0, 255);
        blau_an = random(0, 255);
      break;
      
      case 2://spalte
        rot_an = random(0, 255);
        gruen_an = random(0, 255);
        blau_an = random(0, 255);
      break;
      
      case 3://pixel
        rot_an = random(0, 255);
        gruen_an = random(0, 255);
        blau_an = random(0, 255);
      break;
      
      case 4://spalte farbwechsel
        if(rot_an == 255 && blau_an == 0){
          if(gruen_an < 255){
            gruen_an = gruen_an + 15;
          }
        }
        
        if(gruen_an == 255){
          if(rot_an > 0){
            rot_an = rot_an - 15;
          }
        }
        
        if(rot_an == 0){
          if(blau_an < 255){
            blau_an = blau_an + 15;
          }
        }
        
        if(blau_an == 255){
          if(gruen_an > 0){
            gruen_an = gruen_an - 15;
          }
        }
        
        if(gruen_an == 0){
          if(rot_an < 255){
            rot_an = rot_an + 15;
            
          }
        }      
        
        if(rot_an == 255 && gruen_an == 0 && blau_an > 0){      
            blau_an = blau_an - 15;
        }
      break;
    }
}


void _einruecken(){
  for(int i=0; i<num_stripes; i++){
     for(int j=0; j<NUMPIXELS; j++){
       uint32_t color = stripes[i].getPixelColor(j + 1);
       stripes[i].setPixelColor(j, color);
       //stripes[i].show();              
     }
  }
}


void f_helligkeit(int val_helligkeit){
  for(int i=0 ; i < num_stripes ; i++){
    stripes[i].setBrightness(val_helligkeit);
    //stripes[i].show();
  }  
}

Ich vermute ich muss die Funktion _anzeigen() anders aufrufen, als ich es derzeit tue, oder?

Edit2: Dies hätte ich als Idee des Funktionsaufrufes im Kopf:
Code:
_anzeigen(pgm_read_byte(buchstabe_A[0], pgm_read_byte(buchstabe_A[1], pgm_read_byte(buchstabe_A[2], pgm_read_byte(buchstabe_A[3], pgm_read_byte(buchstabe_A[4], pgm_read_byte(buchstabe_A[5]);
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
29.04.2015, 13:37
Beitrag #26
RE: Laufschrift mit RGB-LEDs
Hi,
nein, das muesste schon so stimmen. Versuch mal das hier
Code:
pgm_read_byte(buchstabe[i])
durch das zu ersetzen:
Code:
pgm_read_byte(buchstabe+i)
Gruss,
Thorsten

Falls ich mit einer Antwort helfen konnte, wuerde ich mich freuen, ein paar Fotos oder auch ein kleines Filmchen des zugehoerigen Projekts zu sehen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
29.04.2015, 14:50
Beitrag #27
RE: Laufschrift mit RGB-LEDs
Funktioniert folgendermaßen leider nicht.

if(bitRead(pgm_read_byte(buchstabe+i), j) == 1){
}

Das kommt wieder nur 1 und 0-Chaos heraus. Siehe dieses Video: https://www.youtube.com/watch?v=pBiyzeuz...e=youtu.be
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
29.04.2015, 15:19
Beitrag #28
RE: Laufschrift mit RGB-LEDs
Hi,
also so genau weiss ich das jetzt auch nicht. Versuch mal das:
Code:
const byte buchstabe_W[6] PROGMEM = {B1111...
...und spaeter
Code:
void _anzeigen(const byte* buchstabe){
Gruss,
Thorsten

Falls ich mit einer Antwort helfen konnte, wuerde ich mich freuen, ein paar Fotos oder auch ein kleines Filmchen des zugehoerigen Projekts zu sehen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
29.04.2015, 16:53
Beitrag #29
RE: Laufschrift mit RGB-LEDs
Ich habe mal meinen Lösungsansatz von vorhin verfolgt. Das funktioniert soweit, in guter Geschwindigkeit. Allerdings habe ich so das Problem, Dass ich die Spalten nicht nacheinander in einer Schleife verarbeiten kann. Hast du da einen Tipp?

Code:
#include <Adafruit_NeoPixel.h>

#define PIN_1 8//
#define PIN_2 2
#define PIN_3 3
#define PIN_4 4
#define PIN_5 5
#define PIN_6 6
#define PIN_7 9

#define NUMPIXELS      45 //vorerst für den Prototypen
#define num_spalten  7
#define num_stripes  7

Adafruit_NeoPixel stripe_1 = Adafruit_NeoPixel(NUMPIXELS, PIN_1, NEO_GRB + NEO_KHZ800);//die bezeichnung der Stripes kann verändert werden. so kann man diese auch in einer Zählerschleife ansprechen
Adafruit_NeoPixel stripe_2 = Adafruit_NeoPixel(NUMPIXELS, PIN_2, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel stripe_3 = Adafruit_NeoPixel(NUMPIXELS, PIN_3, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel stripe_4 = Adafruit_NeoPixel(NUMPIXELS, PIN_4, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel stripe_5 = Adafruit_NeoPixel(NUMPIXELS, PIN_5, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel stripe_6 = Adafruit_NeoPixel(NUMPIXELS, PIN_6, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel stripe_7 = Adafruit_NeoPixel(NUMPIXELS, PIN_7, NEO_GRB + NEO_KHZ800);

Adafruit_NeoPixel stripes[] = { stripe_1, stripe_2, stripe_3, stripe_4, stripe_5, stripe_6, stripe_7};



int modus_buchstabenfarbwechsel = 0; int modus_spaltenfarbwechsel = 0; int modus_pixelfarbwechsel = 0; int modus_spaltenfarbuebergang = 0;
int modus_text = 0; // ist für den Moduswechsel damit man z. B. über den seriellen Port den Text (vorher im µController gespeichert) wechseln kann
int arraylaenge = 0; // beinhaltet die Länge des Arrays des Textes
int rot_an = 255; int gruen_an = 0; int blau_an = 0; //Die Farben der LEDs welche die Buchstaben darstellen
int rot_aus = 0; int gruen_aus = 0; int blau_aus = 0; //Die Farben der LEDs welche nicht die Buchstaben darstellen
int verzoegerung = 0; //ist die Verzögerung in ms, mit der die Schrift läuft. Je kleiner der Wert, desto schneller läuft sie.
//int f_helligkeit = 0; //Variable für die Helligkeit

int stripe_nummer = 0;



  
byte Spalte_1; byte Spalte_2; byte Spalte_3; byte Spalte_4; byte Spalte_5; byte Spalte_6;
byte spalten[6] = {Spalte_1, Spalte_2, Spalte_3, Spalte_4, Spalte_5, Spalte_6};

const PROGMEM byte buchstabe_A[6] = {B0111111, B1000100, B1000100, B1000100, B0111111, B0000000};
const PROGMEM byte buchstabe_B[6] = {B1111111, B1001001, B1001001, B1001001, B0110110, B0000000};
const PROGMEM byte buchstabe_C[6] = {B0111110, B1000001, B1000001, B1000001, B0100010, B0000000};
const PROGMEM byte buchstabe_D[6] = {B1111111, B1000001, B1000001, B0100010, B0011100, B0000000};
const PROGMEM byte buchstabe_E[6] = {B1111111, B1001001, B1001001, B1001001, B1000001, B0000000};
const PROGMEM byte buchstabe_F[6] = {B1111111, B1001000, B1001000, B1001000, B1000000, B0000000};
const PROGMEM byte buchstabe_G[6] = {B0111110, B1000001, B1001001, B1001001, B0101111, B0000000};
const PROGMEM byte buchstabe_H[6] = {B1111111, B0001000, B0001000, B0001000, B1111111, B0000000};
const PROGMEM byte buchstabe_I[6] = {B0000000, B1000001, B1111111, B1000001, B0000000, B0000000};
const PROGMEM byte buchstabe_J[6] = {B0000010, B0000001, B1000001, B1111110, B1000000, B0000000};
const PROGMEM byte buchstabe_K[6] = {B1111111, B0001000, B0010100, B0100010, B1000001, B0000000};
const PROGMEM byte buchstabe_L[6] = {B1111111, B0000001, B0000001, B0000001, B0000001, B0000000};
const PROGMEM byte buchstabe_M[6] = {B1111111, B0100000, B0011000, B0100000, B1111111, B0000000};
const PROGMEM byte buchstabe_N[6] = {B1111111, B0010000, B0001000, B0000100, B1111111, B0000000};
const PROGMEM byte buchstabe_O[6] = {B0111110, B1000001, B1000001, B1000001, B0111110, B0000000};
const PROGMEM byte buchstabe_P[6] = {B1111111, B1001000, B1001000, B1001000, B0110000, B0000000};
const PROGMEM byte buchstabe_Q[6] = {B0111110, B1000001, B1000101, B1000010, B0111101, B0000000};
const PROGMEM byte buchstabe_R[6] = {B1111111, B1001000, B1001100, B1001010, B0110001, B0000000};
const PROGMEM byte buchstabe_S[6] = {B0110001, B1001001, B1001001, B1001001, B1000110, B0000000};
const PROGMEM byte buchstabe_T[6] = {B1000000, B1000000, B1111111, B1000000, B1000000, B0000000};
const PROGMEM byte buchstabe_U[6] = {B1111110, B0000001, B0000001, B0000001, B1111110, B0000000};
const PROGMEM byte buchstabe_V[6] = {B1111100, B0000010, B0000001, B0000010, B1111100, B0000000};
const PROGMEM byte buchstabe_W[6] = {B1111110, B0000001, B0001110, B0000001, B1111110, B0000000};
const PROGMEM byte buchstabe_X[6] = {B1100011, B0010100, B0001000, B0010100, B1100011, B0000000};
const PROGMEM byte buchstabe_Y[6] = {B1110000, B0001000, B0000111, B0001000, B1110000, B0000000};
const PROGMEM byte buchstabe_Z[6] = {B1000011, B1000101, B1001001, B1010001, B1100001, B0000000};
const PROGMEM byte sonderzeichen_punkt[6] = {B0000000, B0000011, B0000011, B0000000, B0000000, B0000000};

const PROGMEM  byte herz[6] = {B0011000, B0100100, B0010011, B0100100, B0011000, B0000000};
const PROGMEM  byte ingo[6] = {B0000100, B0110010, B0000010, B0110010, B0000100, B0000000};
const PROGMEM byte space[6] = {B0000000, B0000000, B0000000, B0000000, B0000000, B0000000};

char buchstabe = ' ';

//char text[6] = {'H', 'A', 'L', 'L', 'O', ' '};
//char text[13] = {'F', 'R', 'O', 'H', 'E', ' ', 'O', 'S', 'T', 'E', 'R', 'N', ' '};
//char text[15] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O'};
// text[1] = {'n'};
//char text[9] = {'I', '<', 'C', 'O', 'P', 'T', 'E', 'R', ' '};
//char text[26] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};

//char text[31] = {'H', 'A', 'B', 'E', ' ', 'E', 'U', 'C', 'H', ' ', 'L', 'I', 'E', 'B', '.', ' ', 'I', 'H', 'R', ' ', 'S', 'E', 'I', 'D', ' ', 'T', 'O', 'L', 'L', '.', ' '};
char atext[255];
//char atext_1[3] = {'A', 'B', 'C'};
//char atext_2[5] = {'D', 'E', 'F', 'G', 'H'};      
//char atext_3[7] = {'I', 'J', 'K', 'L', 'M', 'N', 'O'};


//char atext_1[] = {' '};

void setup() {
Serial.begin(9600);
stripe_1.begin();
stripe_2.begin();
stripe_3.begin();
stripe_4.begin();
stripe_5.begin();
stripe_6.begin();
stripe_7.begin();
}

void loop(){
  modus_buchstabenfarbwechsel = 0;//1 mit überggeben
  modus_spaltenfarbwechsel = 0;//2 übergeben
  modus_pixelfarbwechsel = 0;//3 übergeben
  modus_spaltenfarbuebergang = 4;//4 übergeben
  modus_text = 3;
  verzoegerung = 120; //
  f_helligkeit(150);
  
  
  
  switch(modus_text){
    case 1:
      arraylaenge = 46;
      strcpy(atext, "DIE FESTSTELLTASTE IST MEIN GROESSTER FREUND. ");

    break;
      
    case 2:
      arraylaenge = 26;
      strcpy(atext, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");

    break;
    
    case 3:
      arraylaenge = 1;
      strcpy(atext, "A");
    break;
  }
  
  
  // _einruecken();
  
  //for schleife für den text
  for(int i=0; i<arraylaenge; i++){ //erstmal nur provisorisch, damit die buchstaben für den text nacheinander in eine variable für die auswertung das switch-case verarbeitet werden können
    
    _farbwechsel(modus_buchstabenfarbwechsel);
      
    buchstabe = atext[i];
    switch(buchstabe){
      
      case '<':
       // _anzeigen(herz);
      break;
      
      case 'A':
        //_anzeigen(buchstabe_A);        
        _anzeigen(pgm_read_byte(&buchstabe_A[0]), pgm_read_byte(&buchstabe_A[1]), pgm_read_byte(&buchstabe_A[2]), pgm_read_byte(&buchstabe_A[3]), pgm_read_byte(&buchstabe_A[4]), pgm_read_byte(&buchstabe_A[5]));
      break;
      
      /*
      case 'B':
        _anzeigen(buchstabe_B);
      break;
      
       case 'C':
        _anzeigen(buchstabe_C);
      break;
    
       case 'D':
        _anzeigen(buchstabe_D);
      break;
                
      case 'E':
        _anzeigen(buchstabe_E);
      break;
                  
      case 'F':
        _anzeigen(buchstabe_F);
      break;
      
      case 'G':
        _anzeigen(buchstabe_G);
      break;
                  
      case 'H':
        _anzeigen(buchstabe_H);
      break;
      
      case 'I':
        _anzeigen(buchstabe_I);
      break;
      
       case 'J':
        _anzeigen(buchstabe_J);
      break;
      
       case 'K':
        _anzeigen(buchstabe_K);
      break;
      
      case 'L':
        _anzeigen(buchstabe_L);
      break;
      
      case 'M':
        _anzeigen(buchstabe_M);
      break;
                  
      case 'N':
        _anzeigen(buchstabe_N);
      break;
            
      case 'O':
        _anzeigen(buchstabe_O);
      break;
      
       case 'P':
        _anzeigen(buchstabe_P);
      break;
      
      case 'Q':
        _anzeigen(buchstabe_Q);
      break;
      
      case 'R':
        _anzeigen(buchstabe_R);
      break;
      
      case 'S':
        _anzeigen(buchstabe_S);
      break;
      
      case 'T':
        _anzeigen(buchstabe_T);
      break;
      
      case 'U':
        _anzeigen(buchstabe_U);
      break;
      
      case 'V':
        _anzeigen(buchstabe_V);
      break;
      
      case 'W':
        _anzeigen(buchstabe_W);
      break;
      
      case 'X':
        _anzeigen(buchstabe_X);
      break;
      
      case 'Y':
        _anzeigen(buchstabe_Y);
      break;
      
      case 'Z':
        _anzeigen(buchstabe_Z);
      break;
      
      case '.':
        _anzeigen(sonderzeichen_punkt);
      break;
      
      case ' ':
        _anzeigen(space);
      break;
      
      case 'n':
        _anzeigen(ingo);
      break;
      */
      
    }
  }
    //delay(2000);
}

//void _anzeigen(const PROGMEM byte buchstabe[]){
  
void _anzeigen(byte Spalte_1, byte Spalte_2, byte Spalte_3, byte Spalte_4, byte Spalte_5, byte Spalte_6){
  int stripe_nummer = 0;
  for(int i=6; i> -1; i--){
      byte readed_bit = bitRead(Spalte_1, i);
      _pixelset(readed_bit, stripe_nummer);  
     stripe_nummer = stripe_nummer + 1;
    }
  for(int j=0; j<num_spalten; j++){  
    stripes[j].show();
  }
  _farbwechsel(modus_spaltenfarbuebergang);
  _einruecken();
  delay(verzoegerung);
  
  stripe_nummer = 0;
  for(int i=6; i> -1; i--){
      byte readed_bit = bitRead(Spalte_2, i);
      _pixelset(readed_bit, stripe_nummer);  
     stripe_nummer = stripe_nummer + 1;
    }
  for(int j=0; j<num_spalten; j++){  
    stripes[j].show();
  }
     _farbwechsel(modus_spaltenfarbuebergang);
  _einruecken();
  delay(verzoegerung);
  
  stripe_nummer = 0;
  for(int i=6; i> -1; i--){
      byte readed_bit = bitRead(Spalte_3, i);
      _pixelset(readed_bit, stripe_nummer);  
     stripe_nummer = stripe_nummer + 1;
    }
  for(int j=0; j<num_spalten; j++){  
    stripes[j].show();
  }
     _farbwechsel(modus_spaltenfarbuebergang);
  _einruecken();
  delay(verzoegerung);
  
  stripe_nummer = 0;
  for(int i=6; i> -1; i--){
      byte readed_bit = bitRead(Spalte_4, i);
      _pixelset(readed_bit, stripe_nummer);  
     stripe_nummer = stripe_nummer + 1;
    }
  for(int j=0; j<num_spalten; j++){  
    stripes[j].show();
  }
  _farbwechsel(modus_spaltenfarbuebergang);
  _einruecken();
  delay(verzoegerung);
  
  stripe_nummer = 0;
  for(int i=6; i> -1; i--){
      byte readed_bit = bitRead(Spalte_5, i);
      _pixelset(readed_bit, stripe_nummer);  
     stripe_nummer = stripe_nummer + 1;
    }
  for(int j=0; j<num_spalten; j++){  
    stripes[j].show();
  }
  _farbwechsel(modus_spaltenfarbuebergang);
  _einruecken();
  delay(verzoegerung);
  
  stripe_nummer = 0;
  for(int i=6; i> -1; i--){
      byte readed_bit = bitRead(Spalte_6, i);
      _pixelset(readed_bit, stripe_nummer);  
     stripe_nummer = stripe_nummer + 1;
    }
  for(int j=0; j<num_spalten; j++){  
    stripes[j].show();
  }
     _farbwechsel(modus_spaltenfarbuebergang);
  _einruecken();
  delay(verzoegerung);
  
  
  
}

void _pixelset(byte bit_status, int stripe_nummer){
   _farbwechsel(modus_spaltenfarbwechsel);

    _farbwechsel(modus_pixelfarbwechsel);
   if(bit_status == 1){ //Wenn der ausgelesene Bit gleich eins ist, dann...
     stripes[stripe_nummer].setPixelColor(NUMPIXELS - 1, stripes[stripe_nummer].Color(rot_an, gruen_an, blau_an));
   }  
   else{// Wenn der ausgelesene Bit nicht eins ist, dann
     stripes[stripe_nummer].setPixelColor(NUMPIXELS - 1, stripes[stripe_nummer].Color(rot_aus, gruen_aus, blau_aus));
   }  
  
}


  
  
  
/*
void _anzeigen(const PROGMEM byte buchstabe[]){
  //for(int i=0; i<num_spalten; i++){
    
    for(int i=0; i<num_spalten; i++){
    
      _farbwechsel(modus_spaltenfarbwechsel);
      _farbwechsel(modus_spaltenfarbuebergang);
      
      int var = 0; //Zählervariable für die Stripe-Nummer die angesprochen wird
      for(int j=6; j> -1; j--){ // Es wird an einer niedrigeren Position angefangen zu zählen, da.... bla... irgendwas
        
        _farbwechsel(modus_pixelfarbwechsel);
        
        //Serial.println(bitRead(pgm_read_byte(buchstabe[i]), j));
        //delay( 200 );
        
         if(bitRead(pgm_read_byte(&buchstabe+i), j) == 1){
         //if(bitRead(buchstabe[i], j) == 1){ //Wenn der ausgelesene Bit gleich eins ist, dann...
           stripes[var].setPixelColor(NUMPIXELS - 1, stripes[var].Color(rot_an, gruen_an, blau_an));
         }  
         else{// Wenn der ausgelesene Bit nicht eins ist, dann
           stripes[var].setPixelColor(NUMPIXELS - 1, stripes[var].Color(rot_aus, gruen_aus, blau_aus));
         }  
        var = var + 1;
      }
      stripes[i].show();
      _einruecken();
      
      delay(verzoegerung);
     }
}

*/

void _farbwechsel(int modus){

  switch(modus){
      case 1://buchstabe
        rot_an = random(0, 255);
        gruen_an = random(0, 255);
        blau_an = random(0, 255);
      break;
      
      case 2://spalte
        rot_an = random(0, 255);
        gruen_an = random(0, 255);
        blau_an = random(0, 255);
      break;
      
      case 3://pixel
        rot_an = random(0, 255);
        gruen_an = random(0, 255);
        blau_an = random(0, 255);
      break;
      
      case 4://spalte farbwechsel
        
        //Serial.print(rot_an);
        //Serial.print("\t");
        //delay(10);
        
        if(rot_an == 255 && blau_an == 0){
          if(gruen_an < 255){
            gruen_an = gruen_an + 15;
          }
        }
        
        if(gruen_an == 255){
          if(rot_an > 0){
            rot_an = rot_an - 15;
          }
        }
        
        if(rot_an == 0){
          if(blau_an < 255){
            blau_an = blau_an + 15;
          }
        }
        
        if(blau_an == 255){
          if(gruen_an > 0){
            gruen_an = gruen_an - 15;
          }
        }
        
        if(gruen_an == 0){
          if(rot_an < 255){
            rot_an = rot_an + 15;
            
          }
        }      
        
        if(rot_an == 255 && gruen_an == 0 && blau_an > 0){      
            blau_an = blau_an - 15;
        }
      break;
    }
}


void _einruecken(){
  for(int i=0; i<num_stripes; i++){
     for(int j=0; j<NUMPIXELS; j++){
       uint32_t color = stripes[i].getPixelColor(j + 1);
       stripes[i].setPixelColor(j, color);
       //stripes[i].show();              
     }
  }
}


void f_helligkeit(int val_helligkeit){
  for(int i=0 ; i < num_stripes ; i++){
    stripes[i].setBrightness(val_helligkeit);
    //stripes[i].show();
  }  
}
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
29.04.2015, 17:16
Beitrag #30
RE: Laufschrift mit RGB-LEDs
(29.04.2015 16:53)scritch schrieb:  Ich habe mal meinen Lösungsansatz von vorhin verfolgt. Das funktioniert soweit, in guter Geschwindigkeit. Allerdings habe ich so das Problem, Dass ich die Spalten nicht nacheinander in einer Schleife verarbeiten kann. Hast du da einen Tipp?
Ja, versuche, meinen Loesungsansatz zum Laufen zu bringen. Es muss irgendwie gehen, PROGMEM Arrays an Funktionen zu uebergeben.

Falls ich mit einer Antwort helfen konnte, wuerde ich mich freuen, ein paar Fotos oder auch ein kleines Filmchen des zugehoerigen Projekts zu sehen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
29.04.2015, 20:04 (Dieser Beitrag wurde zuletzt bearbeitet: 29.04.2015 20:06 von scritch.)
Beitrag #31
RE: Laufschrift mit RGB-LEDs
So, habe auch deinen Lösungsansatz nochmal verfolgt und bin jetzt zu einem positiven Ergebnis gekommen. Es funktioniert nun wie es soll. Hier der Code.

Code:
#include <Adafruit_NeoPixel.h>

#define PIN_1 8//
#define PIN_2 2
#define PIN_3 3
#define PIN_4 4
#define PIN_5 5
#define PIN_6 6
#define PIN_7 9

#define NUMPIXELS      45 //vorerst für den Prototypen
#define num_spalten  7
#define num_stripes  7

Adafruit_NeoPixel stripe_1 = Adafruit_NeoPixel(NUMPIXELS, PIN_1, NEO_GRB + NEO_KHZ800);//die bezeichnung der Stripes kann verändert werden. so kann man diese auch in einer Zählerschleife ansprechen
Adafruit_NeoPixel stripe_2 = Adafruit_NeoPixel(NUMPIXELS, PIN_2, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel stripe_3 = Adafruit_NeoPixel(NUMPIXELS, PIN_3, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel stripe_4 = Adafruit_NeoPixel(NUMPIXELS, PIN_4, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel stripe_5 = Adafruit_NeoPixel(NUMPIXELS, PIN_5, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel stripe_6 = Adafruit_NeoPixel(NUMPIXELS, PIN_6, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel stripe_7 = Adafruit_NeoPixel(NUMPIXELS, PIN_7, NEO_GRB + NEO_KHZ800);

Adafruit_NeoPixel stripes[] = { stripe_1, stripe_2, stripe_3, stripe_4, stripe_5, stripe_6, stripe_7};

int modus_buchstabenfarbwechsel = 0; int modus_spaltenfarbwechsel = 0; int modus_pixelfarbwechsel = 0; int modus_spaltenfarbuebergang = 0;
int modus_text = 0; // ist für den Moduswechsel damit man z. B. über den seriellen Port den Text (vorher im µController gespeichert) wechseln kann
int arraylaenge = 0; // beinhaltet die Länge des Arrays des Textes
int rot_an = 255; int gruen_an = 0; int blau_an = 0; //Die Farben der LEDs welche die Buchstaben darstellen
int rot_aus = 0; int gruen_aus = 0; int blau_aus = 0; //Die Farben der LEDs welche nicht die Buchstaben darstellen
int verzoegerung = 0; //ist die Verzögerung in ms, mit der die Schrift läuft. Je kleiner der Wert, desto schneller läuft sie.
//int f_helligkeit = 0; //Variable für die Helligkeit
int var = 0; //Zählervariable für die Stripe-Nummer die angesprochen wird
int v_einruecken = 0;
int stripe_nummer = 0;

byte Spalte_1; byte Spalte_2; byte Spalte_3; byte Spalte_4; byte Spalte_5; byte Spalte_6;
byte spalten[6] = {Spalte_1, Spalte_2, Spalte_3, Spalte_4, Spalte_5, Spalte_6};

const PROGMEM byte buchstabe_A[6] = {B0111111, B1000100, B1000100, B1000100, B0111111, B0000000};
const PROGMEM byte buchstabe_B[6] = {B1111111, B1001001, B1001001, B1001001, B0110110, B0000000};
const PROGMEM byte buchstabe_C[6] = {B0111110, B1000001, B1000001, B1000001, B0100010, B0000000};
const PROGMEM byte buchstabe_D[6] = {B1111111, B1000001, B1000001, B0100010, B0011100, B0000000};
const PROGMEM byte buchstabe_E[6] = {B1111111, B1001001, B1001001, B1001001, B1000001, B0000000};
const PROGMEM byte buchstabe_F[6] = {B1111111, B1001000, B1001000, B1001000, B1000000, B0000000};
const PROGMEM byte buchstabe_G[6] = {B0111110, B1000001, B1001001, B1001001, B0101111, B0000000};
const PROGMEM byte buchstabe_H[6] = {B1111111, B0001000, B0001000, B0001000, B1111111, B0000000};
const PROGMEM byte buchstabe_I[6] = {B0000000, B1000001, B1111111, B1000001, B0000000, B0000000};
const PROGMEM byte buchstabe_J[6] = {B0000010, B0000001, B1000001, B1111110, B1000000, B0000000};
const PROGMEM byte buchstabe_K[6] = {B1111111, B0001000, B0010100, B0100010, B1000001, B0000000};
const PROGMEM byte buchstabe_L[6] = {B1111111, B0000001, B0000001, B0000001, B0000001, B0000000};
const PROGMEM byte buchstabe_M[6] = {B1111111, B0100000, B0011000, B0100000, B1111111, B0000000};
const PROGMEM byte buchstabe_N[6] = {B1111111, B0010000, B0001000, B0000100, B1111111, B0000000};
const PROGMEM byte buchstabe_O[6] = {B0111110, B1000001, B1000001, B1000001, B0111110, B0000000};
const PROGMEM byte buchstabe_P[6] = {B1111111, B1001000, B1001000, B1001000, B0110000, B0000000};
const PROGMEM byte buchstabe_Q[6] = {B0111110, B1000001, B1000101, B1000010, B0111101, B0000000};
const PROGMEM byte buchstabe_R[6] = {B1111111, B1001000, B1001100, B1001010, B0110001, B0000000};
const PROGMEM byte buchstabe_S[6] = {B0110001, B1001001, B1001001, B1001001, B1000110, B0000000};
const PROGMEM byte buchstabe_T[6] = {B1000000, B1000000, B1111111, B1000000, B1000000, B0000000};
const PROGMEM byte buchstabe_U[6] = {B1111110, B0000001, B0000001, B0000001, B1111110, B0000000};
const PROGMEM byte buchstabe_V[6] = {B1111100, B0000010, B0000001, B0000010, B1111100, B0000000};
const PROGMEM byte buchstabe_W[6] = {B1111110, B0000001, B0001110, B0000001, B1111110, B0000000};
const PROGMEM byte buchstabe_X[6] = {B1100011, B0010100, B0001000, B0010100, B1100011, B0000000};
const PROGMEM byte buchstabe_Y[6] = {B1110000, B0001000, B0000111, B0001000, B1110000, B0000000};
const PROGMEM byte buchstabe_Z[6] = {B1000011, B1000101, B1001001, B1010001, B1100001, B0000000};
const PROGMEM byte sonderzeichen_punkt[6] = {B0000000, B0000011, B0000011, B0000000, B0000000, B0000000};

const PROGMEM  byte herz[6] = {B0011000, B0100100, B0010011, B0100100, B0011000, B0000000};
const PROGMEM  byte ingo[6] = {B0000100, B0110010, B0000010, B0110010, B0000100, B0000000};
const PROGMEM byte space[6] = {B0000000, B0000000, B0000000, B0000000, B0000000, B0000000};

char buchstabe = ' ';
char atext[255];

void setup() {
Serial.begin(9600);
stripe_1.begin();
stripe_2.begin();
stripe_3.begin();
stripe_4.begin();
stripe_5.begin();
stripe_6.begin();
stripe_7.begin();
}

void loop(){
  modus_buchstabenfarbwechsel = 0;//1 mit überggeben
  modus_spaltenfarbwechsel = 0;//2 übergeben
  modus_pixelfarbwechsel = 0;//3 übergeben
  modus_spaltenfarbuebergang = 4;//4 übergeben
  modus_text = 1;
  verzoegerung = 120; //
  f_helligkeit(100);
  
  switch(modus_text){
    case 1:
      arraylaenge = 46;
      strcpy(atext, "DIE FESTSTELLTASTE IST MEIN GROESSTER FREUND. ");

    break;
      
    case 2:
      arraylaenge = 26;
      strcpy(atext, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");

    break;
    
    case 3:
      arraylaenge = 3;
      strcpy(atext, "ABC");
    break;
  }
  
  for(int i=0; i<arraylaenge; i++){
    _farbwechsel(modus_buchstabenfarbwechsel);
      
    buchstabe = atext[i];
    switch(buchstabe){
      
      case '<':
       _anzeigen(herz);
      break;
      
      case 'A':
        _anzeigen(buchstabe_A);        
      break;
            
      case 'B':
        _anzeigen(buchstabe_B);
      break;
      
       case 'C':
        _anzeigen(buchstabe_C);
      break;
    
       case 'D':
        _anzeigen(buchstabe_D);
      break;
                
      case 'E':
        _anzeigen(buchstabe_E);
      break;
                  
      case 'F':
        _anzeigen(buchstabe_F);
      break;
      
      case 'G':
        _anzeigen(buchstabe_G);
      break;
                  
      case 'H':
        _anzeigen(buchstabe_H);
      break;
      
      case 'I':
        _anzeigen(buchstabe_I);
      break;
      
       case 'J':
        _anzeigen(buchstabe_J);
      break;
      
       case 'K':
        _anzeigen(buchstabe_K);
      break;
      
      case 'L':
        _anzeigen(buchstabe_L);
      break;
      
      case 'M':
        _anzeigen(buchstabe_M);
      break;
                  
      case 'N':
        _anzeigen(buchstabe_N);
      break;
            
      case 'O':
        _anzeigen(buchstabe_O);
      break;
      
       case 'P':
        _anzeigen(buchstabe_P);
      break;
      
      case 'Q':
        _anzeigen(buchstabe_Q);
      break;
      
      case 'R':
        _anzeigen(buchstabe_R);
      break;
      
      case 'S':
        _anzeigen(buchstabe_S);
      break;
      
      case 'T':
        _anzeigen(buchstabe_T);
      break;
      
      case 'U':
        _anzeigen(buchstabe_U);
      break;
      
      case 'V':
        _anzeigen(buchstabe_V);
      break;
      
      case 'W':
        _anzeigen(buchstabe_W);
      break;
      
      case 'X':
        _anzeigen(buchstabe_X);
      break;
      
      case 'Y':
        _anzeigen(buchstabe_Y);
      break;
      
      case 'Z':
        _anzeigen(buchstabe_Z);
      break;
      
      case '.':
        _anzeigen(sonderzeichen_punkt);
      break;
      
      case ' ':
        _anzeigen(space);
      break;
      
      case 'n':
        _anzeigen(ingo);
      break;
      
      
    }
  }
}


void _anzeigen(const PROGMEM byte buchstabe[]){
    
  int v_char_array_count = 0; //Zählervariable für Fehlereliminierung
  v_einruecken = 0;
  for(int i=0; i<7; i++){
      _farbwechsel(modus_spaltenfarbwechsel);
      _farbwechsel(modus_spaltenfarbuebergang);
      
      var = 0;
      for(int j=6; j> -1; j--){ _farbwechsel(modus_pixelfarbwechsel);

        if(i < 6){
          v_char_array_count = i;}
        
        if(bitRead(pgm_read_byte(&buchstabe[v_char_array_count]), j) == 1){ //Wenn der ausgelesene Bit gleich eins ist, dann...
           stripes[var].setPixelColor(NUMPIXELS - 1, stripes[var].Color(rot_an, gruen_an, blau_an));
        }  
        else{// Wenn der ausgelesene Bit nicht eins ist, dann
           stripes[var].setPixelColor(NUMPIXELS - 1, stripes[var].Color(rot_aus, gruen_aus, blau_aus));
        }  
        var = var++;
      }

      for(int i=0; i<num_spalten; i++){
        stripes[i].show();
      }
      
      v_einruecken = v_einruecken++;
  
      if(v_einruecken < 7){ _einruecken();
        delay(verzoegerung);
      }
    }
}



void _farbwechsel(int modus){

  switch(modus){
      case 1://buchstabe
        rot_an = random(0, 255);
        gruen_an = random(0, 255);
        blau_an = random(0, 255);
      break;
      
      case 2://spalte
        rot_an = random(0, 255);
        gruen_an = random(0, 255);
        blau_an = random(0, 255);
      break;
      
      case 3://pixel
        rot_an = random(0, 255);
        gruen_an = random(0, 255);
        blau_an = random(0, 255);
      break;
      
      case 4:
        if(rot_an == 255 && blau_an == 0){
          if(gruen_an < 255){
            gruen_an = gruen_an + 15;
          }
        }
        
        if(gruen_an == 255){
          if(rot_an > 0){
            rot_an = rot_an - 15;
          }
        }
        
        if(rot_an == 0){
          if(blau_an < 255){
            blau_an = blau_an + 15;
          }
        }
        
        if(blau_an == 255){
          if(gruen_an > 0){
            gruen_an = gruen_an - 15;
          }
        }
        
        if(gruen_an == 0){
          if(rot_an < 255){
            rot_an = rot_an + 15;
            
          }
        }      
        
        if(rot_an == 255 && gruen_an == 0 && blau_an > 0){      
            blau_an = blau_an - 15;
        }
      break;
    }
}

void _einruecken(){
  for(int i=0; i<num_stripes; i++){
     for(int j=0; j<NUMPIXELS; j++){
       uint32_t color = stripes[i].getPixelColor(j + 1);
       stripes[i].setPixelColor(j, color);  
     }
  }
}

void f_helligkeit(int val_helligkeit){
  for(int i=0 ; i < num_stripes ; i++){
    stripes[i].setBrightness(val_helligkeit);
    //stripes[i].show();
  }  
}

Danke nochmal für deine Tipps. Bin heute wieder ein ganzes Stück weit schlauer geworden. Für morgen ist der Bau der eigentlichen Lauflichttafel geplant mit 315 LEDs gesamt. Ist die soweit lauffähig, gibts davon natürlich auch wieder ein kleines Video Smile
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
30.04.2015, 15:11 (Dieser Beitrag wurde zuletzt bearbeitet: 30.04.2015 15:46 von scritch.)
Beitrag #32
RE: Laufschrift mit RGB-LEDs
Wie versprochen, hier das Video und die Hardware zum Code: https://www.youtube.com/watch?v=bRqMj8Ul...e=youtu.be
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Pulsierende LEDs KBLc 4 186 20.10.2016 22:35
Letzter Beitrag: hotsystems
  WS2812 Helligkeit einzelner LEDs steuern mavericklp 3 660 11.03.2016 09:32
Letzter Beitrag: torsten_156
  Leds blinken lassen mit if-Abfrage und millis ferdi 11 1.521 24.10.2015 08:54
Letzter Beitrag: Bitklopfer
  RGB Wechsler - LEDs flackern Sesselmann 3 1.359 22.05.2015 17:07
Letzter Beitrag: Sesselmann
  Switch Case, LEDs bleiben an, Bedingung aber falsch luto92 4 1.446 16.11.2014 16:52
Letzter Beitrag: luto92
Brick Taster und Leds Hilfe bei dem Code max800000 8 2.587 21.07.2014 12:20
Letzter Beitrag: fp.blues2013
  Wie LEDs durch Taster schalten Alessandra 1 1.615 05.01.2014 16:50
Letzter Beitrag: derdemo
  Laufschrift auf SainSmart LCD Keypad Shield wally57214 6 8.273 27.12.2013 20:32
Letzter Beitrag: kraweuschuasta

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste