Forum: Mikrocontroller und Digitale Elektronik 4/8-Hamming-Code nach Integer konvertieren


von Thomas H. (thoern)


Lesenswert?

Hallo,

ich möchte einen 4/8 Hamming-Code in C nach Integer konvertieren. Kennt 
jemand einen Algorithmus, mit dem das möglich ist?

Beispiel für die 4/8-Hamming-Codierung:

10101100 -> 0
10101010 -> 1
10101001 -> 2
10100101 -> 3
10100011 -> 4
...

Eine unelegante Möglichkeit wäre in etwa so:
1
uint8_t hamming_decode(byte hamming_byte) {
2
  switch (hamming_byte) {
3
    case B10101100:
4
      return 0;
5
    case B10101010:
6
      return 1;
7
    case 10101001:
8
      return 2;
9
    case 10100101:
10
      return 3;
11
    case 10100011:
12
      return 4;
13
    ....
14
  }
15
}

Ziemliche Menge fehleranfälliger Tipparbeitb bei 70 Kombinationen. Wie 
kann man das eleganter lösen?
Klar, mit einem Algorithmus, der das berechnet - ist aber ziemlich lange 
her und ich blicke nicht mehr, wie das funktioniert...

Wäre für Tipps/Hilfe dankbar.

Gruß,
thoern

: Bearbeitet durch User
von Johann L. (gjlayde) Benutzerseite


Lesenswert?

Thomas H. schrieb:
> Ziemliche Menge fehleranfälliger Tipparbeitb bei 70 Kombinationen.
> Wie kann man das eleganter lösen?

Schreib für deinen PC in der Programmiersprache deines Vertrauens ein 
Programm, dass den entsprechenden C-Code oder -Tabelle generiert, z.b. 
als hamming_decode.c/h.  Dann verwendest du dieses hamming_decode Modul 
in deinem eigentlichen Projekt.

von Wolfgang (Gast)


Lesenswert?

Thomas H. schrieb:
> Beispiel für die 4/8-Hamming-Codierung:
>
> 10101100 -> 0
> 10101010 -> 1

Bit du sicher, dass da da überhauüt einen Hamming-Code erwischt hast?
Der sollte doch einen Hamming-Abstand von 3 zwischen den Codeworten 
haben.

von Georg (Gast)


Lesenswert?

Thomas H. schrieb:
> Wäre für Tipps/Hilfe dankbar

Das sind ja nur 256 Werte - da ist eine Tabelle am einfachsten, und so 
nebenbei auch am schnellsten.

Georg

von Thomas H. (thoern)


Lesenswert?

Servus!

Erst einmal Danke an alle!

Wolfgang schrieb:
> Bit du sicher, dass da da überhauüt einen Hamming-Code erwischt hast?
> Der sollte doch einen Hamming-Abstand von 3 zwischen den Codeworten
> haben.

Nein, so richtig sicher bin ich mir da nicht wirklich. Soweit ich weiss, 
ist aber euch einen Hamming-Abstand von 4 möglich. Aber ich bin da nicht 
wirklich in der Materie...

Georg schrieb:
> Das sind ja nur 256 Werte - da ist eine Tabelle am einfachsten, und so
> nebenbei auch am schnellsten.
>
> Georg

Tatsächlich sind es nur ca. 64 Werte, da bei diesem Code tatsächlich nur 
6 Bits zur Wertdarstellung verwendet werden.
Was meinst du mit Tabelle? Ein zweidimensionales Array? Sowas Schönes 
wie Hashes gibt es ja in C nicht. Eine Zuordnungstabelle wäre schon 
nützlich.

Was ist mit meiner Funktion aus dem ersten Thread? Ist die ineffizient? 
Das Ganze soll auf einem Arduino Uno laufen und der Speicherplatz im 
SRAM ist dort echt begrenzt. Deshalb, je weniger Speicherbedarf umso 
besser.

Danke vorerst und Gruß,
thoern

: Bearbeitet durch User
von Georg (Gast)


Lesenswert?

Thomas H. schrieb:
> Ein zweidimensionales Array?

Wieso 2 Dimensionen? Eine reicht doch - 256 Einträge, die 
Zugriffsadresse ist eben der Code. Einträge sind entweder das Ergebnis 
(integer) oder ein Fehlercode für die Kombinationen, die nicht gültig 
sind. Da bekommt man eine Überprüfung auf Fehler kostenlos mit. 
Ausserdem ist eine solche Tabelle unschlagbar flexibel, man kann ja für 
jede mögliche Eingangs-Kombination eintragen was man will.

