# ANSI c in Java



## Sergunja (11. November 2004)

Hallo !
ich versuche eine Methode aus C in Java umzuwandeln.

```
#define CRC16_GEN_POL 0x8005
#define MKSHORT(a,b) ((unsigned short) (a) | ((unsigned short)(b) << 8))
/* ::---------------------------------------------------------------------
:: FN: CreateCRC; CRC in ANSI - C
:: Synopsis: static void CreateCRC(BYTE *CommData,WORD uLen)
:: Funktion: Bildung der CRC16 - Checksumme.
------------------------------------------------------------------------*/
static WORD CreateCRC(unsigned char *CommData, unsigned int uLen )
{
   unsigned short uCrc16:
   unsigned char abData[2];
   uCrc16 = 0;
   abData[0] = 0;
   while (uLen-- )
  {
      abData[1] = abData[0];
      abData[0] = *CommData++;
      if(uCrc16 & 0x8000)
      {
         uCrc16 = (uCrc16 & 0x7fff) << 1;
         uCrc16 ^= CRC16_GEN_POL;
     }
     else
    {
    uCrc16 <<= 1;
    }
    uCrc16 ^= MKSHORT (abData[0] , abData[1]);
   }
return(uCrc16);
}
```
Da ich C überhaupt nicht kenne, könnte mir einer erklären, was diese Operationen an sich bedeuten z.Bsp:
#define MKSHORT(a,b) ((unsigned short) (a) | ((unsigned short)(b) << 8)) 
und if(uCrc16 & 0x8000)

Danke für Antwort


----------



## torsch2711 (11. November 2004)

Also,
ich probiers mal (um korrekturen wird gebeten, bin schon ziemliche lange aus C raus, *hüstel, hüstel, stimmts Redwing?* (Insider: seit wann haben basistypen membervariablen ))
Ist nur eine pseudo-code Erklärung um dir ein besseres Bild zu geben, was da gemacht wird. Ich hoffe das hilft dir bei der Umsetzung, bzw. was immer du damit vor hast.


#define ist ein makro und steht für die Vorabdefinition von etwas.

du könntest genauso gut

typedef  const CRC16_GEN_POL=0x8005

in C sagen, in Java würde das 

so heissen 

static final short(oder was auch immer für ein typ) CRC16_GEN_POL=0x8005
heissen.

Ist halt ein Makro.

Für das define auf der Funktion, das bedeutet nur, dass du dieser Funktion von anfang an diese Funktionalität zuweist. (also quasi dasselbe).

das if (....) mit dem urc und einem Hexwert werden mit dem bit-operator & verundet, sprich er prüft ab, ob das flag gesetzt ist oder nicht (hier die stelle 0x8000).

