neues Byte aus Byte-Array erstellen

[BoondockDuck]

 Dim Ausgabe As String * 8
 Ausgabe = "1634HELP"

 Dim Beginn_zeichen As Word , Ende_zeichen As Word , Db_zeiger As Word
 Dim Bz As Word
 Dim Tl As Byte
 Dim Ez As Byte
 Dim Dat(56) As Byte
 Dim Einzelzeichen As String * 1

 Tl = Len(ausgabe)

 Dim A As Byte , B As Byte
 B = 1

 For A = 1 To Tl
  Einzelzeichen = Mid(ausgabe , A , 1)
  Ez = Asc(einzelzeichen)

  Bz = Ez - 32

  Beginn_zeichen = Bz * 7
  Ende_zeichen = Beginn_zeichen + 6

  For Db_zeiger = Beginn_zeichen To Ende_zeichen
   Dat(b) = Lookup(db_zeiger , Zeichensatz)
   Print Dat(b)
   Incr B
  Next Db_zeiger
 Next A

Zeichensatz:                                                'Segment A,B,C,D,E,F,G - sortiert nach ASCII
Data 0 , 0 , 0 , 0 , 0 , 0 , 0                              'SPACE DEC32
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 1                              '-     DEC45
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 1 , 1 , 1 , 1 , 1 , 1 , 0                              '0     DEC48
Data 0 , 1 , 1 , 0 , 0 , 0 , 0                              '1     DEC49
Data 1 , 1 , 0 , 1 , 1 , 0 , 1                              '2     DEC50
Data 1 , 1 , 1 , 1 , 0 , 0 , 1                              '3     DEC51
Data 0 , 1 , 1 , 0 , 0 , 1 , 1                              '4     DEC52
Data 1 , 0 , 1 , 1 , 0 , 1 , 1                              '5     DEC53
Data 1 , 0 , 1 , 1 , 1 , 1 , 1                              '6     DEC54
Data 1 , 1 , 1 , 0 , 0 , 0 , 0                              '7     DEC55
Data 1 , 1 , 1 , 1 , 1 , 1 , 1                              '8     DEC56
Data 1 , 1 , 1 , 0 , 0 , 1 , 1,                             '9     DEC57
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 1 , 0 , 0 , 1 , 1 , 1 , 1                              'E     DEC69
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 1 , 1 , 0 , 1 , 1 , 1                              'H     DEC72
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 1 , 1 , 1 , 0                              'L     DEC76
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 1 , 1 , 0 , 0 , 1 , 1 , 1                              'P     DEC80
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 0 , 0 , 0 , 0
Data 0 , 0 , 0 , 1 , 0 , 0 , 0                              '_     DEC95

Hi
der Code gibt mir aus einer Datenbank abhängig vom String "Ausgabe" korrekt Daten aus "Zeichensatz" aus. (Im Zeichensatz sind so viele "leere Zeilen" weil die Position momentan noch abhängig von der ASCII-Nummer des Zeichens ist. Ich benötige aber eigentlich nur 17 Zeichen... im Moment funktioniert es so aber auch)
Die Bits aus Zeichensatz werdem im Array dat(n) als Byte gespeichert (bit-array geht ja anscheinend nicht??).

d.h. ich habe 56 Byte die die Werte 0 oder 1 annehmen.

Diese 56 Byte sollen (als Bit) in 7 Byte geteilt werden und zwar so:

Byte1: dat(1) , dat(8)  , dat(15) , dat(22) , dat(29) , dat(36) , dat(43) , dat(50)
Byte2: dat(2) , dat(9)  , dat(16) , dat(23) , dat(30) , dat(37) , dat(44) , dat(51)
Byte3: dat(3) , dat(10) , dat(17) , dat(24) , dat(31) , dat(38) , dat(45) , dat(52)
Byte4: dat(4) , dat(11) , dat(18) , dat(25) , dat(32) , dat(39) , dat(46) , dat(53)
Byte5: dat(5) , dat(12) , dat(19) , dat(26) , dat(33) , dat(40) , dat(47) , dat(54)
Byte6: dat(6) , dat(13) , dat(20) , dat(27) , dat(34) , dat(41) , dat(48) , dat(55)
Byte7: dat(7) , dat(14) , dat(21) , dat(28) , dat(35) , dat(42) , dat(49) , dat(56)

Ich weiß nur nicht wie ich das machen soll.
Gibts irgendwo ein Tutorial dass einem die Basics am Arbeiten mit Variabeln erklärt? Also Was es für welche gibt ist klar, aber so Sachen wie Variabelntypen umwandeln, verschiedene Variabeln zusammenfügen etc. Ich habe da nichts gefunden was mir weiterhilft.

