Show Posts
Pages: 1 ... 3 4 [5] 6 7 ... 20
61  International / Deutsch / Re: 3kW Heizung, Leistung regulieren und messen on: January 15, 2014, 03:34:39 pm
Quote
Mit RMS kannst du nicht rechnen, weil das so aussieht:

Wem soll ich den nun glauben jurs hatte mir versichert:
Quote
Der Code dient zur Berechnung des "Effektivwerts" eines Signals durch Abtastung in gleichen Zeitabständen und ist unabhängig vom zeitlichen Verlauf des Signals. Das Signal kann Rechteck, Sinus, Phasenanschnitt, Phasenabschnitt, Sägezahn, Schmetterling oder sonstwas sein. Die Messwerte werden gesampelt und der "geometrische Mittelwert" der Messwerte als Effektivwert errechnet.

Quote
was möchtest Du denn messen? Die Wirkleistung?

Ja die Wirkleistung.

Wie ich das verstanden hab scheint die Vollwellensteuerung am einfachsten.

Ich hab ein SSR aber ich weiß nicht ob das geeignet ist.
Ich glaub das war das hier: http://www.ebay.de/itm/Solid-State-Relais-SSR-Halbleiterrelais-25A-/300815330704?pt=Elektromechanische_Bauelemente&hash=item4609fdad90
62  International / Deutsch / 3kW Heizung, Leistung regulieren und messen on: January 15, 2014, 11:57:19 am
Hallo,

ich will mich wieder daran wagen, habs ja schon paar mal hier versucht. Aber ich hing glaube ich zu sehr an meiner Sache fest und habe auf nichts anderes gehört. Ich will noch mal von vorne Anfangen und hoffe mir wird trotzdem geholfen.

Ich möchte eine 3 kW Heizung(ohmscher Wiederstand) anhand der Leistung regeln können und diese auch messen können.

Bisher habe ich die Heizung mit dem Kemo M028(Phasenanschnittregler) reguliert. Das signal was darauf gebe ist wächst nicht proportional. zB. sind 90% genauso wie 100% und 50% sind nicht 50%.
Um die Leistung zu messen, habe ich es bisher mit dem ACS712 20A-Version versucht. Der kann den Strom messen und den verrechne ich denn mit dem Wiederstand R zur Leistung.

Aber die Messungen sind halt leider nicht richtig. (hab RMS-Formel verwendet)

Also kann ich die Leistung nicht Richtig einstellen und mit der Messungen kann ich es auch nicht vergleichen da diese fehlerhaft sind.

Nun wurden mir zuvor ja schon Vorschläge gemacht von Uwe eine Vollwellensteuerung zu verwenden oder von jurs mit einer SSR-Relais Taktung(hatte aber auch nicht geklappt).

Welche dieser Varianten ist besser und mit dem ACS712 gut messbar? Könnte ich nicht auch mit nem Traffo der die Wechselspannung auf höchsten 5V senkt und diese denn am analogPin messen?

Wie soll ich jetzt vorgehen.

Bitte steigert euch nicht wieder in den Grund des ganzen rein.
Ich kann echt leider nicht sagen wofür das ist.
Fest steht das ich die Leistung(nicht Temperatur) regulieren will und diese auch messen will. Stellt euch zB. vor ich brauche mal eine 3kW Heizung und mal eine mit 1kW(und andere Werte). Es ist 100% gewollt das ich nach der Leistung reguliere und nicht Temperatur.

Gruß

strohhirn
63  International / Deutsch / Re: LED Laufleiste mit Arduino steuern on: January 05, 2014, 02:48:26 pm
Code:
XXX..X...X.XXXXX.XXXX..XXXXX.X...X........................
...X.X...X.X.....X...X...X...X...X........................
...X.X...X.X.....X...X...X....X.X.........................
...X.X.X.X.XXXX..XXXX....X.....X..........................
.X.X.X.X.X.X.....X.X.....X.....X..........................
..X..XX.XX.X.....X..X....X.....X..........................
XX.X.X...X.XXXXX.X...X...X.....X..........................

Ja genau so sah das aus.

Hab den neuen sketch durchprobiert.

Alles klappt wunderbar. Auch "Der absolute Killer Test ".  smiley-lol
Das mit den OPTIMIZE_CHARS funktioniert auch.
LEFT und CENTER sind jetzt auch richtig.
Die Sekunden bei Duration stimmen auch.(Zeit gestoppt)
Die Pause mit den Leerzeichen klappt auch.
Damit kann ich auch zB ein Blinken erzeugen (gewollt):
Code:
{ 1, notMoving, CENTER, 1, DEFAULT_SPEED },
  { 5, notMoving, CENTER, .1, DEFAULT_SPEED }, // Leerzeichen

Das freut mich riesig das so viel klappt smiley-grin

Nun wäre es eig. nur noch toll wenn man ein Wort reinscrollen könnte und es links/rechts/mittig stehen bleiben könnte und danach rausgescrollt wird oder verschwindet.

Ein Wort das zu groß ist wird abgeschnitten, wäre schön wenn man es hin und her scrollen könnte und endlos. Also so das der abgeschnittene teil beim scrollen auch erscheint.

