Im Buffer größere Hex-ketten schreiben!

whitelion · Beitrag von **whitelion** » 28.05.2008 15:13

Ich suche eine möglichkeit um meinen buffer mit selbstdefinierten hexwerten zu füllen. allerdings fine ich immernur "pokeD" und damit kann ich ja nur 8 bytes in dem buffer schieben... das ist ntürlich zu wenig! ich bin erst am überlegen gewesen, ob ich den pokeD befehl öfters anwende, was aber offensichtlich recht umständlich ist.... gibts da nicht einen besseren weg ?? und falls nein, wie kann ich diese idee möglichst geschickt integrieren.
Außerdem würde ich gerne mal wissen wie man den inhalt des buffers ausgespuckt bekommt.

Code: Alles auswählen

Buffer = AllocateMemory(5000)

PokeD(Buffer, $0102030405060708)

OpenConsole()
PrintN("Der Buffer: "+Hex(Buffer)) ; wirft immer nur 3 bytes aus!! 
Delay(100000)

Kaeru Gaman · Beitrag von **Kaeru Gaman** » 28.05.2008 15:23

also, mit PokeD bist du absolut auf dem Holzweg!
ein Hexadezimalwert ist ein Integer, also kannst du höchstens PokeQ benutzen.

...und woher bekommst du Hexadezimalwerte mit mehr als 64bit?

wenn es sich um ASCII- bzw. Unicode-Werte handelt,
würde ich den Buffer auch Byte- bzw. Word-weise füllen,
dafür haben die Götter die Schleifen erschaffen...

Andreas_S · Beitrag von **Andreas_S** » 28.05.2008 15:25

Code: Alles auswählen

Buffer = AllocateMemory(5000)

PokeQ(Buffer, $0102030405060708)
Debug PeekQ(Buffer)					; DEZ
Debug HexQ(PeekQ(Buffer))			; HEX

Ähm... du weist schon dass 'buffer' im Sinne keine Variable ist sondern ein Pointer?
Mit deinem Code verlangst du nur die Adresse in einer Hexadezimalzahl...

PokeD() würde deinen Hexawert ganz normal reinschreiben, doch beim lesen wird das ganze als eine Double gehandhabt und umgewandelt... 1 Bit Vorzeichen, ...
Da kommst du auf ganz andere Werte...

whitelion · Beitrag von **whitelion** » 28.05.2008 16:09

hmm, also ich reserviere mit meinem code ja einen speicher(buffer) der 5000 bytes groß ist... so viel hab ich kappiert. offensichtlich legt PB selber (konfortabler weise)fest, wo der speicher erstellt wird.
so weit so gut. mit meinem code lese ich jetzt quasi nur die speicheradresse des 1 bytes, richtig? wenn ich jetzt mit einem ram-editor an diese adresse gehen würde, fände ich den anfang meines buffers ?

wenn ich jetzt diesen buffer mit hexwerten befüllen möchte, muss es sich ja nicht darum handeln, dass ich unbedingt befehle auf 64bit-basis abarbeiten will. - oder ich verstehe die aussage nicht Kaeru hinaus möchte !?
jedenfalls hat das schon einen sinnvollenhintergrund, dass mein buffer befüllt wird

also ich müsste jetzt quasi eine schleife erstellen und dann byteweise den buffer beschreiben. wie spreche ich denn überhaupt den buffer an einer bstimmten stelle an? ich hab mal folgendes versucht, was vermutlich totaler quatsch ist... außerdem funktionierts nicht

Code: Alles auswählen

Buffer = AllocateMemory(50)
NewHexValue1 = $020304

bufferadress = @Buffer
x=0
Repeat
PokeB(bufferadress, NewHexValue1)
x+1
bufferadress = @Buffer+x
Until x = 50 

Debug PeekQ(Buffer)               ; DEZ
Debug HexQ(PeekQ(Buffer))         ; HEX

;OpenConsole()
;PrintN("Der Buffer: "+Hex(Buffer))
Delay(100000)

Selbst erkannte fehler:

- NewHexValue1 ist immer konstant, was natürlcih dazu führt, dass immer das erste byte daraus geschrieben wird. außerdem kann ich nicht mehr als 3 bytes in dieser variable definieren.

- hängt sich offensichtlich in der schleife auf...

ts-soft · Beitrag von **ts-soft** » 28.05.2008 16:18

Code: Alles auswählen

*Mem = AllocateMemory(50)

MyByte.b = 100