Das einzige Problem ist die Grösse solcher Tabellen, bei 16 bit Code 
müsste sie schon 65536 Einträge haben - aber die 256 hier sind Pipifax.

Georg

von Thomas H. (thoern)


Lesenswert?

Georg schrieb:
> Thomas H. schrieb:
> Ein zweidimensionales Array?
>
> Wieso 2 Dimensionen? Eine reicht doch - 256 Einträge, die
> Zugriffsadresse ist eben der Code. Einträge sind entweder das Ergebnis
> (integer) oder ein Fehlercode für die Kombinationen, die nicht gültig
> sind. Da bekommt man eine Überprüfung auf Fehler kostenlos mit.
> Ausserdem ist eine solche Tabelle unschlagbar flexibel, man kann ja für
> jede mögliche Eingangs-Kombination eintragen was man will.
>
> Das einzige Problem ist die Grösse solcher Tabellen, bei 16 bit Code
> müsste sie schon 65536 Einträge haben - aber die 256 hier sind Pipifax.
>
> Georg

Hast du ein Codebeispiel für eine derartige Tabelle in. C?

von Dominik J. (d-r-j)


Lesenswert?

Thomas H. schrieb:
> Wolfgang schrieb:
>> Bit du sicher, dass da da überhauüt einen Hamming-Code erwischt hast?
>> Der sollte doch einen Hamming-Abstand von 3 zwischen den Codeworten
>> haben.
>
> Nein, so richtig sicher bin ich mir da nicht wirklich. Soweit ich weiss,
> ist aber euch einen Hamming-Abstand von 4 möglich. Aber ich bin da nicht
> wirklich in der Materie...


Bedeutet Hamming-Abstand von 4 nicht, dass es statt 3 sogar 4 
unterschiede geben muss(jeder Wert unterscheidet sich von jedem anderen 
an 4 Stellen)?



Thomas H. schrieb:
> Tatsächlich sind es nur ca. 64 Werte, da bei diesem Code tatsächlich nur
> 6 Bits zur Wertdarstellung verwendet werden.

Von 8 Bit werden 4 Bit für die Fehlerkorrektur benötigt. Dann bleiben 
nur 4 Bit übrig, also 16 Werte.


Bei nur 2 unterschiede zwischen den Werten kann es doch keine 
Fehlerkorrektur geben, höchstens Fehlererkennung(bei 1 Fehler).
Ist aber nicht Fehlerkorrektur das wichtige am Hamming-Code?



Oder verwechsle ich jetzt was?

von Thomas H. (thoern)


Lesenswert?

Dominik J. schrieb:
> Bei nur 2 unterschiede zwischen den Werten kann es doch keine
> Fehlerkorrektur geben, höchstens Fehlererkennung(bei 1 Fehler).
> Ist aber nicht Fehlerkorrektur das wichtige am Hamming-Code?
>
> Oder verwechsle ich jetzt was?

wie gesagt, bin ich auch nicht der Experte. Vier/Achtel-Codierung 
bedeutet, dass in der jeder Bytedarstellung jeder Ziffer immer exakt 4 
'1'-en und 4 '0'-en vorkommen:

10101100 -> 0
10101010 -> 1
10101001 -> 2
10100101 -> 3
10100011 -> 4
...

Somit kann jeder Wert einfach grepüft werden, da bei jeder Zahl 4 * '1' 
und 4 x'0' vorhanden sein muss. Ist das nicht der Fall -> 
Übertragungsfehler.

Gruß,
thoern

: Bearbeitet durch User
von Georg (Gast)


Lesenswert?

Thomas H. schrieb:
> Hast du ein Codebeispiel für eine derartige Tabelle in. C?

Nein, ist auch nicht sinnvoll, wenn du nicht einmal den Zugriff auf ein 
einfaches Array verstehst, da fehlen die einfachsten Grundlagen. Googel 
mal nach "lookup table c". Aber besser erst mal ein C-Einführungsbuch 
lesen.

Georg

von Marc V. (Firma: Vescomp) (logarithmus)


Lesenswert?

Thomas H. schrieb:
> Tatsächlich sind es nur ca. 64 Werte, da bei diesem Code tatsächlich nur
> 6 Bits zur Wertdarstellung verwendet werden.

