Atmega8 und 74HC595

[Markus]

Hallo Andreas,

folgende Frage vorab:

$crystal = 10500000

Verwendest Du einen externen Quarz oder wie kommst Du auf 10500000 Hz? Ist eine komische Frequenz, aber gut, daran solls ertmal nicht scheitern. Ist mir nur aufgefallen.

So nun zu Deinem Code:
Nach dem ersten Überfliegen konnte ich kein prinzipielles Problem finden. Aber, der SHIFTOU-Befehl hat einen 4. Parameter der meiner Meinung nach nicht optional ist sondern immer angegebn werden muss. Er steuert, wie und in welcher Reihenfolge die Bits rausgetaktet werden. Der Parameter fehlt in Deinem Beispiel komplett. Es könnte sein, das BASCOM hier rein zufällig was macht, was BASCOM gerade gefälltund das daher Dein Fehlverhalten kommt.
Schau Dir bitte hierzu den Parameter Option an:

Option can be :
0 – MSB shifted out first when clock goes low
1 – MSB shifted out first when clock goes high
2 – LSB shifted out first when clock goes low
3 – LSB shifted out first when clock goes high

Aufgrund Deiner Beschaltung und der Daten würde ich fast sagen, dass der Parameter "1" der richtige wäre. Ggf. Musst Du das aber ausprobieren.

Ansonsten müsste es, soweit ich aus der Ferne erstmal beurteilen kann, funktionieren. Der Storage-Clock zur Übernahme der Daten an die Ausgänge ist ok.

Vom Timing her ist kein Problem zu erwarten da Du mit 1050000 Hz einen Clock-Cycle von ca. 95 ns hast und damit weit über allen MIN/TYP/MAX Werten des Schieberegisters liegst. Sollte also auch OK sein.

Würde sagen, check mal den Parameter OPTION und melde Dich wieder.
Gerne auch wieder mit Viedeo

Grüße,
Markus

 

[Tipfix]

Hallo Markus

Verwendest Du einen externen Quarz

Richtig. Hatte nur einen mit 10500000 MHz da.

Also bei den Parameter 0 und 1 bleibt alles beim alten und bei 2 und 3 das ganze rückwärts.

Irgendwie habe ich den eindruck das der nicht die ganzen 15 bit reinschiebt sondern eher nur 8.

Gruß Andreas

 

[Markus]

Das kann ich mir fast nicht vorstellen. Normalerweise nimmt BASCOM wenn Du keinen Parameter angibst die größe des Value um die Bits zu schieben. bedeutet bei byte automatisch 8 und bei word automatisch 16. um das auszuprobieren kannst due aber den weiteren optionalen Parameter probieren und ihn auf 16 setzen um wirklich auch 16 Bits rauszuschieben.
Um sicherzustellen, dass du kein Timing-Problem hast kannst Du auch als letuzten optionalen Parameter mal 100µsec Wartezeit einbauen. Müsste dann immer noch schnell genug sein.

Ansonsten verstehe ich es nicht den rein vom Code her sollte es funktionieren. Probiers nochmals aus, ansonsten schaue ich mir den Code und die Funktion nochmals genauer an.

Grüße,
Markus

 

[hellmars]

hallo tipfix,
nun mische ich auch noch ein bischen mit ... zur erinnerung, ich bin der mit dem rotor-display!

das ding ist fasf fertig und bald stelle ich das ganze projekt hier auch vor und auch ein ...
vorab aber ... ich betreibe die ansteuerung der led's ebenfalls ueber besagtes schieberegister
uber den HW-SPI (parallel zum SPI-programmierstecker).

auf den beiden schaltplaenen ist das notwendige pinning enthalten. soviel noch als ergaenzung
(da ich die schaltplaene wegen minimalversion von eagle splitten musste!), der "stecker latch"
geht auf den "stecker sv1" ... und ueber "stecker sv2" geht es weiter zum naechsten schiebere-
gister auf "stecker sv1" und so weiter bis zum x-ten schieberegister, in meinem fall 4 stk.


sodele, jetzt noch was zu bascom.


hier erst mal die konfiguration:

