Show Posts
Pages: 1 2 3 [4] 5 6 ... 18
46  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.
47  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
48  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
49  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
50  International / Deutsch / Re: LED Laufleiste mit Arduino steuern on: December 23, 2013, 02:16:44 pm
Quote
Die grobe Variante (die für dich einfacher zu verstehen ist) ist ein Funktion, die ein switch-case enthält:

Danke, genau sowas meinte ich.

Ich bleibe aber bei der ersten Variante, weil ich diese verstehe. Oder hat die Port-Manipulation irgendwelche Vorteile?

Ab hier wurde es mir zu schnell oder zu grob:
Quote
Einen fertigen 5*7 Font gibt es hier:

Ab da habe ich nichts mehr verstanden, zudem sind die Seiten auch noch auf Englisch was es nicht leichter macht.(Ich kann Englisch aber es ist schwer etwas zu lesen wovon man noch keine Ahnung hat)

Könntest du mir das bitte das ganze etwas langsamer und ausführlicher erklären.
Ich habe nämlich keinen Plan was ich jetzt mit diesem "Font" machen soll.

Gruß
strohhirn
51  International / Deutsch / Re: LED Laufleiste mit Arduino steuern on: December 23, 2013, 08:26:27 am
Es klappt !!!!   smiley-grin smiley-grin smiley-grin smiley-grin
Vielen Dank! Endlich mal wieder ein kleiner Erfolg. Das motiviert.
Hab es mit 2 Zeilen Versucht und es klappt ohne zu flackern.
Ihr hattet vollkommen recht. Erst als ich den 4 Pin angeschlossen habe, hat es geklappt.

Nun muss ich mich ans Programm machen.

Nun möchte ich nicht immer folgendes schreiben um 1 Pin anzumachen.
Code:
digitalWrite(latchPin,HIGH);
    digitalWrite(latchPin2,LOW);
    digitalWrite(latchPin3,LOW);
    digitalWrite(latchPin4,LOW);

oder andere Kombinationen.

Wie kriege ich das im Programm umgewandelt, sodass ich nur noch 1 Zeile schreiben muss und nur die Pin nummer anstatt einen 4-stelligen code.
(mit arrays und strings kenne ich mich noch nicht aus, hab aber schon darüber gelesen)

Denn wollte ich noch fragen:
Gibt es schon fertige Programme die Schrift in Binärcode umwandeln können.

Oder muss ich mir ein Muster zeichnen und jede Zeile nach dem Muster im Binärcode umsetzen?

Gruß

strohhirn
52  International / Deutsch / Re: LED Laufleiste mit Arduino steuern on: December 22, 2013, 03:10:28 pm
Habs gerade versucht mit dem BCD Decoder. Aber irgendwie kriege ich das ding nicht zum laufen.

Mein Sketch:

Code:
//Pin connected to ST_CP of 74HC595
int latchPin = 8;
int latchPin2 = 7;
int latchPin3 = 6;
int latchPin4 = 5;
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
////Pin connected to DS of 74HC595
int dataPin = 11;