Thomas H. schrieb:
> wie gesagt, bin ich auch nicht der Experte. Vier/Achtel-Codierung
> bedeutet, dass in der jeder Bytedarstellung jeder Ziffer immer exakt 4
> '1'-en und 4 '0'-en vorkommen:

 Aha.
 64 Werte ?
 Und 0x3F (63d) wird wie dargestellt ?

von Thomas H. (thoern)


Lesenswert?

Georg schrieb:
> Thomas H. schrieb:
>> Hast du ein Codebeispiel für eine derartige Tabelle in. C?
>
> Nein, ist auch nicht sinnvoll, wenn du nicht einmal den Zugriff auf ein
> einfaches Array verstehst, da fehlen die einfachsten Grundlagen. Googel
> mal nach "lookup table c". Aber besser erst mal ein C-Einführungsbuch
> lesen.
>
> Georg

Ach, gute Idee! Vielleicht sollten wir das zusammen lesen. Dann könntest 
du künftig vielleicht mit konkreten Beispielen helfen, statt mit 
pauschalen Floskeln heißen Dampf zu verbreiten.

Eigentlich wollte ich ein Abdriften der Diskussion in diese Richtung 
vermeiden...

Gruß, thoern

von Thomas H. (thoern)


Lesenswert?

Marc V. schrieb:
> Aha.
>  64 Werte ?
>  Und 0x3F (63d) wird wie dargestellt ?

So: 00110011

Aber was tut das jetzt zur Sache?

: Bearbeitet durch User
von Marc V. (Firma: Vescomp) (logarithmus)


Lesenswert?

Thomas H. schrieb:
>>  Und 0x3F (63d) wird wie dargestellt ?
>
> So: 00110011
>
> Aber was tut das jetzt zur Sache?

 Nichts, nur ist das 0x33.
 Mit 6 bit für Wert kann es nicht 4 '1'-en und 4 '0'-en geben.
 Oder es kann keine 64 Werte geben.
 Suche dir eines davon aus.

: Bearbeitet durch User
von Thomas H. (thoern)


Lesenswert?

Marc V. schrieb:
> Nichts, nur ist das 0x33.
>  Mit 6 bit für Wert kann es nicht 4 '1'-en und 4 '0'-en geben.
>  Oder es kann keine 64 Werte geben.
>  Suche dir eines davon aus.

Mann, ihr legt aber auch alles auf die Goldwaage :-(

Aber egal, nachdem hier jetzt niemand eine einfachere oder zumindest 
eine bessere Lösung aufzeigen konnte, habe ich es mit der Funktion, die 
ich im Eröffnungsthread angedeutet habe, gelöst.

Funktioniert einwandfrei!

Vielen Dank für eure Hilfe!

: Bearbeitet durch User
von Georg (Gast)


Lesenswert?

Thomas H. schrieb:
> Eigentlich wollte ich ein Abdriften der Diskussion in diese Richtung
> vermeiden...

Und ich vermeide es, Leute zu unterstützen, die völlig lernunwillig sind 
und nur fertige Lösungen abkopieren wollen. Ende der Diskussion.

Aber wahrscheinlich hättest du ja eine Lookup Table sowieso nicht 
verstanden.

Georg

von Dergute W. (derguteweka)


Lesenswert?

Moin,

Wattngedoens um 2 Zeilen C code.
1
const uint8_t hammingtable[256]={0xff, 0xff, 0xff, ... ... };
2
3
...
4
5
hamming_out = hammingtable[hamming_in];

Gruss
WK

von CPP (Gast)


Lesenswert?

Und Wenn man C++14 nimmt und constexpr, dann kann man sich die Tabelle 
gleich vom Compiler als const Arra im Flash ausrechnen lassen.

Für Pur C gäbe es noch die Möglichkeit über den Preprozessor zu gehen.

z.b. Gibt es im Atmel Software Framework eine Implenetierung mit der man 
ein Macro bis zu 256 fach aufrufen kann.

von Thomas H. (thoern)


Lesenswert?

Hallo,

Dergute W. schrieb:
> Moin,
>
> Wattngedoens um 2 Zeilen C code.
> const uint8_t hammingtable[256]={0xff, 0xff, 0xff, ... ... };
>
> ...
>
> hamming_out = hammingtable[hamming_in];
> Gruss
> WK

Endlich mal einer, der konkret wird. Vielen Dank dafür :-)
Ich hatte ursprünglich auch ein Array dieser Art in Erwägung gezogen, 
allerdings bräuchte ich die Zuordnung genau anders herum, also vom 
Hamming-Code zum Int. Bei diesem Vorschlag müsste ich alle Werte des 
Arrays in einer Schleife durchlaufen, um dann den Index zu bestimmen. 
Das scheint mir auch nicht so richtig elegant. Da finde ich meine 
Funktion im Eröffnungsthread anschaulicher, ja sogar effizienter.
Deshalb ja meine Frage, ob es in C andere Mechanismen gibt, dies 
einfacher und sauberer abzubilden (so etwas wie ein Hash in Perl wäre 
optimal).


