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
28.04.2015, 21:35
Beitrag #17
RE: Laufschrift mit RGB-LEDs
Hallo lieber Namensfetter. Was meinst du mit "entgültiges Listing"? Den fertigen Code? Wenn du das meinst: Der ist noch nicht wirklich fertig. Das gezeigte im Video ist auch bloß ein Prototyp mit 7 Zeilen. in seiner fertigen Version soll das ganze über 45 Zeilen gehen. Ich habe es heute mal ausprobiert und die Passage im Code geändert. Der µController scheint da an seine Grenzen zu stoßen (Arduino Uno). Das nervt mich gerade richtig. Ich hatte es insgeheim zwar bereits befürchtet, aber irgendwie nicht wahrhaben wollen. Mit 45 Spalten läuft das ganze gar nicht. Mit 40 läuft es zwar, aber alles andere als zufriedenstellend Sad Es ist ja so, dass nach dem aufleuchten lassen des jeweils letzten Pixels pro LED-Streifen, jeder Status jeder LED auf die benachbarte LED "Kopiert" wird. Das braucht viel zu viel Zeit, sodass das "Schieben" aller Buchstaben von rechts nach links nicht mehr geschmeidig aussieht (siehe Video):
https://youtu.be/AeRVQHZd6Fs
Ich stelle mir nun die Frage, wie ich das beheben könnte. Kann ich es mir einfach machen und mir einen µController holen, der mehr MHz hat? Der Uno hat ja bloß 16MHz. Der Arduino Due hätte ja z. B. 84MHz, könnte der das in akzeptabler Geschwindigkeit packen, oder ist das gar nicht die CPU die hier limitiert?
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
29.04.2015, 04:46
Beitrag #18
RE: Laufschrift mit RGB-LEDs
Hallo und Danke für die Antwort. Das Listing von der im Video gezeigten "Testversion" wäre schon ganz nett gewesen. Zum Prozessor: Man bekommt schon für rd. 20-25 € einen Raspberry - vielleicht wäre das eine Alternative... - oder einen Banana -

Wäre schön wenn man weiter von den sehr interessanten Projekt was zu lesen bakommt.

Gruß Ingo

Raspberry P2 mit 900 Mhz und 1 GB NEU für 38,- € gibt es hier http://www.elv.de/raspberry-pi-2-b-1-gb....tAodATIAhQ
..der packt das ganz sicher.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
29.04.2015, 08:51 (Dieser Beitrag wurde zuletzt bearbeitet: 29.04.2015 08:55 von scritch.)
Beitrag #19
RE: Laufschrift mit RGB-LEDs
Das wäre natürlich eine Alternative. Aber kann ich das denn wie einen normalen µController auch ganz normal mit Code versorgen? Ich weiss leider immernoch nicht was du mit Listing meinst. Außerdem weiß ich auch nicht 100%ig ob meine Problematik an zu wenig Leistung liegt.

Edit: Thorsten hatte zum Anfang (da hatte ich es mit 50 LEDs vor) schon Bedenken geäußert. "Die Adafruit-Lib wird für 50*7 LEDs schon 50*7*3 = 1050 Byte brauchen". Evt. liegt es auch daran?
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
29.04.2015, 09:33
Beitrag #20
RE: Laufschrift mit RGB-LEDs
(29.04.2015 08:51)scritch schrieb:  Außerdem weiß ich auch nicht 100%ig ob meine Problematik an zu wenig Leistung liegt.
Ich glaube nicht. Ich denke, dass das eher an ungeschickter Programmierung liegt. Stell mal Dein Coding hier rein, dann kann man vielleicht was sagen.

Zitat:Edit: Thorsten hatte zum Anfang (da hatte ich es mit 50 LEDs vor) schon Bedenken geäußert. "Die Adafruit-Lib wird für 50*7 LEDs schon 50*7*3 = 1050 Byte brauchen". Evt. liegt es auch daran?
Nein, das wuerde dann eher zu kompletten Freezes fuehren oder anderen seltsamen Effekten. Wenn man das Video anschaut, dann funktioniert ja alles, nur eben etwas langsam.
...aber wie gesagt: Zeig mal das Programm.

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, 10:35 (Dieser Beitrag wurde zuletzt bearbeitet: 29.04.2015 10:36 von scritch.)
Beitrag #21
RE: Laufschrift mit RGB-LEDs
Zitat:Edit: Thorsten hatte zum Anfang (da hatte ich es mit 50 LEDs vor) schon Bedenken geäußert. "Die Adafruit-Lib wird für 50*7 LEDs schon 50*7*3 = 1050 Byte brauchen". Evt. liegt es auch daran?
Nein, das wuerde dann eher zu kompletten Freezes fuehren oder anderen seltsamen Effekten. Wenn man das Video anschaut, dann funktioniert ja alles, nur eben etwas langsam.
...aber wie gesagt: Zeig mal das Programm.
[/quote]
Wenn ich 45 LEDs definiere, funktioniert es auch gar nicht mehr. 40 sind die absolute Grenze. Hier der aktuelle Code. Das Einrücken, was nicht mehr so performant ist, übernimmt die letzte Funktion. Nicht von dem Umfang des Codes erschlagen lassen, in vielen Zeilen geht es nur um die Buchstaben:

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

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 num_spalten = 6;
int num_stripes = 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};

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