' ----- Hardware-SPI zur Ansteuerung der LED's -----
' CONFIG SPI = HARD, INTERRUPT=ON|OFF, DATA ORDER = LSB|MSB , MASTER = YES|NO , POLARITY = HIGH|LOW , PHASE = 0|1, CLOCKRATE = 4|16|64|128 , NOSS=1|0
' Hardware-SPI einstellen, SPI Bus initialisieren, setzt das DDR Register entsprechend
' *** folgende Einstellung hat sich bewährt ***
Config Spi = Hard , Master = Yes , Clockrate = 4 , Noss = 0 ' , Polarity = Low , Phase = 0 , Data Order = Lsb ,
Spiinit

im programm selbst sieht die ansteuerung der led's dann folgendermaßen aus:

Dim Daten_zu_latch(4) As Byte

...
 
      Daten_zu_latch(4) = &B11101111                 'daten_zu_latch(4) ist 
      Daten_zu_latch(3) = &B11000000
      Daten_zu_latch(2) = &B00011000
      Daten_zu_latch(1) = &B00000011

      Spiout Daten_zu_latch(1) , 4

bzw. wenn du sie aus einem datenbereich ausliest

      Sprungadresse = Loadlabel(datenbereich)

      Daten_zu_latch(4) = Cpeek(sprungadresse)      'laden des ersten bytes in der ersten zeile
      Incr Sprungadresse                            'im datenbereich
      Daten_zu_latch(3) = Cpeek(sprungadresse)
      Incr Sprungadresse
      Daten_zu_latch(2) = Cpeek(sprungadresse)
      Incr Sprungadresse
      Daten_zu_latch(1) = Cpeek(sprungadresse)
      Incr Sprungadresse

      Spiout Daten_zu_latch(1) , 4

mit der zugehoerigen definition des datenbereiches

Datenbereich:
Data &B11101111 , &B11000000 , &B00011000 , &B00000011
Data &B11111111 , &B11000000 , &B00000000 , &B00000000
Data &B11111111 , &B11000000 , &B00000000 , &B00000000
Data &B11111111 , &B11000000 , &B00000000 , &B00000000

in beiden faellen wuerden die 32 led's wie folgt leuchten:

led 1 (innen) .................................................................. 32 (aussen)

1 1 1 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1


verwirrung komplett? gern geschehen!

gruss und viel glueck
helmar

 

[Tipfix]

Hallo Markus

Ich habe jetzt mal folgendes probiert:

For A = 0 To 15

Daten = Lookup(a , Spalten)

Daten2 = Lookup(0 , Zeilen)

Print Daten
Print Daten2

Shiftout Ds , Sh_cp , Daten , 3
Shiftout Ds2 , Sh_cp2 , Daten2 , 3

Die rote 0 hab ich statt dem a rein genommen. Und das geht. Frag mich nicht warum.

 

[Markus]

Oooooh, da viel es mir wie Schuppen von den Augen

Folgende Ergänzung zu Data (originalauszug BASCOM):

Difference with QB
Integer and Word constants must end with the %-sign.
Long constants must end with the &-sign.
Single constants must end with the !-sign.
Double constants must end with the #-sign.

Definiere Deine Data mal wie folgt:

Spalten:

Data &B0000000000000001%
Data &B0000000000000011%
Data &B0000000000000111%
Data &B0000000000001111%
Data &B0000000000011111%
Data &B0000000000111111%
Data &B0000000001111111%
Data &B0000000011111111%
Data &B0000000111111111%
Data &B0000001111111111%
Data &B0000011111111111%
Data &B0000111111111111%
Data &B0001111111111111%
Data &B0011111111111111%
Data &B0111111111111111%
Data &B1111111111111111%

und lass ruhig

Daten2 = Lookup(a , Zeilen)

stehen, das muss auch so funktionieren.

Grüße,
Markus

 

[Tipfix]

Hallo Markus

Difference with QB
Integer and Word constants must end with the %-sign.
Long constants must end with the &-sign.
Single constants must end with the !-sign.
Double constants must end with the #-sign.

Hab ich auch gefunden. Hab ich gemacht und die rote 0 wieder durch a ersetzt. und das geht auch. Man sollte eben mehr lesen.
So als nächstes wäre es interesant Buchstaben dar zustellen.

Dafür ist ja das ganze gedacht.

Gruß Andreas

 

[Markus]

Ja dann mal los

 

[Tipfix]

Tach auch

