Gray- Code convertieren

dengel

Mitglied
Hallo,

ich suche eine Funktion in C, die einen Binären Wert in einen Gray-Code convertiert! Gibt es es eine Funktion in einer Standardlibrary oder kennt jemand etwas selbst geschriebenes?
Der Binäre Wert und der Gray- Code sind vom Typ unsigned Char.

Danke für eure Hilfe!

Gruß dengel
 
Moin moin,

Mir ist leider keine Funktion bekannt.
Ne einfache Convertierung ist aber erstmal auch nicht möglich, da die Bits im Gray Code keine Wertigkeit besitzen.
Solltest vielleicht eine LUT erstellen. sind ja nur 256 einträge:-)

wahrscheinlich keine wirkliche Hilfe aber durch das einfache bildungsgesetz vom GrayCode sollte das mit Cut & Past recht schnell zu machen sein.
Man könnte die LUT auch zur Laufzeit dynamisch erstellen lassen, durch nen Algorithmus sollte auch :-)
Gruss Michael
 
Hab mal was geschrieben. Ist zwar nicht sehr gut getestet, sollte aber korrekte Werte liefern. (Also ohne Gewähr :-))
Code:
// GrayCode.cpp
  
  #include <iostream>
  
  long int GetGrayCode(long int iIn);
  unsigned char GetBitValue(long int liMod, unsigned char ucBitPlace);
  void OutputGreyCodeBinary(unsigned long int uliGrey);
  
  using namespace std;
  
  int main(int argc, char* argv[])
  {
  	long int liInNumber, liGrayCode;
  	bool bCont = true;
  
  	while(bCont)
  	{
  	
  		//Zahl einlesen
  		cout << "Bitte Zahl eingeben (Beenden mit 0): ";
  
  		cin >> liInNumber;
  
  		if(liInNumber == 0)
  		{
  			cout << "Beendet!" << endl;
  			bCont = false;
  		}
  		else
  		{
  			//GrayCode ermitteln
  			liGrayCode = GetGrayCode(liInNumber);
  
  			//GrayCode ausgeben
  			cout << "GreyCode binär: ";
  			OutputGreyCodeBinary(liGrayCode);
  			cout << endl;
  		}
  	}
  
  	return 0;
  }
  
  long int GetGrayCode(long int liIn)
  {
  	long int liMod, liGray = 0;
  	unsigned char ucBitPlace = 0, ucCounter = 0, ucBitVal;
  
  	do
  	{
  		ucCounter++;
  
  		liMod = liIn % (ucCounter * 4);
  		
  		ucBitVal = GetBitValue(liMod, ucBitPlace);
  		if(ucBitVal)
  		{
  			liGray |= (1 << ucBitPlace);
  		}
  
  		ucBitPlace++;
  
  	}while(liIn > (1 << ucCounter));
  
  	return liGray;
  }
  
  unsigned char GetBitValue(long int liModIn, unsigned char ucBit)
  {
  	unsigned char ucBitVal = 0;
  	long int liLower, liUpper, liMod = liModIn + 1;
  
  	liLower = 1 << ucBit;
  	liUpper = 4;
  	for(int i = 0; i < ucBit; i++)
  	{
  		liUpper = (liUpper * 2) - 1;
  	}
  
  	if((liMod > liLower) && (liMod < liUpper))
  		ucBitVal = 1;
  	
  	return ucBitVal;
  }
  
  void OutputGreyCodeBinary(unsigned long int uliGrey)
  {
  	unsigned long int uliMask = 0x80000000;
  
  	//Nullen am Anfang überspringen
  	while((uliGrey & uliMask) == 0)
  		uliMask >>= 1;
  
  	while(uliMask > 0)
  	{
  		if((uliGrey & uliMask) == 0)
  			cout << '0';
  		else
  			cout << '1';
  		uliMask >>= 1;
  	}
  }
 
Hallo jokey2,

habe deinen Code ausprobiert, doch leider kommen die falschen Werte heraus:

Code:
bin					gray
0x01 0000 0001   0x01 0000 0001 
0x02 0000 0010	   0x01 0000 0001
0x03 0000 0011	   0x02 0000 0010
0x04 0000 0100	   0x02 0000 0010
0x05 0000 0101	   0x07 0000 0111
0x06 0000 0110	   0x05 0000 0101
0x07 0000 0111	   0x04 0000 0100
0x08 0000 1000	   0x04 0000 0100
0x09 0000 1001	   0x0D 0000 1101
0x0A 0000 1010	  0x0A 0000 1010
0x0B 0000 1011	  0x0E 0000 1110
0x0C 0000 1100	  0x0A 0000 1010
0x0D 0000 1101	  0x0B 0000 1011
0x0E 0000 1110	  0x09 0000 1001
0x0F 0000 1111	  0x08 0000 1000
Gruß dengel
 
Zuletzt bearbeitet:
Zurück