byte herz[6] = {B0011000, B0100100, B0010011, B0100100, B0011000, B0000000};
byte ingo[6] = {B0000100, B0110010, B0000010, B0110010, B0000100, B0000000};
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 = 1; //
  f_helligkeit(100);
  
  switch(modus_text){
    case 1:
      arraylaenge = 46;
      strcpy(atext, "DIE FESTSTELLTASTE IST MEIN GROESSTER FREUND. ");
    break;
      
    case 2:
      arraylaenge = 5;
      strcpy(atext, "DEFGH");

    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(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);
        
         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));
           stripes[var].show();
         }  
         else{// Wenn der ausgelesene Bit nicht eins ist, dann
           stripes[var].setPixelColor(NUMPIXELS - 1, stripes[var].Color(rot_aus, gruen_aus, blau_aus));
           stripes[var].show();
         }  
        var = var + 1;
      }
      _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();
  }  
}
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
29.04.2015, 10:45
Beitrag #22
RE: Laufschrift mit RGB-LEDs
Hi,
Dein Hauptproblem ist, dass Du stripes[var].show() nach jeder Aenderung aufrufst. Das kostet ein bisschen zu viel Zeit. Aendere das mal so ab, dass es moeglichst selten gemacht wird. D.h. werfe alle (!) stripes.show-Aufrufe raus und rufe das show fuer alle Stripes vor dem delay in _anzeigen auf.
Das sollte das Problem mit dem Ruckeln beheben.
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, 11:05
Beitrag #23
RE: Laufschrift mit RGB-LEDs
Ich sage mal so: Ich habe das Bedürfnis dir ein Bier auszugeben. Das war (jedenfalls zum Teil) die Lösung. Jetzt läuft es in der gewünschten Geschwindigkeit. Allerdings habe ich weiterhin das Problem, dass ich nicht mehr als 40 LEDs pro Stripe ansteuern kann. Definiere ich die avisierten 45 Pixel pro Stripe, passiert einfach gar nichts mehr.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
29.04.2015, 11:12
Beitrag #24
RE: Laufschrift mit RGB-LEDs
Hi,
das mit dem Bier koennen wir machen, schick mir mal per PN wo Du Dich normalerweise so aufhaeltst...
Dein Programm geht recht verschwenderisch mit dem dem SRAM um. Ich wuerde mal die zwei folgenden Massnahmen treffen:
1. Alle "Variablen", die sich nie aendern in #define s aendern.
2. Deine Buchstaben gehoeren ins PROGMEM. Such Dir mal raus, wie das geht.
3. Alle Zeichenketten-Konstanten sollten mit F(...) angelegt werden
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
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 658 11.03.2016 09:32
Letzter Beitrag: torsten_156
  Leds blinken lassen mit if-Abfrage und millis ferdi 11 1.515 24.10.2015 08:54
Letzter Beitrag: Bitklopfer
  RGB Wechsler - LEDs flackern Sesselmann 3 1.354 22.05.2015 17:07
Letzter Beitrag: Sesselmann
  Switch Case, LEDs bleiben an, Bedingung aber falsch luto92 4 1.444 16.11.2014 16:52
Letzter Beitrag: luto92
Brick Taster und Leds Hilfe bei dem Code max800000 8 2.584 21.07.2014 12:20
Letzter Beitrag: fp.blues2013
  Wie LEDs durch Taster schalten Alessandra 1 1.613 05.01.2014 16:50
Letzter Beitrag: derdemo
  Laufschrift auf SainSmart LCD Keypad Shield wally57214 6 8.267 27.12.2013 20:32
Letzter Beitrag: kraweuschuasta

Gehe zu:


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