Bascom Problem beim Ansteuern einer LED-Matrix

[Cassio]

.....
(shiftout Data_4094 , Clock_4094 , Zeichen , 0 , i)
nicht umsetzen, da Bascom auf die Variable "i" nicht reagiert?! ("i" habe ich als Byte deklariert)

Hallo!

Welche BASCOM-Version verwendest du gerade?
Ich müsste noch mal stöbern..... meine mich aber daran zu erinnern, dass da in letzter Zeit etwas geändert wurde.
Ob es dabei aber um SHIFTOUT ging, weiß ich jetzt leider nicht mehr genau...... muss ich mal schauen.

Geh also erst mal davon aus, dass bei der Angabe der Bits keine Variable verwendet werden kann.


Grüße,
Cassio

 

[Kokusnuss]

Ich verwende Bascomversion 1.11.8.7.
Das wäre ja schade, wenn es diese Möglichkeit nicht gibt. Aber es scheint so zu sein. :-(

LG
Kokusnuss

 

[Cassio]

Ich verwende Bascomversion 1.11.8.7.
Das wäre ja schade, wenn es diese Möglichkeit nicht gibt. Aber es scheint so zu sein. :-(

Hallo!

Ich habe den Thread wieder gefunden..... Schau mal hier und die nachfolgenden Beiträge von HBA!
Bzw. auch HIER!


Demnach muss das funktionieren.... ab Version 2.0.6.x!
Nur leider in deiner alten 1.11.8.7 nicht.


Grüße,
Cassio

 

[Kokusnuss]

Vielen Dank.
Dann weiß ich jetzt bescheid. Schade, aber habs auch erstmal anders hinbekommen, zwar speicherintensiver, aber zum üben reicht es erstmal.

LG

 

[Kokusnuss]

Ich habe wiedermal ne Frage. ;-D

Gibt es in Bascom die Möglichkeit den Inhalt von Bytes in eine long-Variable zu schieben um den Inhalt später wiederzuverwenden?
Ich würde es für das Rein- und Rausscrollen (von rechts nach links) eines Textes anwenden wollen.
Ich habe mit shift schon vieles ausprobiert, mit overlay ebenfalls, aber es waren bisher keine wirklichen Erfolge zu verzeichnen.

LG
Kokusnuss

 

[Cassio]

Hallo !

Ich denke, das ist keine Frage von BASCOM oder einer anderen Programmiersprache.

Natürlich kannst du ein Byte in eine Long-Variable kopieren.... und darin auch munter hin und her schieben!
Was meinst du denn jetzt genau?

Beispiel:

Dim I As Byte
Dim L As Long


I = 15            'binär= 0000_1111

L = I
' binäre Ausgabe via Print: 00000000000000000000000000001111

Shift L , Left , 8
' binäre Ausgabe via Print: 00000000000000000000111100000000

Shift L , Left , 8
' binäre Ausgabe via Print: 00000000000011110000000000000000

Shift L , Left , 8
' binäre Ausgabe via Print: 00001111000000000000000000000000


[B]Rotate[/B] L , Left , 8
' binäre Ausgabe via Print: 00000000000000000000000000001111

Grüße,
Cassio

 

[Kokusnuss]

Ok gut.
Eine Bytevaiable hineinschieben geht. Aber wie sieht es aus, wenn ich mehrere hineinschieben möchte?
Beim Befehl L=I wird doch in das ganze long der Wert 15 (von I) geschrieben oder?
Oder werden dementsprechend nur die ersten 8 Bits des longs verändert? Ich möchte ja beispielsweise 4 oder mehr verschiedene Werte von Bytevariablen hineinschieben.
Ich hatte es mal so probiet:

Dim A As Byte
Dim B as Byte
Dim I As Byte
Dim L As Long


I = 15            'binär= 0000_1111
A = 26           'binär= 0001_1010
B = 12           'binär= 0000_1100

L = I
shift L , Left , 8
L = A
Shift  L , Left , 8
L = B 
Shift L , Left , 8

Und da hatte ich immer das Problem, dass irgendwie immer nur das letzte Byte (also der Wert 12) im long stand und die anderen 3 Bytes im Long hatten irgendwie die Wertigkeit Null. Hab ich da etwas falsch gemacht?

Liebe Grüße
Kokusnuss

 

[Cassio]

Hallo!

Wo ist das Problem?

Das Einfachste ist doch, du addierst die Werte einfach NACH dem Shiften.

Dim A As Byte
Dim B as Byte
Dim I As Byte
Dim L As Long


I = 15            'binär= 0000_1111
A = 26           'binär= 0001_1010
B = 12           'binär= 0000_1100

L = I
shift L , Left , 8

L =[B] L + A[/B]
Shift  L , Left , 8

L = [B]L + B[/B] 
Shift L , Left , 8

Die Printausgabe sollte dann folgendes anzeigen:
0000_1111_0001_1010_0000_1100 (natürlich ohne die Unterstriche )


Grüße,
Cassio

 

[Kokusnuss]

Dankeschön.
Man bin ich bl...
Na logisch.
Ich denke so werde ich das rein und raussrcollen des Textes ohne weiteres hinbekommen. *gg*

thx für eure schnellen Hilfen

Lieber Gruß
Kokusnuss

 

[Cassio]

Hallo!

Nun ja.... manchmal denkt man einfach nur zu kompliziert.

Da ein Long aus vier Byte besteht, kannst du auch mittels OVERLAY einzeln auf die vier Byte im Long zugreifen.

Dim L As Long
Dim L_byte(4) As Byte At L Overlay


L = 2141851452           'MAXIMAL: 2147483648 !!!

Print "Long=      " ; Bin(L)
Print "L_byte 1= " ; Bin(L_byte([COLOR="#FF0000"]1[/COLOR]))
Print "L_byte 2= " ; Bin(L_byte([COLOR="#0000CD"]2[/COLOR]))
Print "L_byte 3= " ; Bin(L_byte([COLOR="#008000"]3[/COLOR]))
Print "L_byte 4= " ; Bin(L_byte([COLOR="#FFA500"]4[/COLOR]))

Die Ausgabe sollte dann so aussehen:

Long=     [COLOR="#FFA500"]01111111[/COLOR][COLOR="#008000"]10101010[/COLOR][COLOR="#0000CD"]00001111[/COLOR][COLOR="#FF0000"]00111100[/COLOR]
L_byte 1= [COLOR="#FF0000"]00111100[/COLOR]
L_byte 2= [COLOR="#0000CD"]00001111[/COLOR]
L_byte 3= [COLOR="#008000"]10101010[/COLOR]
L_byte 4= [COLOR="#FFA500"]01111111[/COLOR]

Wie du siehst, erfolgt das "Abgreifen" der einzelnen Bytes dann natürlich von "rechts"... also bei Bit 0 !
Alles klar soweit?

Grüße,
Cassio

 

[LotadaC]

Arrays werden mit 1 beginnend indiziert (in Bascom)? (L_byte(1..4))
8faches schieben: schiebt/rotiert Bascom da wirklich 8mal (je alle beteiligten bytes), oder wird der Code zu mehreren "move"s optimiert?
(wird das überhaupt "in einem Abwasch" in den Rechenregistern erledigt, oder werden die einzelnen bytes permanent zwischen Rechenregistern und SRAM hin und hergeschoben?)
in Bascom sollte das einschieben eines Byte doch dann auch so gehen (bei der obigen overlay-Dimensionierung):
L_byte(4)=L_byte(3)
L_byte(3)=L_byte(2)
L_byte(2)=L_byte(1)
L_byte(1)=einzuschiebendesByte

 

[Cassio]

Arrays werden mit 1 beginnend indiziert (in Bascom)? (L_byte(1..4))

Hallo!

Nun, dass ist ja nicht grundsätzlich so!

Wenn man im Header des Programms die Zuweisung:
Config Base = 0
einfügt, beginnt die Indizierung mit "0" und nicht mit "1"!
Dies kann bei automatischen Zugriffen auf Daten schon sehr nützlich sein.


Wie das Schieben der Bits von BASCOM aus tatsächlich umgesetzt wird, entzieht sich jetzt aber meiner Kenntnis.
Da kann sich wohl nur jemand zu äußern, den das schon mal ganz genau interessiert hat.


Grüße,
Cassio

 

[Kokusnuss]

Hallo zusammen.

Vielen Dank euch beiden.
Ich habe jetzt hinbekommen eine (bzw. mehrere) longvariablen zu erstellen, die die Daten des auszugebenen Strings beinhalten.
Das Darstellen, sowie das Rausscrollen bekomme ich ebenfalls hin. Allerdings habe ich schon vieles versucht, um den Text reinzuscrollen.
Leider habe ich nur den Ansatz dies mit "shiftout ..... 0 , i " zu realisieren, doch leider bietet Bascom ja nicht an dort eine Variable einzusetzen.

Nun hätte ich eine andere Idee, doch weiß nicht, ob dies möglich ist.
Und zwar kann man die ersten Daten einer Longvariable an die letzte Stelle einer anderen Longvariable schieben?
(z.B. 00001010 00001111 -----> 00000000 00000000
Long1 Long2
danch soll
00000000 10100000 -----> 11110000 00000000
Long1 Long2)

Gibt es Befehle oder eine Algorythmus wie man dies realisieren kann?
Oder gibt es gar eine einfachere Methode den Text rein- und raus- zu scrollen?

Liebe Grüße
Kokusnuss

 

[Cassio]

Hallo Kokosnuss!

Warum möchtest du denn den Inhalt einer Variablen bitweise in eine Andere transportieren?

Spontan würde mir jetzt einfallen, dass du einfach die Long-Variable bitweise abfragst......
und dies dann bitweise rausschiebst.
Vielleicht hilft dir das ja weiter?

So müsstest du die eigentliche Long-Variable gar nicht hin und her schieben bzw. kopieren.
Mein Gedanke zum möglichen Ansatz wäre:

Dim I As Byte


For I = 0 To 31
Shiftout Data_4094.I , Clock_4094 , Zeichen , 0 , 1
Next I

Ist natürlich keine Endlösung, aber vielleicht bringt es dich auf Ideen......

Grüße,
Cassio

 

[Kokusnuss]

Hallo Cassio,

also der Gedanke die Longvariable bitweise abzufragen ist sehr gut.
Die Idee mit

"Shiftout Data_4094.I , Clock_4094 , Zeichen , 0 , 1"
funktioniert so leider nicht. Ich habe es so probiert

"Shiftout Data_4094 , Clock_4094 , Zeichen.I , 0 , 32"
Doch da habe das gleiche Resultat.
Nämlich, dass das Bild sich nicht verändert auf irgendeine Zahl für I.
Wie genau kann man denn die Bits des Longs abfragen? (Mit "Longvariable.I" ?)

Liebe Grüße
Kokusnuss

 

[Cassio]

"Shiftout Data_4094.I , Clock_4094 , Zeichen , 0 , 1"

Bullshit!


Hallo !

Ja, natürlich..... die Longvariable ist ja auch "Zeichen" und nicht "Data_4094".
Von daher passt mein Beispiel auf die Schnelle auch nicht.

Das Prinzip und was ich machen wollte, scheinst du aber trotzdem verstanden zu haben.

Hm, OK, wenn das mit den einzelnen Bits bei Shiftout nicht geht, dann musst du eben einen Umweg machen.
Kopiere die Bits einzeln aus der Long-Variable in eine Byte-Variable, welche dann mit SHIFTOUT immer verwendet wird.

Andere Ideen müsste ich selber erst mal ausprobieren.....

Grüße,
Cassio


PS: Das Einfachste und Beste wäre doch, du besorgst dir mal eine Vollversion von BASCOM!
Dann klappt es zum Beispiel auch mit dem Variablenaufruf für die Bits bei SHIFTOUT.

 

[Kokusnuss]

Alles klaro.
Ich werde mal weiter rumprobieren ob ich das reinshiften und rausshiften gleichzeitig irgendwie hinbekomme.
Ich steh bestimmt wieder nur aufm Schlauch und es ist total einfach.
Wenn ich etwas erreichen sollte, schreib ich hier mal meine Lösung. *gg*

Ich finde es übrigens sehr schön, dass du und einige andere hier so hilfsbereit seid und mir, sowie anderen so gut helft.
Großes Kompliment an euch.

Liebe Grüße
Kokusnuss

 

[Grandpa]

...
PS: Das Einfachste und Beste wäre doch, du besorgst dir mal eine Vollversion von BASCOM!
Dann klappt es zum Beispiel auch mit dem Variablenaufruf für die Bits bei SHIFTOUT.

Recht hat er. Die 69 oder 79 Euro sind auf jeden Fall gut angelegt. Da sollte man nun wirklich nicht sparen.

 

[TrueNEO]

Hallo,

eine Idee wäre vielleicht noch wenn Du ein Array definieren würdest.
Arrays mit Byte, Integer, Word und Long sind Möglich.
Dann müsste das Programm so aussehen.

DIM Zeichen(Anzahl) as Long

For I = 1 to Anzahl
Shiftout Data_4094 , Clock_4094 , Zeichen(I) , 0 , 32
Next I

LG

 

[Cassio]

DIM Zeichen(Anzahl) as Long

Hallo NEO!

Ich glaube nicht, dass es so funktioniert.

Letzlich hätte er damit doch nur mehrere Long-Variablen "nebeneinander", die lediglich alle den selben "Vornamen" haben.
Er möchte aber innerhalb EINER Long-Variable die Bits einzeln auslesen.

Grüße,
Cassio