void setup() {
  //set pins to output so you can control the shift register
  pinMode(latchPin, OUTPUT);
  pinMode(latchPin2, OUTPUT);
  pinMode(latchPin3, OUTPUT);
  pinMode(latchPin4, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}

void loop() {
 
    digitalWrite(latchPin, LOW);
    digitalWrite(latchPin2, LOW);
    digitalWrite(latchPin3, LOW);
   
   
    shiftOut(dataPin, clockPin, MSBFIRST, 170);
 
   
    digitalWrite(latchPin, HIGH);
   digitalWrite(latchPin2, LOW);
   digitalWrite(latchPin3, LOW);
   
    delay(10);
}

Ich verstehe diese Tabelle immernoch nicht da steht :
H = HIGH Level (OFF)
L = LOW Level (ON)

Ist Der Pin nun HIGh oder OFF???

Ist mein sketch irgendwie falsch? Bitte berichtigt ihn wenn ja.

Quote
Du darfst nie Eingänge offen lassen.
Wieso? Ist es nicht egal ob dort kein Signal ankommt oder LOW. Es ist denn doch so oder so aus, oder kann es auch von grundauf an sein?

Quote
Eingang D wird wahrscheinlich fest auf LOW liegen

Von Pin D führt ein Weg zum Prozessorsockel. Soll ich diesen also auch mit dem Arduino verbinden und auf LOW setzen?

Gruß

strohhirn
53  International / Deutsch / Re: LED Laufleiste mit Arduino steuern on: December 22, 2013, 06:39:33 am
Danke das wieder Antworten kommen. smiley

Quote
Da hast du oben aber mal geschrieben dass du dass probieren willst und dann nichts mehr weiter dazu...

Ich habe nichts gemacht weil ich mir nicht sicher war wie das geht.
Deswegen habe ich ja nochmal nachgefragt.

Quote
Ich versuche es mit dem BCD Decoder. Mit Spannung wird er schon durch die platine versorgt, richtig? Ich muss nur noch die inputs anschließen.

Wird es nun schon mit Spannung versorgt? Wie schalte ich zB. nur den 1. Pin an, für den 1. Transistor?
Ich habe es mit einem Input versucht da passiert nichts. Bracht es mindestens 3 inputs um die Outputs bedienen zu können?
In der Funktions Tabelle sehe ich nicht durch.

Gruß

strohhirn

54  International / Deutsch / Re: LED Laufleiste mit Arduino steuern on: December 21, 2013, 03:31:44 pm
Da mir auf simpelste Fragen nicht mehr geantwortet wird, habe ich es jetzt einfach selbst versucht.

Ich habe die Spannung zwischen GND und dem Ausgang vom Transistor mal gemessen.
Wenn er an sein soll sind es 11,7 V und wenn er aus sein soll sind es 11,5 V.
Daraus folgt: Das flackern entsteht dadurch das die Transistoren dauerhaft an sind.

Sollte ich vllt die Wiederstände dem Arduino anpassen? Und wenn ja wie?

Wird der Post überhaupt noch gelesen? Ich habe das Gefühl wie mehr seiten ein Thread hat umso weniger Leute schauen rauf,weil sie keine Lust haben sich alles durchzulesen .
Sollte ich besser einen neuen Tread aufmachen?

Gruß

strohhirn
55  International / Deutsch / Re: LED Laufleiste mit Arduino steuern on: December 21, 2013, 12:51:55 pm
Hab jetzt verstanden was der 74LS04 macht der invertiert das eingehende signal.
Da er mit dem Clock und Input Pin der Schieberegister verbunden ist gehe ich mal davon aus das er diese signale umhehrt.
Aber was bringt das? Könnte es das flackern verhindern?

Und wie kann ich nun testen ob die Transistoren an und aus gehen?
56  International / Deutsch / Re: LED Laufleiste mit Arduino steuern on: December 21, 2013, 12:39:02 pm
Wie soll ich den jetzt mit meinem Problem vorankommen? Irgendwie muss ich ja den Fehler finden können.
57  International / Deutsch / Re: LED Laufleiste mit Arduino steuern on: December 20, 2013, 02:29:21 pm
Kann ich irgendwie kontrollieren ob die Transistoren an und aus gehen?
58  International / Deutsch / Re: LED Laufleiste mit Arduino steuern on: December 20, 2013, 08:12:11 am
Ich versuche es mit dem BCD Decoder. Mit Spannung wird er schon durch die platine versorgt, richtig? Ich muss nur noch die inputs anschließen.
Hab mal ein bild rangehängt wo ich 2 Transistoren beschriftet hab.

Im datasheet der Transistoren steht: Emitter-Base Voltage 5V (ich weiß zwar nicht was das ist aber ich habe nichts logischeres gefunden)

TIP125
http://pdf.datasheetcatalog.com/datasheet/stmicroelectronics/4128.pdf

Was machen den die 74LS04 machen? Dieser chip ist nähmlich auf der platine mit dem Clock und Input pin verbunden.
Quote
74LS04 -> 6 invertierende Treiber um viele Schieberegister ansteuern zu können
59  International / Deutsch / Re: LED Laufleiste mit Arduino steuern on: December 18, 2013, 02:28:45 pm
Danke das du versuchst mir zu helfen.
Habs grad versucht und es ergab keinen Unterschied. Heißt das, dass ich die Transistoren dauerhaft an sind?
Mir ist aufgefallen das das flackern verschwindet wenn ich ein programm auf den arduino lade.
60  International / Deutsch / Re: LED Laufleiste mit Arduino steuern on: December 18, 2013, 12:42:35 pm
Uwe meinte ja:
Quote
Also Ansteuerung über die Eingänge des 74LS04 (Schieberegister) bzw 7445 (Transistoren).
Quote
74LS04 -> 6 invertierende Treiber um viele Schieberegister ansteuern zu können

Ich habe diesen IC auch entfernt.
Ich habe nicht richtig verstanden wofür es ist. Kann dadurch dieses flackern verhindert werden?

Gruß

strohhirn
Pages: 1 2 3 [4] 5 6 ... 18