@Georg(Gast)
Und ja, meine C-Kenntnisse sind 25 Jahre lang verstaubt, dennoch komme 
ich nicht auf der Wurstsuppe dahergeschwommen....

Gruß,
thoern

: Bearbeitet durch User
von Marc V. (Firma: Vescomp) (logarithmus)


Lesenswert?

Thomas H. schrieb:
> Ich hatte ursprünglich auch ein Array dieser Art in Erwägung gezogen,
> allerdings bräuchte ich die Zuordnung genau anders herum, also vom
> Hamming-Code zum Int. Bei diesem Vorschlag müsste ich alle Werte des
> Arrays in einer Schleife durchlaufen, um dann den Index zu bestimmen.
> Das scheint mir auch nicht so richtig elegant. Da finde ich meine
> Funktion im Eröffnungsthread anschaulicher, ja sogar effizienter.

 Manoman.
 Das kann nicht dein Ernst sein ?

: Bearbeitet durch User
von CPP (Gast)


Lesenswert?

Es sind wohl weniger die C Kenntnisse, die verstaubt sind.


Thomas H. schrieb:
> Ich hatte ursprünglich auch ein Array dieser Art in Erwägung gezogen,
> allerdings bräuchte ich die Zuordnung genau anders herum, also vom
> Hamming-Code zum Int.

Tabellen kann man auch um 90° Grad drehen. Transponieren heist das.
Natürlich muss man umrechnen

https://de.wikipedia.org/wiki/Transponierte_Matrix

von Wolfgang (Gast)


Lesenswert?

Thomas H. schrieb:
> Nein, so richtig sicher bin ich mir da nicht wirklich. Soweit ich weiss,
> ist aber euch einen Hamming-Abstand von 4 möglich. Aber ich bin da nicht
> wirklich in der Materie...

Die Codes in deinem Tabellenausschnitt haben aber einen Hammingabstand 
zwischen 2 und 4. Damit kannst du keine Korrektur von Einzelfehlern 
machen.

Thomas H. schrieb:
> 4/8 Hamming-Code

Thomas H. schrieb:
> Vier/Achtel-Codierung bedeutet, dass in der jeder Bytedarstellung
> jeder Ziffer immer exakt 4 '1'-en und 4 '0'-en vorkommen

Wie kommst du eigentlich auf diese Code-Bezeichnung. In der von Hamming 
eingeführte Bezeichnungsweise müsste die wohl eher als "Hamming(8,6)" 
bezeichnet werden, wobei die Zahlen für eine Codelänge von 8 Bit und die 
6 Datenbits stehen. Die restlichen 2 Bit sind die hinzugefügten 
Paritätsbits.

von Dergute W. (derguteweka)


Lesenswert?

Moin,

Thomas H. schrieb:
> Ich hatte ursprünglich auch ein Array dieser Art in Erwägung gezogen,
> allerdings bräuchte ich die Zuordnung genau anders herum, also vom
> Hamming-Code zum Int.

Ja, stimmt. Dann sieht der Code natuerlich voellig anders aus:
1
const int invershammingtable[256]={0xff, 0xff, 0xff, ... ... };
2
3
...
4
5
myinteger = invershammingtable[hamming_out];

SCNR,
WK

von Marc V. (Firma: Vescomp) (logarithmus)


Lesenswert?

Dergute W. schrieb:
> Ja, stimmt. Dann sieht der Code natuerlich voellig anders aus:

 Ja, das ist natürlich etwas total anderes, in seinem Fall praktisch
 überhaupt nicht zu gebrauchen...

von Wolfgang (Gast)


Lesenswert?