wenn das der fall ist macht er wieder eine Bitoperation, sprich verundung mit diesmal mit dem dem Hexwert 0x7fff (damit erreicht er das das vorderste Bit ausmarkiert wird (sprich das was du oben abgeprüft hast und macht einen links shift um der Bits um 1 stelle, sprich der code nimmt sich das nächste bit vor und zusätzlich wird es mit dem obigen Const geXORed (^). 

Wenn das nicht der fall ist, macht er einfach nur einen linksshift um 1 bitstelle.

Dann ruft er seine oben definierte funktion MKShort auf um die werte aus den arrays
zu verodern (hab's mir jetzt nicht genau angeschaut) und wieder an der bitstelle, die betrachtet wurde ein short zu machen und das ergebnis mit urc zu verXORen.


In diesem Code wird einfach einfach ein CRC von zu sendenden char* Daten erstellt, welcher dazu dient zu überprüfen ob (wenn die Daten übersendet wurden), auf der anderen seite auch korrekt angekommen sind und wenn ein bit gekippt sein könnte es zu bemerken  und so defekte Daten vermieden werden.

Wird ja auch in dem Funktionsheader beschrieben.

Ich hoffe das bringt dich weiter.

C ist halt kein High-Level Sprache. Da macht man noch selber seine Strings (sprich char* Pointer auf einen im Speicher abgelegten character(jaja, mann arbeitet hier richtig an der Basis, kein Memory Management, alles muss man selber machen ) und man operiert auf Bitebene (geht aber auch bei Java und C++), macht man aber nicht mehr so häufig in der HighLevel entwicklung (ich lass mich auch hier wieder gerne korrigieren, klar in der Mikroprogrammierung ist dies wieder anders zu sehen, sprich hardwarenah und in der Industrie auch grösstenteils ).


Noch zur anmerkung:

 unsigned short bedeutet, das bei diesem shortwert das vorzeichen vernachlässigt wird, sprich das erste bit, kein vorzeichen ist.

| ist hier eine normale Bit-oder operation und <<ist wieder das bit shifting nach links, sprich hier 8 bits nach links.

und WORD ist ein 4 Byte (sprich 32 bit) grosser Datentyp.

Die Länge (int uLen) des "Strings" (char* commdata) musst du mitübergeben, da du wissen musst, wie lange die zu betrachtenden Daten sind, damit du nicht noch andere mitliest und somit was falsches machst.

Die Operation abd[0]=*CommData++ bedeutet soviel wie, nimm den Wert an dieser Pointerstelle im Speicher und trage in abd[0] ein, dann gehe zum nächsten character (der pointer geht im Addressbereich wieder eins (abhängig von dem typ)  weiter zum nächsten characterwert!)


Fehlt ws. jetzt die ein kleiner teil und C-Leute würden mich jetzt schlagen für diese etwas ungenau beschreibung, aber naja, ich wollte dir ja nur einen kleiner einblick verschaffen. Für Details empfehle ich ein C-Buch zur hand zu nehmen und sich mit der Sprache auseinander zu setzen, es lohnt sich wirklich. Man bekommt ein besseres Verständnis dafür, wie es unter der Haube von High Level Sprachen wie C++ und Java abgeht. Und wie es eine Stufe Hardwarenäher aussieht.


Grüsse

Torsten


----------



## Thomas Darimont (11. November 2004)

Hallo!

Versuchs mal damit:

```
package de.tutorials;

public class Cport {

	public final static short CRC16_GEN_POL = (short) 0x8005;

	public final static int makeshort(int a, int b) {
		return (int) (a | (b << 8));
	}

	static int createCRC(char[] commData, long len) {
		int uCrc16 = 0;
		char abData[] = new char[2];

		abData[0] = 0;
		int i = 0;
		while (len-- >= 0) {
			abData[1] = abData[0];
			abData[0] = commData[i++];
			if ((uCrc16 & 0x8000) != 0) {
				uCrc16 = (uCrc16 & 0x7fff) << 1;
				uCrc16 ^= CRC16_GEN_POL;
			} else {
				uCrc16 <<= 1;
			}
			uCrc16 ^= makeshort(abData[0], abData[1]);
		}

		return (int) uCrc16;
	}

	public static void main(String[] args) {

	}
}
```

Gruß Tom


----------



## torsch2711 (11. November 2004)

Natürlich kommt Thomas gleich wieder mit nem Source 


Ich glaube aber da du auch hier wieder shifting, bitoperation etc. alles benutzt, würde ihm der Code alleine nicht weiterhelfen.

Trotzdem danke für die Umsetzung.


----------



## Christian Fein (12. November 2004)

torsch2711 hat gesagt.:
			
		

> Natürlich kommt Thomas gleich wieder mit nem Source
> 
> 
> Ich glaube aber da du auch hier wieder shifting, bitoperation etc. alles benutzt, würde ihm der Code alleine nicht weiterhelfen.
> ...



Ich habe schon lange aufgegeben, schneller sein zu wollen als Thomas 

Der sitzt wahrscheinlich permanent vor einem Rechner,  mit ner gestarteten IDE und angelegten Klasse (mit Main Methode) ,  und wartet auf dem nächsten nach Sourcecode
schreienden Thread 

Eine Geduld hat der Mann


----------



## Thomas Darimont (12. November 2004)

Hallo!

Was bei den Bit Operationen passiert lässt sich ganz leicht aus jedem Java Buch herleiten:
http://www.galileocomputing.de/open...0008.htm#Rxxjavainsel_020008257Bitoperationen

Außerdem halte ich es für ein Gerücht, dass ich die ganze Zeit vor dem Rechner sitze... ;-) hab ja schließlich noch andere Sachen zu tun . (Wenn das so wäre hätte ich nicht erst ~2000 Beiträge  ) Ich arbeite nur schon ziemlich lange mit Java und kenn mich einfach ein ganz klein wenig aus... jeder der das auch macht sollte schneller sein als ich.

Gruß Tom


----------



## Christian Fein (12. November 2004)

Thomas Darimont hat gesagt.:
			
		

> Außerdem halte ich es für ein Gerücht, dass ich die ganze Zeit vor dem Rechner sitze... ;-) hab ja schließlich noch andere Sachen zu tun . (Wenn das so wäre hätte ich nicht erst ~2000 Beiträge  ) Ich arbeite nur schon ziemlich lange mit Java und kenn mich einfach ein ganz klein wenig aus... jeder der das auch macht sollte schneller sein als ich.



Das behaupte ich auch von mir 
Dennoch bis du immer fix mit source bei der hand.


----------



## torsch2711 (12. November 2004)

Hehe, naja, jedenfalls kann man an Thomas mal ein kleines Lob verteilen, ich bin meist zu faul den Source hier reinzuhacken, wie gesagt, bin gerade auch an einem Projekt in den Staaten und da kommst es nicht gut wenn man zu lange für andere Sachen aufbringt, deshalb halte ich meine Beiträge kurz und gebe den Leuten nur anregungen, wie sie es machen können und vielleicht teilsourcen. Ich bin der Meinung, wenn man sich selber damit auseinandersetzt und nur leichte hilfestellung hat, lernt man viel schneller und es bleibt auch länger haften, als wenn man den Leuten den Kompletten Source schon schreibt.

Allerdings ist es auf der anderen Seite auch hilfreich Sample Code zu sehen. 
Thomas, bitte dies nicht als Kritik oder meckern auffassen. Respekt an deine schnellen Code-Samples, die Du reinstellst, nur sehe ich den Lern-Effekt als nicht so hoch an. Aber das ist ja ein anderes Thema! 


Grüsse
Torsten


----------

