Ich kann hier keine Null bilden aus der Bytefolge...soll ..

[funkheld]

Hallo, wie kann man bitte daraus eine Null bilden? Die Bytereihenfolge kenne ich nicht.
Wer kann hier mal helfen?

Danke.
Gruss

-------------------------------------------------------------------------------------------------------------------------------------------
..du hast ja Recht. dass man aus den Zahlen ein Muster erkennt ist nicht unbedingt trivial. Man muss austesten wie herum die Bits und die Bytes zu den Stücken des Puzzles zusammengesetzt werden:

00 C1 22 15 94 54 22 C1 kann man zB so zusammensetzen:

***
* *
* * *
* * *
* *
***
----------------------------------------------------------------------------------------------------------------------------------------

[ts-soft]

Code: Alles auswählen

  00 C1 22 15 94 54 22 C1
- 00 C1 22 15 94 54 22 C1
= 00 00 00 00 00 00 00 00

[funkheld]

Hmmm...

Die Null soll irgendwie aus der Bitfolge optisch als Ascii erkennbar sein.

Gruss

[matbal]

Was ich erkennen kann, ist, daß von den 8 Bits einer Zeile die vorderen mit den hinteren 4 Bits vertauscht werden müssen. Diese Zeile habe ich noch auskommentiert. So siehst du das gespeicherte Bitmuster. Wenn du die auskommentierte Zeile rein nimmst, werden beide Hälften vertauscht und es sieht richtig aus.

Theoretisch könnte die Null auch auf dem Kopf stehen oder spiegelverkehrt sein. Das kann man bei einer Null nicht erkennen...

Code: Alles auswählen

EnableExplicit

OpenConsole()

Define Zeile$ = "00 C1 22 15 94 54 22 C1"

Define byte.a, i, Zeichen$, bits$

For i = 1 To 8
   Zeichen$ = StringField(Zeile$, i, " ")       ; Einzelnes Byte im Hexformat
   
   byte = Val("$" + Zeichen$)                   ; in Zahl umwandeln
   bits$ = RSet(Bin(byte),8,"0")                ; Zahl in Bits umwandeln
   
   ;bits$ = Right(bits$, 4) + Left(bits$, 4)     ; Linke und rechte Hälfte müssen vertauscht werden
      
   ; Damit man das Bitmuster besser erkennen kann
   bits$ = ReplaceString(bits$, "0", " ")       ; Nullen ersetzen
   bits$ = ReplaceString(bits$, "1", "+")       ; Einsen ersetzen
   
   PrintN(bits$)                                ; Bitmuster zeigen
Next i

Input()

[funkheld]

Au man danke.
Da wäre ich nie drauf gekommen.

Wie kann man die Nibble jetzt bitte mit Purebasic vertauschen:
h00 hC1 h22 h15 h94 h54 h22 hC1

wenn ich jetzt bitte aus einer Binärdatei die Werte einlesen und vertauscht wieder abspeichern?

Vielen dank.
Gruss

[matbal]

Du mußt die untere Hälfte des Bytes nach oben schieben und die obere Hälfte nach unten schieben.

Beim Verschieben aller Bits eines Bytes fällt ein Teil heraus, der nicht mehr in die Variable paßt. Also beim Linksschieben landet der untere Teil oben und der obere Teile fällt raus. Beim Rechtsschieben landet der linke Teil rechts und der rechte Teil fällt raus. Daher kann man sich das Maskieren der Nibbles sparen.

Die beiden Nibbles kann man mit OR wieder zusammenfügen.

Code: Alles auswählen

EnableExplicit

Procedure.a SwapNibble(byte.a)
   Protected.a a, b
   
   a = byte << 4
   b = byte >> 4
   
   ProcedureReturn a | b
   
EndProcedure

Define byte.a

If ReadFile(0, "c:\Temp\abc.bin")         ; Quelldatei
   If CreateFile(1, "c:\Temp\abc.out")    ; Zieldatei
      While Not Eof(0)                    
         byte = ReadAsciiCharacter(0)     ; Byte lesen
         byte = SwapNibble(byte)          ; Nibbles tauschen
         WriteByte(1, byte)               ; Byte schreiben
      Wend
      CloseFile(1)
   EndIf
   CloseFile(0)
EndIf

[funkheld]

Ja, danke.