Hab mal was versucht. Immerhin ein A.
Allerdings flimmerts ganz schön.
Hier das Video. Und den Code nicht zu vergessen.

Grüße der Tipfix

PS: Das flimmern ist weg. Im Code waren zwei Printbefehle für Testzwecke.
Aber wie kann ich jetzt scrollen?

 

[Tipfix]

Guten Abend

Sitze immer noch vor meinem A. Ich habe absolut keine Idee wie ich es schaffe das das A von links nach rechts wandert.
Hab schon überall geguckt. Wenn ich nicht schon so groß wäre würde ich weinen.
Vieleicht hat noch jemand einen Tip für mich.

Gruß der Tipfix

 

[Markus]

Hei Tipfix,

auch für Erwachsene ist es manchmal ganz befreiend zu weinen. Wenn Dir danach ist dann tue es einfach. Kann Dir nur den Tipp geben denn wenn mir danach ist dann tue ich es auch Egal ob aus Frust oder aus Trauer oder oder oder.
Ich glaube diese menschlichen Züge sind der Hautunterschied der uns in der heutigen "funktionierenden" Gesellschaft von den Maschinen unterscheidet.

So, wenn Du dann fertig geweint hast dann vielleicht noch ein paar Tipps von mir.

Ich glaube, das bei Deiner Idee ein prinzipielles HW-Problem existiert sondern eher ein Denkfehler. Schau mal, was bedeutet es das A von links nach rechts ins Display reinwander zu lassen. Es bedeutet nix anderes, als dass Du die dafür notwendigen 16 Bit nicht auf einmal in das Schieberegister schiebst sonder Schluck für Schluck immer ein Bit mehr. Verstanden, NEIN -> OK

In Deiner aktuellen Implementierung schiebst Du über die For-Schleife alle 16 Bit für die Zeilen und alle 8 Bit für die Spalten auf einen Schlag rein. Damit erzeugst Du aber immer das gesamte Bild auf einen Schlag und das mehrfach in der Sekunde damit ein "stehendes" A erscheint. Soweit auch so gut.

Jetzt könntest Du folgendes mache:
Du erzeugst einen Timer welcher Dir einen Sekundentakt über eine Interrupt-Service-Routine erzeugt.

In Deiner For-Schleife gibst Du alle 8Bit für die Spalten aber immer nur eine bestimmte Anzahl von Bits für die Zeilen aus. Über den Timer-Tick kannst Du zum Beispiel eine Variable immer von 1 bis 16 und wieder zurück auf 1 und wieder bis 16 zählen oder nur von 1 bis 16 zählen und dann bei 16 aufhören. Das läuft im Hintergrund und davon bekommst Du nicht viel mit.

In Deiner For-Schleife schiebst Du nun nicht die gesamten 16 Bit für die Zeilen in Dein Schieberegister sondern immer nur die Anzahl von Bits die Dir Dein Zähler vorgiebt.

Also, zum Startzeitpunkt hat Du Zähler 1, nach einer Sekunde Zähler 2, nach einer weiteren Sekunde Zähler 3 usw bis Zähler 16.

Den Shiftout in der For-Schleife kannst Du durch einen weiteren Parameter so konfigurieren, dass Du im sagen kannst, wie viel bits Deiner Variable er schieben soll. Nehme dort den Zähler mit rein.

Nach einer Sekunde schieb er also 1 Bit für die Spalten über alle Zeieln in die Register, nach 2 Sekunden 2 Bit, nach 3 Sekunden 3 Bit usw.

Man hat also den Eindruck, dass sich das Bild sekündlich um ein Bit mehr von links nach rechts aufbaut.

Verstanden?

Ich glaube anders wirst Du es nicht schaffen hier einen fließenden Effekt hinzubekommen mit dem Du bewegten text ins Display bekommst. Du musst ja parallel darauf achten, dass die Zeilen schnell genug aufgebaut werden so dass Du ein stehendes Bild bekommst. Wenn Du zu langsam wirst fängt es zu flackern an und bei noch größeren Delay siehst Du wie er die Zeilen einzeln durchklappert.

Ich hoffe ich konnte mit den Hinweisen den Knoten lösen.

Grüße,
Markus

 

[Tipfix]

Hallo Markus