Gruß

strohhrin

64  International / Deutsch / Re: LED Laufleiste mit Arduino steuern on: January 04, 2014, 01:55:54 pm
Habs jetzt mit SPI versucht, es ist kein sichtbarer Unterschied bemerkbar, außer das es fehlerhaft ist.
Der schiebt das Wort nicht von links ein sondern es taucht ein paar Zeilen weiter auf und wenn er etwas rechts rauscrollt kommt es links glaube ich wieder.

Quote
CENTER darfst du bei den Scroll Modi gar nicht verwenden.

Das tuh ich auch garnicht, das ist mir klar.

Bei Center habe ich jetzt mal statt +1, +2 geschrieben. Nun sind die Wörter mittig.

Code:
else if(_currentOrientation == CENTER)
    shiftDisplayRight((NUMBER_OF_LEDS - columns + 2) / 2);

Wo ich LEFT berichtigen kann habe ich nicht gefunden.

Quote
Wenn du da in der if-Abfrage noch mal -1  machst sollte er eins eher aufhören.

Das tut es auch, aber es beginnt immer noch mit 1 Spalte zu wenig. Wenn es dann hin und her geht klappts sauber.

Quote
Das ganze mit den Strings und Modi wird sich eh noch ändern. Ich habe es jetzt so:

...

Wenn du das anders willst, sag es jetzt smiley

Mach mal wie du es für richtig hälst, hauptsache ich verstehe es nachher einigermassen und es klappt. smiley

Gruß

strohhirn
65  International / Deutsch / Re: LED Laufleiste mit Arduino steuern on: January 03, 2014, 02:43:26 pm
OK, hab den sketch grad wieder durch probiert.

Mir ist aufgefallen das LEFT und CENTER 1 Spalte zu weit Links ist. Das ist auch bei scrollBackAndForth, da links ein Spalte vom Buchstaben herausgeschoben wird, taucht aber wieder auf wenns wieder nach rechts geht.

Ansonsten funktioniert alles schön und sauber.

Aber wie wechsel ich jetzt im loop den String,Modus,...?
Hab versucht folgendes im loop einzufügen, denn wurde aber garnichts mehr angezeigt:
Code:
_currentStringIndex = 1;
_currentMode(true);

Wollte es auch mit SPI versuchen, aber der Kompiler schreibt too few arguments to function 'void switchTransistorSPI(byte)'.

Übrigens, wieso hast du Serial.begin(115200); verwendet? ich muss die zahl auf 9600 ändern da ansonsten nur undefinierte zeichen kommen.

Wie schaffe ich es nun z.B ein Wort reinzuscrollen und für ne bestimmte Zeit links,rechts oder mittig stehen zu lassen?

Gruß

strohhirn
66  International / Deutsch / Re: LED Laufleiste mit Arduino steuern on: January 02, 2014, 12:53:24 pm
Quote
Quote
Das Wort wird um eine Spalte verschoben. Danach wird eine Zeile des Wortes gezeigt und und danach wird das Wort wieder geschoben.
Mhhh, bei mir gings eigentlich. Oder es war irgendein Bug drin. smiley-sad

Das ist aber nur wenn #define DEBUG  nicht auskommentiert ist.

Wenn ich es auskommentiere funktioniert das zwar ohne Seriel Monitor, aber dafür einwandfrei.
Ist doch nicht so schlimm wird doch nachher eh ohne laufen.

Quote
Wie hast du dir das eigentlich gedacht? Alle Texte fest definiert wenn es kompiliert wird?

Ich habe mir gedacht das das nacher fest festgelegt ist. zB:
Ein Satz wird reingescrollt, danach werden ein paar Worte rein gescrollt, die jeweils in der Mitte ne zeitlang stehen bleiben.
So in die Richtung.
67  International / Deutsch / Re: LED Laufleiste mit Arduino steuern on: January 02, 2014, 05:24:38 am
Hab ihn jetzt getestet:

War anfangs warum nichts geht, ich dachte den Seriel Monitor kann man alternativ zuschalten, aber ohne den startet nichts.
Mit ihm läuft die Schrift aber Fehlerhaft:
Das Wort wird um eine Spalte verschoben. Danach wird eine Zeile des Wortes gezeigt und und danach wird das Wort wieder geschoben.

Quote
Phase change @4887

Sollen das eig. die vergangenen nanoSekunden ?

Ohne Debug läuft das sauber.
Alles funktioniert CENTER, scrollSimple, ...

Nur wenn das Wort zu groß für das Display ist passiert nichts. Das müsste man noch hinkriegen und das, das Wort rein scrollt.
Der Idee nach muss das Wort doch Spalte für Spalte rein geschoben werden und denn Nullen hinterher, richtig?

Quote
Du sagst, dass du kein Flimmern mehr hast und die Animation flüssig geht. Wie sieht es mit der Helligkeit aus?

Ne ist eig. kein Flimmern zu sehen und die Animation ist flüssig. Die Helligkeit ist auch gut.

