ä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