Jetzt hast du mich vollends verwirrt. Mit dem zusätzlichen Parameter hatte ich auch schon mal experimentiert. Das ergebniss sah aber komisch aus. Hatte mit meinem A nicht mehr viel zu tun. Kannst Du mir das mit dem Timer näher erklären? Wäre echt nett von Dir.

Der Tipfix

 

[Tipfix]

Abend

Hab mal versucht das von Markus geschriebene um zusetzen. Raus gekommen ist das angehängte Prog. Allerdings ändert das an meinem A rein garnichts. Das steht immer noch brav an seiner Stelle.

Der Tipfix

 

[Tipfix]

Guten Morgen

Ich schon wieder. Bin ein bischen weiter. Immerhin ein Fortschritt. Hier ein Video. Anbei auch das Programm. Allerdings ist das nicht das was ich will . Zum einen läuft das A nicht rein nur raus. Zweitens ist das nur ein Buchstabe. Ich möchte aber einen ganzen Text. Ich habe das Gefühl das ich total falsch liege mit meinem Ansatz. Hab mir auch schon die Finger wund gegoogelt und nichts was mir auch nur annähernd hilft gefunden.

Der Tipfix

 

[Markus]

Hallo TipFix,

mit dem falschen Ansatz könntest Du recht haben. Aber es sollte schon eine Lösung für Dein Problem geben

Also, dass Das A wie im Video dargestellt rechts erscheint und nach links rausgeschoben wird ist eigentlich schon klar.

Das A befindet sich "linksbündig" in der 16-Bit WORD-Variable und damit beginnend mit MSB. Mit dem ShiftOut schiebst Du auch das MSB zuerst raus. Bedeutet, dass das A auf dem Display also spiegelverkehr rechtsbündig abgebildet wird weil diese bits der Spalten die höherwertigeren sind. Beim definieren von anderen Buchstaben z.B. B oder G muss das beachtet werden da Du sonst die Buchstaben gespiegelt darstellst.

Nun, warum läuft der Buchstabe von rechts nach links. Ganz einfach. Deine Operation Daten / B gleicht einer Schiebeoperation über N Stellen. Durch die Berechnung B = B * 2 klapperst Du die einer, zweier, vierer, achetr usw. Stellen ab und sorgst durch die Division für einen Shift des A in der Variable nach rechts. Shift von A in der Variable von links nach rechts bedeutet aber aufgrund der Spiegelung auf Deinem Display ein Wandern des A von rechts nach links. Das ist schon klar.

So, nun weiter:

Wie Du allerdings mit diesem Konzept eine Laufschrift hinbekommen möchtest mit der Du die unterschiedlichsten Texte darstellst, oh jeee oh jeee. Das wir aufwendig und ist ziemlich "tricki". Da bekomme ich erstmal auch einen Knoten in mein Hirn.

Zurück zum letzten Code-Teil bei dem Du versucht hast mit Shiftout das A zu bewegen. Habe mir Deinen Code angesehen und bin der Meinung er müsste eigentlich funktionieren. Komme auf Anhieb nicht auf das Problem. Ich verstehe absolut nicht warum mit diesem Code das A wieder nur stehend auf der rechten Seite projiziert wird. Es müsste eigentlich auch wandern da Du ja nur x Bits in die Schieberegister schiebst. Aber geb mir dazu noch ein bissle Zeit und vielleicht komme ich noch dahinter.

Soweit erstmal meine Gedanken.

Grüße,
Markus

 

[Tipfix]

Abend

@Markus, ich verfolge einen neuen Ansatz. Und zwar kam ich auf die Idee das A mit dem Befehl Shift Daten , Left , 13 aus dem Anzeigebereich raus zu shiften. Und anschließend mit dem Befehl Shift Daten , Right , B wieder rein zu shiften. Leider kommt dabei nur die erste Spalte im Anzeigebereich an . Und da Bilder mehr als tausend Worte sagen hier das Video. Das Prog ist auch wieder mit dabei.

Gruß der Tipfix

 

[drminzkopp]

Danke Tipfix, der Programmschnippsel hat mir prima geholfen shiftout zu verstehen.
Ich hatte das mit dem clock einfach nicht gerafft, bzw. wie/woher soll der clock kommen usw...
Fand ich in der Bascom Hilfe etwas abstrakt, oder es ist im Grunde zu simpel.
Super....
MfG