Marc V. schrieb:
> Ja, das ist natürlich etwas total anderes, in seinem Fall praktisch
>  überhaupt nicht zu gebrauchen...

Kannst du deine Aussage auch durch irgendwelche hilftreichen Argumente 
untermauern?

von Marc V. (Firma: Vescomp) (logarithmus)


Lesenswert?

Wolfgang schrieb:
> Kannst du deine Aussage auch durch irgendwelche hilftreichen Argumente
> untermauern?

 Ja.
 Wie CPP schon schrieb, Tabellen kann man transponieren.

 IQ aber nicht.

von Dergute W. (derguteweka)


Lesenswert?

Moin,

Wolfgang schrieb:
> Kannst du deine Aussage auch durch irgendwelche hilftreichen Argumente
> untermauern?

Das ist analog zu dem Umstand zu sehen, dass es von Ostern bis 
Weihnachten auch laenger dauert, als von Weihnachten bis Ostern. ;-P

SCNR,
WK

von Thomas H. (thoern)


Lesenswert?

Ahh Super. Da steht ja "invershammingtable[256]". Man, dass ich da nicht 
gleich selbst drauf gekommen bin. Ihr habt recht! Da ist wohl doch mehr 
verstaubt, als nur das C. Dann hol ich mal jetzt den Staubsauger raus...

Schönes Wochenende
(und denkt nich soviel über Arrays und Lookup-Tables nach)

von Wolfgang (Gast)


Lesenswert?

Marc V. schrieb:
> Wie CPP schon schrieb, Tabellen kann man transponieren.

Und was hat das mit deiner Aussage zu tun, dass der genannte 
invershammingtable-Vektor angeblich nicht brauchbar ist, um das Problem 
von Thomas zur Abbildung der Hamming-Codewort auf die Integers mit 
minimalem Rechenaufwand zu lösen?

von Marc V. (Firma: Vescomp) (logarithmus)


Lesenswert?

Wolfgang schrieb:
> Und was hat das mit deiner Aussage zu tun, dass der genannte
> invershammingtable-Vektor angeblich nicht brauchbar ist, um das Problem
> von Thomas zur Abbildung der Hamming-Codewort auf die Integers mit
> minimalem Rechenaufwand zu lösen?

Dergute W. schrieb:
> Das ist analog zu dem Umstand zu sehen, dass es von Ostern bis
> Weihnachten auch laenger dauert, als von Weihnachten bis Ostern. ;-P

 Und analog zu dem Umstand, dass IQ nicht transponiert werden kann.

von GanzSchlauer (Gast)


Lesenswert?

Wolfgang schrieb:
> Und was hat das mit deiner Aussage zu tun, dass der genannte
> invershammingtable-Vektor angeblich nicht brauchbar ist, um das Problem
> von Thomas zur Abbildung der Hamming-Codewort auf die Integers mit
> minimalem Rechenaufwand zu lösen?

Schon mal was von Sarkasmus gehört? ;-)

von Thomas H. (thoern)


Lesenswert?

Hallo Wolfgang,

da du mir einer der Wenigen zu schein seinst, die ernsthaft helfen 
wollen oder zumindest Interesse zeigen, will ich nicht so unhöflich sein 
und deine Fragen kommentarlos stehen lassen.

Wolfgang schrieb:
> Thomas H. schrieb:
>> Nein, so richtig sicher bin ich mir da nicht wirklich. Soweit ich weiss,
>> ist aber euch einen Hamming-Abstand von 4 möglich. Aber ich bin da nicht
>> wirklich in der Materie...
>
> Die Codes in deinem Tabellenausschnitt haben aber einen Hammingabstand
> zwischen 2 und 4. Damit kannst du keine Korrektur von Einzelfehlern
> machen.

Das habe ich inzwischen auch festgestellt. Weshalb ich mir gar nicht 
sicher bin, ob man hier wirklich von Hamming-Code sprechen kann.


>
> Thomas H. schrieb:
>> 4/8 Hamming-Code
>
> Thomas H. schrieb:
>> Vier/Achtel-Codierung bedeutet, dass in der jeder Bytedarstellung
>> jeder Ziffer immer exakt 4 '1'-en und 4 '0'-en vorkommen
>
> Wie kommst du eigentlich auf diese Code-Bezeichnung. In der von Hamming
> eingeführte Bezeichnungsweise müsste die wohl eher als "Hamming(8,6)"
> bezeichnet werden, wobei die Zahlen für eine Codelänge von 8 Bit und die
> 6 Datenbits stehen. Die restlichen 2 Bit sind die hinzugefügten
> Paritätsbits.