If *Mem
  For I = 0 To 49
    PokeB(*Mem + I, MyByte)
  Next
  
  For I = 0 To 49
    Debug PeekB(*Mem + I)
    Debug "$" + Hex(PeekB(*Mem + I))
  Next
  
  FreeMemory(*Mem)
EndIf

Hex ist lediglich eine andere Art der Darstellung, im Speicher stehen
immer die Werte.
Eine Speicherstelle ist ein Byte groß, so das man für jedes Byte einen
Offset von 1 zum Pointer nehmen kann. Bei Long sollte man einen offset
von 4 (bzw. besser SizeOf(long)) usw.

Ich hoffe mal, ich habe das Problem richtig interpretiert

Andreas_S · Beitrag von **Andreas_S** » 28.05.2008 17:01

1. du hast einen Pointer und dann pointest du auf deinen anderen Pointer
>> bufferadress = @Buffer
mach das zu

Code: Alles auswählen

*bufferadress = Buffer

2. mach statt einer unübersichtlichen Repeat-Until eine For-Next
>>

Code: Alles auswählen

Repeat
...
Until x = 50

zu

Code: Alles auswählen

For i = 0 to 50
...
Next

3. um ein bisschen Rechenarbeit zu ersparen, mach einfach

Code: Alles auswählen

*bufferadress + 1

aber am besten gleich für alle Datentypen

Code: Alles auswählen

*bufferadress + sizeof(Byte)

4. Du hast hier eine 3 Byte Zahl und willst sie mit PokeB() auf den Speicher schreiben...
Am besten zerschneidest du die Zahl immer in ein Byte und zwar mit Shift...

Code: Alles auswählen

num = $123456
byte.b = 0

For i = 1 To 3
	byte = num - (num >> 8) << 8
	num >> 8
	
	Debug Hex(byte)
Next

Wenn du jetzt alles richtig zusammenflickst dann sollte es gehen

Alles klar?

whitelion · Beitrag von **whitelion** » 28.05.2008 23:10

Code: Alles auswählen

*Mem = AllocateMemory(50)

MyByte.b = 100

If *Mem
  For I = 0 To 49
    PokeB(*Mem + I, MyByte)
  Next
 
  For I = 0 To 49
    Debug PeekB(*Mem + I)
    Debug "$" + Hex(PeekB(*Mem + I))
  Next
 
  FreeMemory(*Mem)
EndIf

der code erzeugt bei mir einen fehler:
puebasic_compilation0 ... hat einen fehler festgestellt...

ts-soft · Beitrag von **ts-soft** » 28.05.2008 23:15

whitelion hat geschrieben: der code erzeugt bei mir einen fehler:
puebasic_compilation0 ... hat einen fehler festgestellt...

Das liegt aber nicht am Code! Weiß jetzt aber nicht was da verkehrt ist,
vielleicht hängt da noch irgendein Compilerprozeß, oder Deine PB Installation
ist fehlerhaft?

whitelion · Beitrag von **whitelion** » 28.05.2008 23:41

du hattest recht ... irgendwas hat meine installation geschrottet.... zwar gingen andere programme noch, aber deins ging nach einem neuinstall...

also ich hab das jetzt nochmal angeschaut, und bei dem beispiel von dir verstehe ich so weit alles .... allerdings zeigt das "nur" wie ich vernünftig den buffer nacheinander verschiebe.

offen bleibt wie ich jetzt eine variable oben angebe die länger ist als 4 bytes und diese nacheinader in den buffer schiebe. zumindest habe ich dann deine aussage nciht verstanden wie ich das mit den bytes anstellen soll.

der zweite code demonstriert das was wichtig für mich ist, nämlich das durchrasseln von jeweils einem hexbyte. verstehe aber immernoch nciht wie ich das mit z.B. 50 bytes anstellen kann. eine variable lässt ja nur 4 bytes zu. das würde also schon klappen, wenn ich mehr bytes in einer variablen definieren könnte.

Kaeru Gaman · Beitrag von **Kaeru Gaman** » 29.05.2008 01:27

ja nee...
du ratterst eben den ganzen buffer byteweise durch, ob du nun 50 oder 100 byte hast.

wozu meinst du denn, eine variable mit mehr bytes zu brauchen?
wenn du mit dem bufferpointer nicht klarkommst, nimm halt ein Array oder nen String mit ner fixen Länge....

als einzelne zahl wirst du das wohl kaum brauchen, oder willst du irgendwas extremes mathematisches berechnen?
dann bräuchtest du sowieso besondere routinen, die dir die berechnung machen,
weil deine FPU nur mit 80bit berechnen und mit 64bit ausgeben kann.