It is not sent in hexa format, it is sent in binary format. You show an hex dump, but the data is still binary. But we don't know how it is encoded. Are there integer? Float? Big endian or little endian? How wide? Etc. Hard to decode without these information.

that's apparently a 64 bit ieee double precision number

that hex string in binary is
1100000000111001100110011001100110100000000000000000000000000000

and this takes -25.6 and prints the same number (roughly)

1. Long l = Double.doubleToLongBits(-25.6);
2. for (int i = 63 ; i > 0 ; i--) {
3.   System.out.print((l >>> i) & 0x1);
4. }
5. System.out.println("");

you have an array of bytes (void receive(byte[] data...)). but you say you only want the last 16 or so for your two coordinates

so using the data above that's

40 6f e0 00 00 00 00 00
c0 39 99 99 a0 00 00 00

(i will leave it to you to extract the above bytes from the array you have)

you can pack those bytes, 8 at a time, into a long using the code i posted

1. long l = 0;
2. for (int i = 0 ; i < 8 ; i++) {
3.   l <<= 8;
4.   l += (b[i] & 0x00ff);
5. }

working example:

1. // the next line just recreates your incoming data byte array
   
2. byte[] data = new byte[]{(byte)0xc0, (byte)0x39, (byte)0x99, (byte)0x99, (byte)0xa0, (byte)0x00, (byte)0x00, (byte)0x00};
3. 
   
4. // pack the bytes into a long
   
5. long longData = 0;
6. for (int i = 0 ; i < 8 ; i++) {
7.   longData <<= 8;
8.   longData += (data[i] & 0x00ff);
9. }
10. 
    
11. // convert to ieee double precision
    
12. double y = Double.longBitsToDouble(longData);
13. println(y);

which data? why are there 5 values there? which bytes are they?

if you're giving it ALL your data then there's no guarantee that you're starting at the correct 8 byte boundaries. you say yourself that there's a header to the data, you need to skip over that header...

> it should start with 44.8500 , 0.4000
> even if you look at  40 46 6c cc c0 00 00 00 it's equal to 44.8500
> and  3f e6 66 66 60 00  00 00 is equal to 0.4000 .

i don't understand this, that seems to be ok to me. you just need to skip those header bytes.

i think wireshark might be a red herring. it doesn't matter how the data looks on the wire - it can do anything it wants to the data as long as it does the reverse at the other end. how it looks when it gets into the bytes is the important thing. we need to see the input data and a hexdump of the bytes from your receive method.

> i send 0 23 23 12 33
> 000000000000000 55 64 000000 55 64000000 40 64..............