Das steht in dieser Spezifikation auf Seite 8,Kapitel 2.5 Data 
Protection:
http://www.nmra.org/sites/default/files/s-9.3.2_2012_12_10.pdf

Mir geht es aber gar nicht darum, ob das jetzt ein Hamming-Code und wie 
die Abstände sind. Auch die Fehlerkorrektur ist momentan nicht relevant 
für mich. Mir geht es ausschließlich darum, die Codeworte möglichst 
effizient nach Integer zu konvertieren. Aber das hast du ja bereits 
erkannt. Meine Lösung hatte ich ja schon im Eröffnungspost geschrieben. 
Ich wollte eigentlich nur Tipps zur Optimierung haben, naja, 
Pustekuchen! Ich kann aber durchaus mit meiner Lösung leben.

Vielen Dank und schönen Gruß,
Thomas

von Marc V. (Firma: Vescomp) (logarithmus)


Lesenswert?

Thomas H. schrieb:
> da du mir einer der Wenigen zu schein seinst, die ernsthaft helfen
> wollen oder zumindest Interesse zeigen, will ich nicht so unhöflich sein
> und deine Fragen kommentarlos stehen lassen.

> erkannt. Meine Lösung hatte ich ja schon im Eröffnungspost geschrieben.
> Ich wollte eigentlich nur Tipps zur Optimierung haben, naja,
> Pustekuchen! Ich kann aber durchaus mit meiner Lösung leben.


Dergute W. schrieb:
> , stimmt. Dann sieht der Code natuerlich voellig anders aus:
1
 const int invershammingtable[256]={0xff, 0xff, 0xff, ... ... };
2
 
3
 ...
4
 
5
 myinteger = invershammingtable[hamming_out];

 Besser und schneller als die oben gepostete gibt es nicht.
 Einmal addieren, einmal lesen.

 Und deine "Lösung" ist gar keine Lösung, sondern Blödsinn.

 Bei einem Wert von z.B. 255 werden 254 Werte vorher geprüft.
 Oder andersrum:
 Bei grösstmöglichem Wert werden alle Werte die kleiner sind, vorher
 geprüft und dann wird trotzdem ein konstanter Wert zugewiesen, nicht
 etwa berechnet.

 Warum dann nicht gleich diesen Wert aus einer Tabelle auslesen ?

von Wolfgang (Gast)


Lesenswert?

Thomas H. schrieb:
> Ich wollte eigentlich nur Tipps zur Optimierung haben, naja,
> Pustekuchen!

Das sehe ich nicht so.

Die Lösung mit dem invershammingtable-Array löst dein Problem 
ausgesprochen effizient und wenn du die Tabelle im Flash ablegst, kostet 
dich das nichtmal irgendwelchen evtl. knappen RAM.

von Thomas H. (thoern)


Lesenswert?

Hallo Marc,

Marc V. schrieb:
> Und deine "Lösung" ist gar keine Lösung, sondern Blödsinn.

klar ist meine Lösung Blödsinnn. Was soll da auch groß rauskommen, 
wenn...

Marc V. schrieb:
> Tabellen kann man transponieren.
>
>  IQ aber nicht.

...kein IQ vorhanden ist.

Deshalb empfehle ich der Nachwelt auch auf deine expertiert-fundierte 
Lösung zu setzen.

Gruß!

von Thomas H. (thoern)


Lesenswert?

Wolfgang schrieb:
> Das sehe ich nicht so.
>
> Die Lösung mit dem invershammingtable-Array löst dein Problem
> ausgesprochen effizient und wenn du die Tabelle im Flash ablegst, kostet
> dich das nichtmal irgendwelchen evtl. knappen RAM.

Ja, sie würde das tun, wenn die Anforderung beispielsweise lauten würde:
1. Gib mir zum Integer 4 den zugehörgigen Bytecode zurück

Sie lautet aber genau anders herum:
2. Gib mir zum Bytecode 10100011 den zugehörigen Integer zurück

1. ist unbestritten hocheffizient

Bei 2. wüsste ich nicht, wie ich an den Integer - ohne eine Schleife 
über die Werte laufen zu lassen - rankommen sollte.