Du hast dich aber auch mit diesen nanoSekunden beschäftigt. smiley Eig. gibt es keine Probleme, aber wenn du willst kann ich ja mal deine Verschnellerungen ausprobieren.

Nun ist das Wort ja global deklariert, wie verwende ich im loop den jetzt zB. mehrere verschiedene Wörter?
68  International / Deutsch / Re: LED Laufleiste mit Arduino steuern on: December 30, 2013, 06:30:58 am
Hab das jetzt installiert. Wenn ich den kleinen Testcode in eine Leere datei einfüge kompilliert er, aber wenn ich es in den aktuellen Code einfüge gibt er mir zich Fehler aus zB: reference to 'advance' is ambiguous
Muss wohl irgendwo in der Library enthalten sein.

Was soll ich nun machen? Seh garnicht durch was das ist und was man damit macht?
Was muss jetzt am code geändert werden?

69  International / Deutsch / Re: LED Laufleiste mit Arduino steuern on: December 29, 2013, 08:27:34 am
Quote
Sorry, da ist ein Schreib-Fehler drin. Das muss "str" statt "star" heißen. Dann sollte er auch den übergebenen String finden

Ja das wars, jetzt kann ich das Wort wieder im loop deklariren.

Quote
Da bin ich glaube ich Opfer von Punkt-vor-Strich geworden. Sollte eher so sein (noch mal Klammern um die Linke Seite:
Wegen CENTER.
Hab die lösung ausprobiert und nun klapp es schon besser : beim vor TEST sind links 14 Spalten frei und rechts 22 Spalten
                                                                                                         beim Wort HALLO links 10, rechts 20

Quote
Ja, sicher. Das beste wäre es sowieso den Text über Serial einzulesen. Dann kann man im Serial Monitor eintippen und es erscheint auf den LEDs. Da könnte man auch die Parameter wie Scrollgeschwindigkeit und Scroll-Versatz einstellbar machen.

Das könnte man evt. zum Schluss noch ausprobieren, aber eig. soll der Arduino nacher nicht mehr am Computer hängen, deswegen möchte ich erstmal (mit deiner Hilfe) das andere zum laufen bringen.

Quote
Du kannst vielleicht sowas machen:
Code:
char exclude[] = "!\":"

if(strchr(exclude, str) == NULL)
    //Nullen ausgeben

Wo soll ich das einfügen in den sketch?

Quote
Das mit dem Ausrufe-Zeichen kannst du auch etwas umgehen wenn du die Font-Definition ändert.

Da finde ich die erste Lösung besser weil das ja nicht nur beim Ausrufezeichen das Problem sondern auch bei einigen Buchstaben die in Wörtern stehen.

Quote
Wenn der Text links steht und er rausgescrolt wird dauert es eine weile bis es von vorne beginnt
(warsch. scrollt er weiter)
Aber das hast du ja nun korigiert.

Ich habe doch in der letzten Zeile geschrieben das, das gelöst ist, da du ja in deinem letzten EDIT folgendes geändert hast:
Code:
if(millis() - previousScrollMillis >= 100)
      {
             previousScrollMillis = millis();  
             scrollCount = scrollCount + advance;
             scrollCount = scrollCount % (NUMBER_OF_LEDS - getZerosFromOrientation(str, currentOrientation));
     }
Also mach dir da erstmal kein Kopf drum. smiley

Quote
Wie gesagt kann ich den Kram nicht wirklich testen. Ich habe nicht mal eine normale 8x8 Matrix hier. Ich mache das in Visual C++ und lass es mir auf der Konsole anzeigen (wie ein DOS Fenster). Das sieht dann so aus wie im Serial Monitor. Ich lasse mir da jede Phase der Animation in einer neuen Zeile anzeigen.

Mach dir doch bitte nicht so nen Kopf drum. Fehler sind nicht schlimm.
Allein die Tatsache das du dir die Mühe machst Nachzudenken und jemandem mit deinem Wissen zu helfen ist bemerkenswert und freut mich.
Zum prüfen habe ich ja die Hardware hier. Wenn was nicht klapp, dann schreib ich das und man kann es korrigieren.  

Hier nochmal der sketch nach aktuellstem stand:
Code:
#include <avr/pgmspace.h>

prog_uchar PROGMEM font[96][5] = {
        {0x00,0x00,0x00,0x00,0x00}, //
        ...      
};

int latchPin1 = 8;
int latchPin2 = 9;
int latchPin3 = 10;
int latchPin4 = 11;

int dataPin = 5;
int clockPin = 6;

unsigned long previousMultiplexMillis;
unsigned long previousScrollMillis = millis();
const int NUMBER_OF_LEDS = 59;
byte advance = 1;                  //um wieviele Pixel auf einmal gescrollt wird. 0 = kein Scrollen
byte startIndex = 36;             //der Anfang des Textes. Der Index fängt von links an. 0 = ganz links






void printRow(char* str, int row)
{
for(int i = 0; i < strlen(str); i++)       //iteriere über String
{
char currentCharacter = str[i] - 0x20;      //Adresse im Flash berechnen

for(int j = 0; j < 5; j++)       //iteriere über die 5 Bytes eines chars
{
byte currentByte = pgm_read_byte_near(&font[currentCharacter][j]);       //aktuelles Byte aus Flash lesen

if(currentByte & (1 << (7 - row)))    //das ist was bitRead() macht, aber man spart sich den Funktions-Aufruf, der auch wieder Zeit kostet. Ganz wichtig: hier nicht auf true abfragen!
{
    //Bit auf 1 setzen
    PORTD = PORTD | _BV(5);        //BV steht für bit value und setzt Bit 5 (B0010000). Das macht einfach (1 << 5). Mit dem Oder wird der Wert dann mit dem aktuellen Zustand des Ports zusammengeführt
}
else
{
    //Bit auf 0 setzen
    PORTD = PORTD & ~(_BV(5));      //Und mit der Negation (B11011111).
}

PORTD = PORTD ^ _BV(6);              //toggle Pin 6 Low -> High (^ ist ein XOR)
PORTD = PORTD ^ _BV(6);
}

PORTD = PORTD & ~(_BV(5));     //Leerzeichen zwischen Buchstaben
                PORTD = PORTD ^ _BV(6);              //toggle Pin 6 Low -> High (^ ist ein XOR)
                PORTD = PORTD ^ _BV(6);
}
}


void setup() {
  pinMode(latchPin1, OUTPUT);
  pinMode(latchPin2, OUTPUT);
  pinMode(latchPin3, OUTPUT);
  pinMode(latchPin4, OUTPUT);
  pinMode(dataPin, OUTPUT);
pinMode(clockPin, OUTPUT);
  Serial.begin(9600);
}

enum orientation { LEFT, CENTER, RIGHT };
orientation currentOrientation = RIGHT;      //diese Variable ändern um die Ausrichtung umzuschalten

/* liefert direkt die Anzahl der Nullen für jede Ausrichtung */
byte getZerosFromOrientation(char* str, byte orientation)
{
        if(orientation == LEFT)
            return NUMBER_OF_LEDS -1- strlen(str) * 5 - (strlen(str) - 1);
        else if(orientation == CENTER)
            return (NUMBER_OF_LEDS - (strlen(str) * 5 - (strlen(str) - 1))) / 2;
        else
             return 0;
}

/* Vielleicht mal nützlich wenn man den Index beliebig setzt */
byte getZerosFromStartIndex(char* str, byte startIndex)
{
    return NUMBER_OF_LEDS - startIndex - strlen(str) * 5 - (strlen(str) - 1);
}

void loop()
{      
      
char str[] = "HALLO";
orientation currentOrientation = CENTER;

      static byte scrollCount;
      static byte row;

       if(millis() - previousMultiplexMillis >= 1)
       {
                previousMultiplexMillis = millis();
            
                switchTransistorFast(7);           // Transistoren aus
                shiftZeros(NUMBER_OF_LEDS);
                
printRow(str, row);

                byte zeros = getZerosFromOrientation(str, currentOrientation);
                shiftZeros(zeros);
                shiftZeros(scrollCount);
  switchTransistorFast(row);
 row = (row + 1) % 7;
       }

      if(millis() - previousScrollMillis >= 100)
      {
             previousScrollMillis = millis();  
             scrollCount = scrollCount + advance;
             scrollCount = scrollCount % (NUMBER_OF_LEDS - getZerosFromOrientation(str, currentOrientation));
     }
}

void switchTransistorFast(byte transistor)
{
      if(transistor <= 6)
            PORTB = PORTB & 0xF0 | transistor;
      else
            PORTB = PORTB | 0x0F;             //alle aus = untere 4 Bits auf 1
}

void shiftZeros(int count)
{
     PORTD = PORTD & ~(_BV(5));  
    
     for(int i = 0; i < count; i++)
     {
           PORTD = PORTD ^ _BV(6);
           PORTD = PORTD ^ _BV(6);
     }
}




Gruß

strohhirn
70  International / Deutsch / Re: LED Laufleiste mit Arduino steuern on: December 28, 2013, 01:08:03 pm
Also das mit den Nullen davor und dahinter schieben klappt.(damit kann ich manuell die position des wortes festlegen)

Nur so nebenbei, ist mir aufgefallen, das wenn ich shiftZeros(i) in der for-schleife nach dem Einschieben setze, das die Schrift dann Kursiv ist oder schräg.

Die for-schleife hast du dadurch ersetzt richtig?:
Code:
row = (row + 1) % 7;

Die Letzte der 8 LED-Matrixen ist unvollständig und hat nur 3 Spalten, deswegen hat eine Zeile 59 LEDs.

Quote
Hier wäre es jetzt sehr schön wenn der CLR Eingang der SR herausgeführt wäre. Aber das ist glaube ich nicht der Fall. smiley-sad

Was meinst du damit?

Der Teil mit dem Scrollen und milles funktioniert auch
Je kleiner die Zahl in der flogenden Zeile umso schneller fährt der Text über den Bildschirm:
Code:
if(millis() - previousScrollMillis >= 1000) // je kleiner die Zahl umso schneller

Quote
Für den Wert von startIndex sollte folgendes gelten:
linksbündig -> 0
rechtsbündig -> NUMBER_OF_LEDS - strlen(str) * 5 - ((strlen(str) - 1)
mittig -> NUMBER_OF_LEDS - (strlen(str) * 5  - ((strlen(str) - 1)) / 2;

Das klappt nur Teilweise bei linksbündig muss startIndex 1 betragen da sonst 1 Spalte vom Buchstaben fehlt.
Rechtsbündig funktioniert. Bei mittig(CENTER)  wird das Wort ab dem letzten Byte vom E (vonTEST) ganz links gezeigt und denn gescrolt, also funktioniert auch:
byte getZerosFromOrientation(char* star, byte orientation);
nur teilweise.

Weitere Sachen die mir aufgefallen sind:
wenn ich
byte getZerosFromOrientation(char* star, byte orientation);
verwende muss das zu schreibende Wort global deklariert werden da der string in der funktion verwendet wird.
Wenn ich nun später Verschiedene Wörter verwende ist es denn auch möglich im loop neue Wörter zu deklarieren?

Wenn der Text links steht und er rausgescrolt wird dauert es eine weile bis es von vorne beginnt
(warsch. scrollt er weiter)
Aber das hast du ja nun korigiert.

Ist es irgend wie möglich das zwischen den Zeichen immer nur 1 Spalte Abstand ist?
Ich habe zum bei spiel 3 Ausrufezeichen geschrieben und zwischen ihnen waren 5 Spalten frei wegen den 4 Bytes der Zeichen und wegen dem Leerzeichen.
Manchmal sind dadurch zwischen Buchstaben eines Wortes verschieden große Abstände.

Nun wird der Text links rausgescrollt und erscheint als ganzes wieder rechts.
Wie scrolle ich den Text von rechts rein?

Gruß

strohhirn



71  International / Deutsch / Re: LED Laufleiste mit Arduino steuern on: December 27, 2013, 03:53:07 pm
Quote
Wenn ich nochmal über deinen Code schaue, fehlen da in setup() zwei Zeilen:
Code:
pinMode(dataPin, OUTPUT);
pinMode(clockPin, OUTPUT);

Ich hätte es nicht gedacht aber das war Tatsächlich der Fehler. smiley

Nun steht vom das Wort "TEST" wie im Serielen Monitor seitenverkehrt auf der LED-Laufleiste.Also habe ich dei for-Schleifen zurückverändert und es stand wieder richtig rum.
Davor kommt das Wort wieder aber um 1 Zeile nach unten verschoben, also zB das T:
(ich schreibe davor, weil das richtige Wort ganz rechts steht)
Quote
00X00
XXXXX
00X00
00X00
00X00
00X00
00X00

Aber ich freue mich riesig das es langsam funktioniert!  smiley-grin smiley-grin smiley-grin smiley-grin

Quote
Also das Flackern/Blinken ist weg und du hast jetzt ein statisches Bild? Dann war die Ansteuerung der Transistoren mit digitalWrite() doch weit schlechter als ich vermutet hatte.

Das lag nicht nicht am digitalWrite, es lag am zu langen delay(), ich verwende jetzt delay(1) statt delay(10). Nun ist ein konstantes Bild zu sehen. Die Variante mit der Port-Manipulation verwende ich natürlich auch weiter, sowohl für Transistoren als auch Schieberegister.
(Hab die Port-Manipulation jetzt ein bisschen verstanden, außerdem ist sie kürzer und schneller.)

Nun ist die Frage:
Wie schreibe ich das Wort nur 1 mal?
Wie kann ich ein beliebiges Wort zB. in der Mitte oder links(wie bei Word) platzieren?
(Ich denke selber nochmal drüber nach, aber jetzt gehe ich erstmal glücklich schlafen.)

Quote
Hast du den 74LS04 dazwischen?
Nein den verwende ich nicht, bis jetzt klappt es ja ohne ihn.

Gruß

strohhirn


72  International / Deutsch / Re: LED Laufleiste mit Arduino steuern on: December 27, 2013, 02:18:41 pm
Quote
Und dann die Zeile vielleicht mit einer gleichzeitigen Ausgabe auf Serial vergleichen (dabei beachten, dass Serial seitenverkehrt ist!)

Das habe ich gemacht mit einer Zeile und mit allen Zeilen und das Bild kommt wie gewollt im Seriellen Monitor das Wort seitenverkehrt.
Aber auf der Leiste kommt nun was ganz anderes: Die meisten LED-Spalten sind aus, aber es leuchten 2-3 verschieden breite LED-Spaltensäulen. (Das gleiche Muster mit einer oder allen Zeilen.)

Übrigens verwende ich jetzt auch die Transistorvariante mit der Port-Manipulation. Und egal ob ich bei den Schieberegistern die Port-Manipulation oder mit digitalWrite() das Muster bleibt gleich.
73  International / Deutsch / Re: LED Laufleiste mit Arduino steuern on: December 27, 2013, 10:35:12 am
Hab mal versucht den sketch zusammenzubasteln :
Code:
#include <avr/pgmspace.h>

prog_uchar PROGMEM font[96][5] = {
        {0x00,0x00,0x00,0x00,0x00}, //
        {0x00,0x00,0xfa,0x00,0x00}, // !
        {0x00,0xe0,0x00,0xe0,0x00}, // "
        {0x28,0xfe,0x28,0xfe,0x28}, // #
        {0x24,0x54,0xfe,0x54,0x48}, // $
        {0xc4,0xc8,0x10,0x26,0x46}, // %
        {0x6c,0x92,0xaa,0x44,0x0a}, // &
        {0x00,0xa0,0xc0,0x00,0x00}, // '
        {0x00,0x38,0x44,0x82,0x00}, // (
        {0x00,0x82,0x44,0x38,0x00}, // )
        {0x10,0x54,0x38,0x54,0x10}, // *
        {0x10,0x10,0x7c,0x10,0x10}, // +
        {0x00,0x0a,0x0c,0x00,0x00}, // ,
        {0x10,0x10,0x10,0x10,0x10}, // -
        {0x00,0x06,0x06,0x00,0x00}, // .
        {0x04,0x08,0x10,0x20,0x40}, // /
        {0x7c,0x8a,0x92,0xa2,0x7c}, // 0
        {0x00,0x42,0xfe,0x02,0x00}, // 1
        {0x42,0x86,0x8a,0x92,0x62}, // 2
        {0x84,0x82,0xa2,0xd2,0x8c}, // 3
        {0x18,0x28,0x48,0xfe,0x08}, // 4
        {0xe4,0xa2,0xa2,0xa2,0x9c}, // 5
        {0x3c,0x52,0x92,0x92,0x0c}, // 6
        {0x80,0x8e,0x90,0xa0,0xc0}, // 7
        {0x6c,0x92,0x92,0x92,0x6c}, // 8
        {0x60,0x92,0x92,0x94,0x78}, // 9
        {0x00,0x6c,0x6c,0x00,0x00}, // :
        {0x00,0x6a,0x6c,0x00,0x00}, // ;
        {0x00,0x10,0x28,0x44,0x82}, // <
        {0x28,0x28,0x28,0x28,0x28}, // =
        {0x82,0x44,0x28,0x10,0x00}, // >
        {0x40,0x80,0x8a,0x90,0x60}, // ?
        {0x4c,0x92,0x9e,0x82,0x7c}, // @
        {0x7e,0x88,0x88,0x88,0x7e}, // A
        {0xfe,0x92,0x92,0x92,0x6c}, // B
        {0x7c,0x82,0x82,0x82,0x44}, // C
        {0xfe,0x82,0x82,0x44,0x38}, // D
        {0xfe,0x92,0x92,0x92,0x82}, // E
        {0xfe,0x90,0x90,0x80,0x80}, // F
        {0x7c,0x82,0x82,0x8a,0x4c}, // G
        {0xfe,0x10,0x10,0x10,0xfe}, // H
        {0x00,0x82,0xfe,0x82,0x00}, // I
        {0x04,0x02,0x82,0xfc,0x80}, // J
        {0xfe,0x10,0x28,0x44,0x82}, // K
        {0xfe,0x02,0x02,0x02,0x02}, // L
        {0xfe,0x40,0x20,0x40,0xfe}, // M
        {0xfe,0x20,0x10,0x08,0xfe}, // N
        {0x7c,0x82,0x82,0x82,0x7c}, // O
        {0xfe,0x90,0x90,0x90,0x60}, // P
        {0x7c,0x82,0x8a,0x84,0x7a}, // Q
        {0xfe,0x90,0x98,0x94,0x62}, // R
        {0x62,0x92,0x92,0x92,0x8c}, // S
        {0x80,0x80,0xfe,0x80,0x80}, // T
        {0xfc,0x02,0x02,0x02,0xfc}, // U
        {0xf8,0x04,0x02,0x04,0xf8}, // V
        {0xfe,0x04,0x18,0x04,0xfe}, // W
        {0xc6,0x28,0x10,0x28,0xc6}, // X
        {0xc0,0x20,0x1e,0x20,0xc0}, // Y
        {0x86,0x8a,0x92,0xa2,0xc2}, // Z
        {0x00,0x00,0xfe,0x82,0x82}, // [
        {0x40,0x20,0x10,0x08,0x04}, // "\"
        {0x82,0x82,0xfe,0x00,0x00}, // ]
        {0x20,0x40,0x80,0x40,0x20}, // ^
        {0x02,0x02,0x02,0x02,0x02}, // _
        {0x00,0x80,0x40,0x20,0x00}, // `
        {0x04,0x2a,0x2a,0x2a,0x1e}, // a
        {0xfe,0x12,0x22,0x22,0x1c}, // b
        {0x1c,0x22,0x22,0x22,0x04}, // c
        {0x1c,0x22,0x22,0x12,0xfe}, // d
        {0x1c,0x2a,0x2a,0x2a,0x18}, // e
        {0x10,0x7e,0x90,0x80,0x40}, // f
        {0x10,0x28,0x2a,0x2a,0x3c}, // g
        {0xfe,0x10,0x20,0x20,0x1e}, // h
        {0x00,0x22,0xbe,0x02,0x00}, // i
        {0x04,0x02,0x22,0xbc,0x00}, // j
        {0x00,0xfe,0x08,0x14,0x22}, // k
        {0x00,0x82,0xfe,0x02,0x00}, // l
        {0x3e,0x20,0x18,0x20,0x1e}, // m
        {0x3e,0x10,0x20,0x20,0x1e}, // n
        {0x1c,0x22,0x22,0x22,0x1c}, // o
        {0x3e,0x28,0x28,0x28,0x10}, // p
        {0x10,0x28,0x28,0x18,0x3e}, // q
        {0x3e,0x10,0x20,0x20,0x10}, // r
        {0x12,0x2a,0x2a,0x2a,0x04}, // s
        {0x20,0xfc,0x22,0x02,0x04}, // t
        {0x3c,0x02,0x02,0x04,0x3e}, // u
        {0x38,0x04,0x02,0x04,0x38}, // v
        {0x3c,0x02,0x0c,0x02,0x3c}, // w
        {0x22,0x14,0x08,0x14,0x22}, // x
        {0x30,0x0a,0x0a,0x0a,0x3c}, // y
        {0x22,0x26,0x2a,0x32,0x22}, // z
        {0x00,0x10,0x6c,0x82,0x00}, // {
        {0x00,0x00,0xfe,0x00,0x00}, // |
        {0x00,0x82,0x6c,0x10,0x00}, // }
        {0x40,0x80,0xc0,0x40,0x80}, // ~
        {0x00,0x00,0x00,0x00,0x00}, //
};

int latchPin1 = 8;
int latchPin2 = 9;
int latchPin3 = 10;
int latchPin4 = 11;

int dataPin = 5;
int clockPin = 6;


void printRow(char* str, int row)
{
for(int i = strlen(str) - 1; i >= 0 ; i--)       //iteriere über String
{
char currentCharacter = str[i] - 0x20;      //Adresse im Flash berechnen

for(int j = 4; j >= 0; j--)        //iteriere über die 5 Bytes eines chars
{
byte currentByte = pgm_read_byte_near(&font[currentCharacter][j]);       //aktuelles Byte aus Flash lesen

if(currentByte & (1 << (7 - row)))    //das ist was bitRead() macht, aber man spart sich den Funktions-Aufruf, der auch wieder Zeit kostet. Ganz wichtig: hier nicht auf true abfragen!
{
    //Bit auf 1 setzen
    PORTD = PORTD | _BV(5);        //BV steht für bit value und setzt Bit 5 (B0010000). Das macht einfach (1 << 5). Mit dem Oder wird der Wert dann mit dem aktuellen Zustand des Ports zusammengeführt
}
else
{
    //Bit auf 0 setzen
    PORTD = PORTD & ~(_BV(5));      //Und mit der Negation (B11011111).
}

PORTD = PORTD ^ _BV(6);              //toggle Pin 6 Low -> High (^ ist ein XOR)
PORTD = PORTD ^ _BV(6);
}

PORTD = PORTD & ~(_BV(5));     //statt Leerzeichen
                PORTD = PORTD ^ _BV(6);              //toggle Pin 6 Low -> High (^ ist ein XOR)
                PORTD = PORTD ^ _BV(6);
}
}


void setup() {
  pinMode(latchPin1, OUTPUT);
  pinMode(latchPin2, OUTPUT);
  pinMode(latchPin3, OUTPUT);
  pinMode(latchPin4, OUTPUT);
  Serial.begin(9600);
}

void loop()
{
char str[] = "TEST";

for(int i = 0; i < 7; i++)           //Zeile 0-7
{
                switchTransistor(7); // Transistoren aus
printRow(str, i);
switchTransistor(i);
                delay(10);
  }

        
}

void switchTransistor(byte transistor)
{
     switch(transistor)
     {
           case 0: digitalWrite(latchPin1, LOW);
                        digitalWrite(latchPin2,LOW);
                        digitalWrite(latchPin3,LOW);
                        digitalWrite(latchPin4,LOW);
                        break;
          case 1: digitalWrite(latchPin1, HIGH);
                       digitalWrite(latchPin2,LOW);
                       digitalWrite(latchPin3,LOW);
                       digitalWrite(latchPin4,LOW);
                       break;
          case 2: digitalWrite(latchPin1, LOW);
                       digitalWrite(latchPin2,HIGH);
                       digitalWrite(latchPin3,LOW);
                       digitalWrite(latchPin4,LOW);
                       break;
          case 3: digitalWrite(latchPin1, HIGH);
                       digitalWrite(latchPin2,HIGH);
                       digitalWrite(latchPin3,LOW);
                       digitalWrite(latchPin4,LOW);
                       break;
          case 4: digitalWrite(latchPin1, LOW);
                       digitalWrite(latchPin2,LOW);
                       digitalWrite(latchPin3,HIGH);
                       digitalWrite(latchPin4,LOW);
                       break;
          case 5: digitalWrite(latchPin1, HIGH);
                       digitalWrite(latchPin2,LOW);
                       digitalWrite(latchPin3,HIGH);
                       digitalWrite(latchPin4,LOW);
                       break;
          case 6: digitalWrite(latchPin1, LOW);
                       digitalWrite(latchPin2,HIGH);
                       digitalWrite(latchPin3,HIGH);
                       digitalWrite(latchPin4,LOW);
                       break;            
                      
          default: digitalWrite(latchPin1, HIGH);
                        digitalWrite(latchPin2,HIGH);
                        digitalWrite(latchPin3,HIGH);
                        digitalWrite(latchPin4,HIGH);
                        break;
     }
}
Was dabei rauskommt: Die LED Zeilen  blinken alle ganzschnell Im wellenmuster . Also alle sind an man merkt aber ein Blinken.

Anstatt des Leerzeichens habe ich folgendes verwendet:

PORTD = PORTD & ~(_BV(5));     //Leerzeichen zwischen Buchstaben
                PORTD = PORTD ^ _BV(6);              //toggle Pin 6 Low -> High (^ ist ein XOR)
                PORTD = PORTD ^ _BV(6);

Was habe ich falsch gemacht?
Hast du irgendetwas anders gemeint? Oder habe ich etwas vergessen?

Gruß

strohirn
74  International / Deutsch / Re: LED Laufleiste mit Arduino steuern on: December 26, 2013, 08:26:55 am
Noch ein paar Fragen:

"strlen(str)" Steht das für Sting Lengh von (str)?

char currentCharacter = str - 0x20;  Wieso Muss man minus Leerzeichen angeben?

Quote
In der Zeile "if(bitRead(currentByte, 7 - row) == true)" sollte man dann (statt Serial.print()) das entsprechende Bit auf den Daten-Eingang der Schieberegister geben können und es mit einem Low->High->Low Impuls auf dem Clock-Eingang einschieben. Siehe Datenblatt: "Clocking occurs on the low-to-high-level transition of CLK".

Also bildet man denn quasi aus den einzelnen Bits eine Kette(Byte) und überträgt sie denn mir diesem impulse, richtig?

Nun habe ich aber jetzt mehrere schieberegister, wie funktioniert das denn wenn ein Buchstabe zwischen 2 Schieberegistern gebildet wird? Ich kann mir das grad garnicht vortellen.

Soll ich es einfach mal so versuchen, mit dieser Port-Manipulation und den Bit Operatoren, wie du es geschrieben hast?
Oder was soll ich als nächstes machen?

Gruß

strohhrin
75  International / Deutsch / Re: LED Laufleiste mit Arduino steuern on: December 25, 2013, 02:35:39 pm
Quote
Dieses ganze Projekt ist ein paar Nummern zu groß für dich.

Das stimmt, deswegen suche ich hier ja auch Hilfe. Außerdem lerne ich einiges dadurch und es ist interessant.

Bis hier hab ich es glaube ich erstmal verstanden:
Quote
Versuche erst mal das zu verstehen.

Ein Buchstabe besteht aus 5 Bytes, jedes Byte ist als Hexadezimal geschrieben wobei "0x" ein Zeichen für den Compiler ist, das eine Hexadeziaml Zahl folgt.

Nun liest das Programm von jedem Byte der Reihe nach vom 7. Bit angefangen den Zustand und schreibt je nachdem "x" oder "_"
So entsteht eine Zeile. Das Wird 7 mal wiederholt bis ein Buchstabe entsteht.

Bis hier hin erstmal richtig?

Wann das Leerzeichen zwischen den Buchstaben gesetzt wird habe ich nicht verstanden.



Nun sollte ich es ja umschreiben sodass das Wort in 1 Zeile steht und nicht untereinander.

Ich habe mir echt den Kopf zerbrochen und habe auch ne weile gebraucht um den eig. Code einigermaßen zu verstehen, da ich viele Sachen googlen musste.

Ich habe mir deine Beschreibung mehrmals durchgelesen und habs nicht richtig verstanden.

Quote
Dann kannst du den ganzen String und die Nummer der Zeile übergeben. Statt über die Zeile (i) iterierst du dann über den String, iterierst über alle 5 Bytes des aktuellen chars (j), und gibst das Bit der jeweiligen Zeile aus (row). Man muss eigentlich nur die for-Schleife mit i ändern und den aktuellen char innerhalb davon aus dem String lesen (und das -0x20 machen) . Und nach jedem char ein Leerzeichen ausgeben.


Für dich mag das hier alles logisch und klar erklärt sein, aber für mich ist das sehr schwer bis garnicht zu verstehen.
Wenn ich denke ich habs verstanden und es versuche umzusetzen, merke ich das ich es wieder nicht verstanden habe smiley.

Aber ich bin dir echt dankbar das du dir die Mühe machst und so lange texte schreist, in der Hoffnung das ich es verstehe.
Bitte hilf mir bis zum Schluss, ich möchte wenigstens etwas mal zu ende bringen.



Übrigens: Allen noch frohe Festtage!

Gruß

strohhirn
Pages: 1 ... 3 4 [5] 6 7 ... 20