Gruß

[MeckPommER]

Hallo,

wäre es nicht erheblich einfacher, wenn du deinen Zeichensatz gleich in Bytes ablegst, anstatt in einzelnen Bits? Anstatt

Data 1 , 1 , 0 , 0 , 1 , 1 , 1

könntest du gleich

Data 103

schreiben, und ersparst du eine Menge Sucherei in deinem Zeichensatz. Außerdem hättest du gleich alle benötigten Bits im gelesenen Byte.

[BoondockDuck]

äh vielleicht hast du da recht, ich muss darüber aber nochmal genau nachdenken ... denn pro zeichen sinds halt nur 7 bit und nicht 8
Also ob das mir dann den rest nicht durcheinander wirft.

Mit diesem Monster geht es: nicht schön, aber funktioniert.
Kann man natürlich noch in eine schleife packen.
Ich verstehe nur eines nicht
ein byte kann man also in bits zerlegen indem man byte.x (x=0-7) schreibt.
Dat(n) ist auch ein byte, da muss ich aber dat(n).8 schreiben ???
wieso?

Dig0.7 = Dat(1).8
Dig1.7 = Dat(2).8
Dig2.7 = Dat(3).8
Dig3.7 = Dat(4).8
Dig4.7 = Dat(5).8
Dig5.7 = Dat(6).8
Dig6.7 = Dat(7).8

Dig0.6 = Dat(8).8
Dig1.6 = Dat(9).8
Dig2.6 = Dat(10).8
Dig3.6 = Dat(11).8
Dig4.6 = Dat(12).8
Dig5.6 = Dat(13).8
Dig6.6 = Dat(14).8

Dig0.5 = Dat(15).8
Dig1.5 = Dat(16).8
Dig2.5 = Dat(17).8
Dig3.5 = Dat(18).8
Dig4.5 = Dat(19).8
Dig5.5 = Dat(20).8
Dig6.5 = Dat(21).8

Dig0.4 = Dat(22).8
Dig1.4 = Dat(23).8
Dig2.4 = Dat(24).8
Dig3.4 = Dat(25).8
Dig4.4 = Dat(26).8
Dig5.4 = Dat(27).8
Dig6.4 = Dat(28).8

Dig0.3 = Dat(29).8
Dig1.3 = Dat(30).8
Dig2.3 = Dat(31).8
Dig3.3 = Dat(32).8
Dig4.3 = Dat(33).8
Dig5.3 = Dat(34).8
Dig6.3 = Dat(35).8

Dig0.2 = Dat(36).8
Dig1.2 = Dat(37).8
Dig2.2 = Dat(38).8
Dig3.2 = Dat(39).8
Dig4.2 = Dat(40).8
Dig5.2 = Dat(41).8
Dig6.2 = Dat(42).8

Dig0.1 = Dat(43).8
Dig1.1 = Dat(44).8
Dig2.1 = Dat(45).8
Dig3.1 = Dat(46).8
Dig4.1 = Dat(47).8
Dig5.1 = Dat(48).8
Dig6.1 = Dat(49).8

Dig0.0 = Dat(50).8
Dig1.0 = Dat(51).8
Dig2.0 = Dat(52).8
Dig3.0 = Dat(53).8
Dig4.0 = Dat(54).8
Dig5.0 = Dat(55).8
Dig6.0 = Dat(56).8

Dig7 = 0

[-tomas-]

Anstatt
Data 1 , 1 , 0 , 0 , 1 , 1 , 1
könntest du gleich
Data 103
schreiben

noch augenfreundlicher ist die Schreibweise:
Data &B1100111

Aber aufpassen, Bascom ist der sehr eigen!! Als Beispiel ein kurzel Schnipsel:

Dim I As Byte , J As Byte

Const A = &B110_0111

I = A
Print I ; "  " ; A

Restore Test

Read I
Read J
Print I ; "   " ; J

End

Test:
Data &B1100111
Data &B110_0111

und hier die Ausgabe im Simulator:

103 &B1100111

103 6

Alles klar
Der Hammer ist der entfallene Unterstrich von Print A

[BoondockDuck]

@tomas
zugegeben versteh ich nicht so recht was Bascom in deinem Beispiel da anstellt.

aber naja ich habe es jetzt ja hinbekommen.
Im prinzip ist es ja einfach wenn man sich durch die bits und bytes gewühlt hat.