Gruß!

: Bearbeitet durch User
von Marc V. (Firma: Vescomp) (logarithmus)


Lesenswert?

Thomas H. schrieb:
> Sie lautet aber genau anders herum:
> 2. Gib mir zum Bytecode 10100011 den zugehörigen Integer zurück
1
 myinteger = invershammingtable[0b10100011];

 Du scheinst wirklich Probleme mit IQ zu haben...

: Bearbeitet durch User
von Dergute W. (derguteweka)


Lesenswert?

Moin,

Thomas H. schrieb:
> Bei 2. wüsste ich nicht, wie ich an den Integer - ohne eine Schleife
> über die Werte laufen zu lassen - rankommen sollte.

WTF???!!?

Nach dem du ja deine Codetabelle gepostet hast, kau' ich dir mal die 
ersten Bissen vor:

1
 uint8_t iht[256];
2
3
memset(iht,0xff,256); // tabelle mit 0xff initialiseren tun.
4
5
iht[0xAC]=0x00;
6
iht[0xAA]=0x01;
7
iht[0xA9]=0x02;
8
iht[0xA5]=0x03;
9
iht[0xa3]=0x04;
10
....
11
iht[0x33]=0x3f;
12
13
14
//so und jetzt:
15
16
myinteger = iht[vierachtcode]; // 4/8code rein -> integer raus

Wenn myinteger jetzt einem Wert ausserhalb von 0..63; z.b. 0xff hat, 
dann war der Eingangsbytecode halt ungueltig oder einer der 
Spezialcodes.

Das ist doch echt keine Raketenwissenschaft?!?

Gruss
WK

von Anfänger (Gast)


Lesenswert?

Thomas H. schrieb:
> 4/8 Hamming-Code in C nach Integer konvertieren.

Was genau ist ein Hammig-Code bzw. was kann man damit machen?

von Dieter F. (Gast)


Lesenswert?


von Johann L. (gjlayde) Benutzerseite


Lesenswert?

Thomas H. schrieb:
> Sie lautet aber genau anders herum:
> 2. Gib mir zum Bytecode 10100011 den zugehörigen Integer zurück
>
> Bei 2. wüsste ich nicht, wie ich an den Integer - ohne eine Schleife
> über die Werte laufen zu lassen - rankommen sollte.

Du schreibst ein Programm auf dem PC, das alle Werte durchnudelt und dir 
die passende C-Source mit Lookup-Tabelle aufbaut, die 10100011 auf 
abbildet.

Bei lediglich 2**8 Werten ist die Performace auf dem PC ziemlich 
wurscht, und du kannst ein einfaches, dir genehmes Verfahren verwenden.

Wie bereits oben beschrieben, verwendest du diese auto-Generierte Quelle 
in deinem Projekt, und auch wenn die Performance auf dem Host nicht toll 
ist, spielt das zur Laufzeit deines Projekts keine Banane, weil es nur 
die Tabelle sieht.

Sowas in ein Makefile einzubauen ist auch keine Quantenphsik... alles 
was du brauchst ist ein Host-Compiler wie z.B. GCC.

von Thomas H. (thoern)


Lesenswert?

Hi,

Marc V. schrieb:
> Thomas H. schrieb:
>> Sie lautet aber genau anders herum:
>> 2. Gib mir zum Bytecode 10100011 den zugehörigen Integer zurück
>
>
1
>  myinteger = invershammingtable[0b10100011];
2
>
>
>  Du scheinst wirklich Probleme mit IQ zu haben...

Genau das war mein Problem. Ich ging davon aus, dass ein Array-Index in 
C ein Integer sein muss. Ich werde das ausprobieren.

IQ definiert sich für mich dennoch anders, als mit C-Expertise zu 
glänzen. Trorzdem Danke!

von Thomas H. (thoern)


Lesenswert?

Dergute W. schrieb:
>
> Das ist doch echt keine Raketenwissenschaft?!?
>
> Gruss
> WK

Danke für das Beispiel. Genau so etwas hatte ich mir erhofft. Wie 
gesagt, mein C ist zu lange her, um alles parat zu haben. Auch das werde 
ich ausprobieren...

Gruß,
thoern

: Bearbeitet durch User
von Marc V. (Firma: Vescomp) (logarithmus)


Lesenswert?

