Hex-Wert in char-Array umwandeln?

[XP M. (xpmodder)]

Hallo allesamt!

Ich möchte einen Hex-Wert in ein char-Array umwandeln nach folgendem 
Muster:

Hex: 0x1A8D  -> char Array: {'1', 'A', '8', 'D'}

Und später möchte ich das ganze wieder umkehren.
Ich möchte damit den Hex-Wert im EEPROM speichern und das mit Werten von 
0x0 bis 0xFFFFFFFF. Mit dem Array kann ich dann jedes Zeichen an einer 
Adresse im EEPROM speichern und diese Adressen später wieder auslesen. 
So benötige ich für jeden Wert maximal 8 Adressen im EEPROM.

Wenn es eine einfachere Möglichkeit gibt einen solchen Hex-Wert im 
EEPROM zu speichern und damit nicht mehr Speicher zu belegen, bin ich 
offen für Vorschläge.

[Peter II (Gast)]

XP M. schrieb:
> Wenn es eine einfachere Möglichkeit gibt einen solchen Hex-Wert im
> EEPROM zu speichern und damit nicht mehr Speicher zu belegen, bin ich
> offen für Vorschläge

ja, einfach speichern.

Dein Hexwert sind doch auch nur Bytes und im eeprom sind Bytes. Was will 
man das konvertierten?

Was für ein Datentype hat denn dein Hex-Wert?

[Huh (Gast)]

XP M. schrieb:
> Wenn es eine einfachere Möglichkeit gibt einen solchen Hex-Wert im
> EEPROM zu speichern und damit nicht mehr Speicher zu belegen, bin ich
> offen für Vorschläge.

So wie du es geschrieben hast (0x1A8D), sieht es nach 16bit aus.
Passt also in 2 Byte (statt 8).

[Lernprozessor (Gast)]

XP M. schrieb:
> Wenn es eine einfachere Möglichkeit gibt einen solchen Hex-Wert im
> EEPROM zu speichern und damit nicht mehr Speicher zu belegen, bin ich
> offen für Vorschläge.

... und zu welchem Ergebnis bist du selbst bis jetzt gekommen?

Mit anderen Worten: hast du schon eine Eigenleistung erbracht
oder willst du gebratene Tauben in den Mund geflogen bekommen?

[Huh (Gast)]

Ich sehe gerade, selbst die 0xFFFFFFFF als Maximalwert sind nur 4 Byte!

[XP M. (xpmodder)]

Ich wollte es auch erst einfach speichern aber eine Adresse im EEPROM 
hat nur ein Byte an Speicherplatz, wie soll ich also einen Wert der 
größer als ein Byte ist dort speichern?

[Tom (Gast)]

http://www.nongnu.org/avr-libc/user-manual/group__avr__eeprom.html#ga88df934c94c037b10ebeb337a6883a74

[Lernprozessor (Gast)]

XP M. schrieb:
> wie soll ich also einen Wert der
> größer als ein Byte ist dort speichern?

Ein Byte nach dem anderen. Vom ersten bis zum letzten.
Auch grössere Werte bestehen aus einzelnen Bytes.

[Peter II (Gast)]

XP M. schrieb:
> Ich wollte es auch erst einfach speichern aber eine Adresse im EEPROM
> hat nur ein Byte an Speicherplatz, wie soll ich also einen Wert der
> größer als ein Byte ist dort speichern?

Arbeitsspeicher hat auch nur 1byte je Adresse und man kann dort viele 
Daten ablegen.

http://www.atmel.com/webdoc/avrlibcreferencemanual/group__avr__eeprom_1gac5c2be42eb170be7a26fe8b7cce4bc4d.html

Noch einmal die Frage, was hat dein Hex-Wert für ein Datentype?

[Huh (Gast)]

XP M. schrieb:
> Ich wollte es auch erst einfach speichern aber eine Adresse im
> EEPROM
> hat nur ein Byte an Speicherplatz, wie soll ich also einen Wert der
> größer als ein Byte ist dort speichern?

Wie hättest du denn deine 8 ASCII-Bytes gespeichert?

Nacheinander, stimmt's?

Genauso nacheinander speicherst du eben die Bytes.
(ohne sie vorher nach ASCII zu konvertieren)

[Johnny B. (johnnyb)]

XP M. schrieb:
> Ich wollte es auch erst einfach speichern aber eine Adresse im EEPROM
> hat nur ein Byte an Speicherplatz, wie soll ich also einen Wert der
> größer als ein Byte ist dort speichern?

Einfach in mehreren Bytes.

Am einfachsten geht es, wenn Du in C einfach ein Struct anlegst mit 
allen Daten, welche Du im EEPROM speichern willst.
Du kannst dann das ganze Struct einfach ins EEPROM schieben und von da 
auch wieder zurückholen, z.B. das Struct in ein "unsigned char" array 
casten, damit Du byteweisen Zugriff erhälst und mit sizeof kannst du die 
Grösse des structs ermitteln.

[XP M. (xpmodder)]

Der Datentyp ist uint32_t.
Ich verstehe jetzt das es Sinnlos ist den Hex-Wert zu konvertieren, aber 
wie spalte ich den Wert auf, so dass ich ihn in mehreren Adressen 
speichern kann?