Ich habe mir ein Abgebrochen.
Es geht ja mit wenig Code in Purebasic.

Danke.
Gruss

[Bisonte]

Wenn du erzählen würdest, was das ganze am Ende werden soll, wäre es einfacher zu helfen...
So müssen die Helfer "rumstochern"....

Also wo kommen deine "Zahlenreihen" her ... und was genau soll mit denen passieren .... ?

[funkheld]

Ja, die Buchstaben sind so vorgegeben um in einem FPGA geladen zu werden auf einen Screen.

Nun habe ich festgestellt, das mit dem obigen Programm die Buchstaben Spiegelverkehrt sind.
Es ist mir bei dem "A" gar nicht aufgefallen, weil die nibble gleich sind.

Beim "B" ist es spiegelverkehrt.

Wer kann das bitte einmal ändern?

Code: Alles auswählen

EnableExplicit

OpenConsole()

Define Zeile$ = " F3 24 24 E3 24 24 F3 "

Define byte.a, i, Zeichen$, bits$

For i = 1 To 8
   Zeichen$ = StringField(Zeile$, i, " ")       ; Einzelnes Byte im Hexformat
   
   byte = Val("$" + Zeichen$)                   ; in Zahl umwandeln
   bits$ = RSet(Bin(byte),8,"0")                ; Zahl in Bits umwandeln
   
   ;bits$ = Right(bits$, 4) + Left(bits$, 4)     ; Linke und rechte Hälfte müssen vertauscht werden
      
   ; Damit man das Bitmuster besser erkennen kann
   bits$ = ReplaceString(bits$, "0", " ")       ; Nullen ersetzen
   bits$ = ReplaceString(bits$, "1", "+")       ; Einsen ersetzen
   
   PrintN(bits$)                                ; Bitmuster zeigen
 Next i
 
 For i = 1 To 8
   Zeichen$ = StringField(Zeile$, i, " ")       ; Einzelnes Byte im Hexformat
   
   byte = Val("$" + Zeichen$)                   ; in Zahl umwandeln
   bits$ = RSet(Bin(byte),8,"0")                ; Zahl in Bits umwandeln
   
   bits$ = Right(bits$, 4) + Left(bits$, 4)     ; Linke und rechte Hälfte müssen vertauscht werden
      
   ; Damit man das Bitmuster besser erkennen kann
   bits$ = ReplaceString(bits$, "0", " ")       ; Nullen ersetzen
   bits$ = ReplaceString(bits$, "1", "+")       ; Einsen ersetzen
   
   PrintN(bits$)                                ; Bitmuster zeigen
Next i

Input()

Danke.

Gruss

[matbal]

Das Spiegeln entspricht dem rückwärts Schreiben der Bits. Mit ReverseString() kannst das machen. Einfach diese Zeile noch einfügen:

Code: Alles auswählen

bits$ = ReverseString(bits$)

EDIT:

Wenn du die Bits im Byte direkt tauschen willst, müssen sie einzeln maskiert und danach an die neue Stelle verschoben werden.

Alle Bits im Byte vertauschen.

Code: Alles auswählen

Procedure.a ReverseBits(byte.a)
   
   Protected result.a
   
   result | (byte & %00000001) << 7 
   result | (byte & %00000010) << 5
   result | (byte & %00000100) << 3
   result | (byte & %00001000) << 1
   result | (byte & %00010000) >> 1
   result | (byte & %00100000) >> 3
   result | (byte & %01000000) >> 5
   result | (byte & %10000000) >> 7
   
   ProcedureReturn result
   
EndProcedure

Alle Bits im Byte rückwärts schreiben und anschließend Nibbles tauschen, ist das gleiche wie nur Bits in den beiden Nibbles rückwärts schreiben. Damit sollten die Bits in einem Rutsch in der richtigen Reihenfolge sein:

Code: Alles auswählen

Procedure.a ReverseNibbles(byte.a)
   
   Protected result.a
   
   result | (byte & %00000001) << 3 
   result | (byte & %00000010) << 1
   result | (byte & %00000100) >> 1
   result | (byte & %00001000) >> 3
   result | (byte & %00010000) << 3
   result | (byte & %00100000) << 1
   result | (byte & %01000000) >> 1
   result | (byte & %10000000) >> 3
   
   ProcedureReturn result
   
EndProcedure