Shiften, aber wie?

[Jan L. (jan_l)]

Hallo,

ich schmeiss hier gleich alles vom Tisch xD

ich habe ein Board was mir Sensordaten in einem array an den Pc schickt.

und um diese Daten lesen zu können, muss ich am pc jeweils 2 
Arraystellen zusammen shiften.

So auf der Board seite Shift ich das aber erst mal auf die richtige 
Größe

out[0] = (unsigned char) ((uint16_t)(accel[0] >> 12) % 256);
out[1] = (unsigned char) ((uint16_t)(accel[0] >> 4) % 256);

(isgesamt übertrage ich ein 16-Bit Array.)

das sieht dann so aus. Und das will ich auch eigendlich nicht verändern, 
warum, dazu komm ich noch.


Ich habe ein Python-test-Programm, mit dem ich die Werte nämlich richtig 
auslesen (Ohne etwas an der Software auf dem Board zu ändern).

Das sieht (meiner Meinung nach die wichtigstens Ausschnitte) so aus:

self.data = [0,0,0,0]

div = 1.0 / (1 << 12)
self.num_elements = 3

for ii in range(0,self.num_elements):
     self.data[ii] = twoBytes(l[2*ii+2],l[2*ii+3]) * div

(Die Daten liegen in meinem Array ab der stelle 2 bis 7)

def twoBytes(d1,d2):
    """ unmarshal two bytes into int16 """
    d = ord(d1)*256 + ord(d2)
    if d > 32767:
        d -= 65536
    return d

###########################################################

So meine erste Idee war, einfach stumpf nach programmieren (c# auf pc 
seite). Das hat leider nicht zu den richtigen Werten geführt.

Jetzt ist meine Frag, wie muss ich das alles wieder shiften und zusammen 
führen das ich endlich mal ein richtigies Ergebnis bekomme?

Oder zumindest kann mir den python Teil jemand erklären, damit ich es 
vielleicht richtig in c# umsetzten kann.

Was ich ebenfalls versuch habe, ist es einfach zusammen in einen 16 bit 
werte zu shiften da kommt aber ebenfalls ein falscher wert raus

bsp.:

value[0] = (long)((((UInt16)b[2]) << 8) + ((UInt16)b[3]));

for (int i = 0; i < FLOATARRAY_SIZE; i++)
{
    if (value[i] > 32767)
    {
        value[i] -= 65536;                
    }
    val[i] = ((float)value[i]) / 16384.0f;
}

Ich hab einfach überhaupt keine Idee mehr glaube aber, eigendlich dürfte 
das garnicht so schwer sein ...

viele Grüße

[Markus V. (valvestino)]

Jan L. schrieb:
> So meine erste Idee war, einfach stumpf nach programmieren (c# auf pc
> seite).

Und warum machst Du das dann nicht? Deine hier gepostete (Teil-)Lösung 
mach nämlich nicht das, was Du als Python Code gepostet hast.

Versuch's mal damit:

    class Program
    {
        static void Main(string[] args)
        {
            //(Die Daten liegen in meinem Array ab der stelle 2 bis 7)
            var l = new byte[] { 255, 127, 16, 5, 18, 7, 20, 9, 63, 31 };
            var data = new float[3];

            const float div = 1.0f/(1 << 12);

            for (var ii=0; ii<data.Length; ii++)
                data[ii] = twoBytes(l[2*ii + 2], l[2*ii + 3])*div; 

            Console.Write("Daten: ");
            foreach (var f in data)
            {
                Console.Write(string.Format("{0} ",f));
            }
            Console.WriteLine();
            Console.ReadKey();

        }

        private static float twoBytes(byte d1, byte d2)
        {
            //""" unmarshal two bytes into int16 """
            var d = d1*256 + d2;
            if (d > 32767)
                d -= 65536;
            return d;
        }
    }

Gruß
Markus

[Jan L. (jan_l)]

^^ ich bin auch blöd wie 10 meter Feldweg ...

hatte es ja schon nach programmiert

aber das:

data[i] = twoBytes(l[2*i + 2], l[2*i + 3])*div;

sah bei mir so aus:

data[i] = twoBytes(l[2*i + 2], l[2*i + 3] * div);

und dann hat die ganze sache immer gemekert -.- vielleicht sollte ich 
einfach mal genauer hinsehen :P

vielen dank =)

wenn mir jetzt noch jemand sagen kann was da passiert bin ich glücklich 
:D
immoment ist es nämlich einfach ein pures Kopieren =(

[Markus V. (Gast)]

Was gibt's da nicht zu verstehen? ;-) Auf der "Boardseite" zerlegst Du 
Deine Sensordaten in Bytes und kopierst sie in Dein 
Übertragungs-Byte-Array. Auf der PC-Seite passiert das Umgekehrte. Dort 
werden zwei Bytes wieder zu einem short-Wert zusammengebastelt 
(High-Byte*256 + Low-Byte) und in einen float konvertiert.

Gruß
Markus

[hopple (Gast)]

> (High-Byte*256 + Low-Byte) und in einen float konvertiert.

eben gerade nicht. Er shifted 12 bit und 4 bit nach links
und nicht 8. Damit kannst du deine Formel nicht anwenden.

hoppel