[XP M. (xpmodder)]

OK. Schreibe jetzt den Wert mit eeprom_write_block in den EEPROM. Danke 
für die schnelle Hilfe!

[DraconiX (Gast)]

Eigentlich ist ja heute Mittwoch, da aber in manchen Bundesländern 
morgen Feiertag ist, ist eigentlich schon Freitag (tm) heute! ?

[Michael F. (sharpals)]

Ok ich hasse C :-)

aber in pascal geht es auch.

falls es mal kein blockwrite gibt ( der macht nämlich genau das ).

type ar_32 = array[0..3] of byte ; 

var 
    p:^arr_32;
    v:integer; / 32bit variable
    i:byte;
begin
    p:=@V; //pointer p auf V zeigen lassen
    v:=irgend ein wert;
    // schreiben
    start_eeprom(0);
    for i:=0 to 3 
      do 
        write_byte(p^[i]);

    // lesen 
    start_eeprom(0);
    for i:=0 to 3 
      do 
        p^[i]:=read_byte; 


end;

Und wenn ich dann in den speicher des eeproms schaue, finde ich in 
hexadezumale schreibweise den wert wieder .

[Wolfgang (Gast)]

Michael F. schrieb:
> Und wenn ich dann in den speicher des eeproms schaue, finde ich in
> hexadezumale schreibweise den wert wieder .

Das ist alles nur Schein.

In dem EEPROM steht das schön als Bytes. Die hexdezimale Schreibweise 
ist, wie die Bezeichnung schon sagt, nur eine Schreibweise und die kommt 
erst zum Tragen, wenn die Daten dem Nutzer in der Anzeige präsentiert 
werden sollen oder direkt für ihn lesbar sein sollen.

[Patrick J. (ho-bit-hun-ter)]

Hi

Verstehe nur ich nicht, warum man einen x-Bit-Wert aufblähen will, um 
Diesen in den Tiefen eines Speichers zu versenken?

XP M. schrieb:
> OK. Schreibe jetzt den Wert mit eeprom_write_block in den EEPROM. Danke
> für die schnelle Hilfe!

Nunja, zumindest werden die Werte jetzt, 'wie Sie kommen' im Eeprom 
versenkt, einfach durch 'Nichts ändern' eine Menge Speicherplatz gespart 
- hat man auch nicht bei jedem Problem ;)

MfG

[Tom (Gast)]

Was sprach gegen eeprom_read_dword/eeprom_write_dword, die genau für 
uint32_t gedacht sind? Zu einfach und typsicher?

[Michael F. (sharpals)]

Oder nicht bekannt :-)

Wenn aber jemand wirklich eine HEX-zahl als string machen will :

Nur braucht das den doppelten speicher.

const hex_w:array of char [0..15] = ('0','1,'2','3'...'9','A'..'F');

var 
    v:integer; / 32bit variable
    i:byte;
begin
   
    v:=irgend ein wert;
    // schreiben
    start_eeprom(0);
    for i:=7 to 0   // 32bit = 4 bit * 2 nipples >> 8 halbbytes 
      do            //  shr >> , shl << , I*4 = i shl 2
       begin         
           write_byte(hex_w[(p^[i] shr (i shl 2)) and $C]);  
       end;   

end;

[Wolfgang (Gast)]

Michael F. schrieb:
> Nur braucht das den doppelten speicher.

Nicht nur das. Zusätzlich braucht man auch noch die Routinen für das 
Kodieren und Dekodieren des Hex-Strings. Nur um einen Wert vom Typ 
uint32_t im EEPROM abzulegen und später wieder zu lesen, ist das absolut 
überflüssiger Firlefanz.

[eProfi (Gast)]

>  and $C
Magst Du mir das bitte erklären?

[Thomas E. (picalic)]

Michael F. schrieb:
> Wenn aber jemand wirklich eine HEX-zahl als string machen will :

Ist doch Kinderkram - die optimale Lösung ist, die Bits Binär als Folge 
von Einsen und Nullen in einen String im UTF16-Format zu wandeln und die 
so entstandenen Binärdaten dann im Intel-Hex Format abzuspeichern... ;)

[Michael F. (sharpals)]

Oh entschuldige , es müßte natürlich $F heißen !!!!

Es soll ja das untere halbbyte maskiert werden ...


also .... (hex_w[(p^[i] shr (i shl 2)) and $F] .....

[Johnny B. (johnnyb)]

Thomas E. schrieb:
> Michael F. schrieb:
>> Wenn aber jemand wirklich eine HEX-zahl als string machen will :
>
> Ist doch Kinderkram - die optimale Lösung ist, die Bits Binär als Folge
> von Einsen und Nullen in einen String im UTF16-Format zu wandeln und die
> so entstandenen Binärdaten dann im Intel-Hex Format abzuspeichern... ;)

Das Intel-Hex dann am besten mit Base64 in einen String wandeln und dann 
noch in ein JSON einbetten.

[Peter II (Gast)]

Johnny B. schrieb:
> Das Intel-Hex dann am besten mit Base64 in einen String wandeln und dann
> noch in ein JSON einbetten.

json ist nicht selbst erklärend, XML ist da besser geeignet.