Thomas H. schrieb:
> Genau das war mein Problem. Ich ging davon aus, dass ein Array-Index in
> C ein Integer sein muss. Ich werde das ausprobieren.
>
> IQ definiert sich für mich dennoch anders, als mit C-Expertise zu
> glänzen. Trorzdem Danke!

 Bedanke dich bei
Dergute W. schrieb:
> Ja, stimmt. Dann sieht der Code natuerlich voellig anders aus:
> const int invershammingtable[256]={0xff, 0xff, 0xff, ... ... };

 Und das mit IQ war sowieso nicht ganz ernst gemeint...

: Bearbeitet durch User
von Wolfgang (Gast)


Lesenswert?

Anfänger schrieb:
> Thomas H. schrieb:
>> 4/8 Hamming-Code in C nach Integer konvertieren.
>
> Was genau ist ein Hammig-Code bzw. was kann man damit machen?

Wikipedia kennst du schon?
https://de.wikipedia.org/wiki/Hamming-Code

Mit dem Code wird redundante Information zu den eigentlichen Nutzdaten 
hinzugefügt, so dass (je nach Hamming-Abstand) Übertragungsfehler 
erkannt und evtl. korrigiert werden können.

Du weisst nicht, was der Hamming-Abstand zweier Codeworten ist?
Guckst du hier https://de.wikipedia.org/wiki/Hamming-Abstand

von Thomas H. (thoern)


Lesenswert?

Hallo zusammen!

ich habe eure Tipps beherzigt, die Tabelle erzeugt und im Flash 
abgelegt.
Funktioniert einwandfrei:
1
// Store 4/8 code table in flash memory
2
// Retrieve a value: pgm_read_byte(&codeTab48[index]), i.e.:
3
// pgm_read_byte(&codeTab48[51]
4
// pgm_read_byte(&codeTab48[0b00110011]
5
const uint8_t  codeTab48[256] PROGMEM = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
6
                                          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
7
                                          0xFF, 0xFF, 0xFF, 0x33, 0xFF, 0xFF, 0xFF, 0x34, 0xFF, 0x35,
8
                                          0x36, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3A,
9
                                          0xFF, 0xFF, 0xFF, 0x3B, 0xFF, 0x3C, 0x37, 0xFF, 0xFF, 0xFF,
10
                                          0xFF, 0x3F, 0xFF, 0x3D, 0x38, 0xFF, 0xFF, 0x3E, 0x39, 0xFF,
11
                                          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
12
                                          0xFF, 0x24, 0xFF, 0xFF, 0xFF, 0x23, 0xFF, 0x22, 0x21, 0xFF,
13
                                          0xFF, 0xFF, 0xFF, 0x1F, 0xFF, 0x1E, 0x20, 0xFF, 0xFF, 0x1D,
14
                                          0x1C, 0xFF, 0x1B, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x19,
15
                                          0xFF, 0x18, 0x1A, 0xFF, 0xFF, 0x17, 0xFF, 0xFF, 0x16, 0xFF,
16
                                          0xFF, 0xFF, 0xFF, 0x25, 0x14, 0xFF, 0x13, 0xFF, 0xFF, 0xFF,
17
                                          0x32, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
18
                                          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0E,
19
                                          0xFF, 0x0D, 0x0C, 0xFF, 0xFF, 0xFF, 0xFF, 0x0A, 0xFF, 0x09,
20
                                          0x0B, 0xFF, 0xFF, 0x08, 0x07, 0xFF, 0x06, 0xFF, 0xFF, 0xFF,
21
                                          0xFF, 0xFF, 0xFF, 0x04, 0xFF, 0x03, 0x05, 0xFF, 0xFF, 0x02,
22
                                          0x01, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x10, 0xFF,
23
                                          0x11, 0xFF, 0xFF, 0xFF, 0x12, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
24
                                          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x2B, 0x30, 0xFF,
25
                                          0xFF, 0x2A, 0x2F, 0xFF, 0x31, 0xFF, 0xFF, 0xFF, 0xFF, 0x29,
26
                                          0x2E, 0xFF, 0x2D, 0xFF, 0xFF, 0xFF, 0x2C, 0xFF, 0xFF, 0xFF,
27
                                          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x28, 0xFF, 0x27, 0xFF,
28
                                          0xFF, 0xFF, 0x26, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
29
                                          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
30
                                          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
31
                                        };

Vielen Dank nochmals für die Unterstützung!
Thomas

Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.