structur in C# empfangen

Hi Pier,

du brauchst dich nicht zu entschuldigen, dass du Anfänger bist. Besser 
wärs, sich dafür zu entschuldigen, dass du keine konkreten Informationen 
lieferst.

Wie sieht deine Struktur im µC aus? Das Prinzip ist allgemein gesehen 
einfach:

- im µC Daten aus Struktur lesen und senden
- in C# empfangen und an entsprechende Stelle in der Struktur schreiben.

Mit der Antwort kannst du wahrscheinlich soviel anfangen wie ich mit der 
Frage. Du musst schon sagen, wo genau es klemmt...

Ralf

Es gibt in C# keine Pointer ?

http://msdn.microsoft.com/en-us/library/50sbeks5.aspx

Ich vermute mal ihr meint das mit "Poiter"


MFG
Marco

Warum legst du in C# nicht einfach ein Array an, in dem du die Daten 
ablegst. Wenn alle Daten da sind, machst du die entsprechende Zuweisung 
vom Array in deine Struktur.

Ralf

weil sowas in C# nicht geht... C# ist eine Hochsprache und mag es nicht 
wenn man irgendwelche Annahmen macht wie die Daten im Speicher liegen.
Die Lösung mit dem BinaryReader ist sauber und einfach, man darf sich 
als hardwarenaher C oder Assembler Programmierer nur nicht Gedanken 
machen das alles doch irgendwie performanter gehen müsste.

Wenn man weiss wie, kann man Dein Problem in C# ganz einfach lösen.
Wie schon beschrieben wurde, musst Du erst mal das Struct in C# 
ebenfalls mit einem Struct oder einer Klasse nachbilden.
Danach kannst Du mit sogenannten serializern, deserializern den 
Datenstrom ganz einfach einlesen oder ausgeben. Alles managed, ohne 
Pointer und Basteleien.
Such mal im Netz weitere Informationen zum Serialisieren und melde Dich 
wieder, falls Du nicht weiterkommst.

Und in welcher Sprache soll der Pseudocode sein? In C# definitiv nicht, 
siehe mein Posting 3 Etagen höher. Und auch in C/C++ muss man den Umweg 
über Pointer gehen.
Ein Stück Code wie ich mal eine Kommunikation auf der C# Seite gebaut 
habe ist im Anhang. Dabei wird erst eine Message komplett mit STX, 
Daten, ETX und Blockcheck empfangen und die Daten in ein MemoryStream 
geschrieben. Danach wird ein Event ausgelöst das ein Paket da ist und 
ein anderer Eventhandler (könnte man auch direkt aufrufen) nimmt die 
Daten auseinander.

So vielleicht:

1

struct ComOut2

2

{

3

    byte start;

4

    byte adres;

5

    byte commando;

6

    int eine_nummer;

7

    byte chksum;

8

    byte ende;

9

};

10

11

SerialPort Port;

12

13

ComOut2 ReadMessage()

14

{

15

    ComOut2 Message = new Message();

16

    Message.start = Port.ReadByte();

17

    Message.adres = Port.ReadByte();

18

    Message.commando = Port.ReadByte();

19

    Message.eine_nummer = Port.ReadByte();

20

    Message.eine_nummer += Port.ReadByte() << 8;

21

    Message.chksum = Port.ReadByte();

22

    Message.ende = Port.ReadByte();

23

    return Message;

24

}

Da fehlt jetzt Berechnung und die Prüfung der Checksum. Mit 
fortschreitender Programmierung wirst Du auch feststellen, dass start 
und ende gar nicht Teil der Struktur sein müssen, weil sie eh bekannt 
sind. Beispielsweise:

1

struct ComOut3

2

{

3

    byte adres;

4

    byte commando;

5

    int eine_nummer;

6

    byte chksum;

7

};

8

9

const byte START = 0x02;

10

const byte ENDE = 0x03;

11

12

ComOut3 ReadMessage()

13

{

14

    ComOut3 Message = new Message();

15

    while (Port.ReadByte() != START)

16

        ;

17

    Message.adres = Port.ReadByte();

18

    Message.commando = Port.ReadByte();

19

    Message.eine_nummer = Port.ReadByte();

20

    Message.eine_nummer += Port.ReadByte() << 8;

21

    Message.chksum = Port.ReadByte();

22

    if (Port.ReadByte() != ENDE)

23

        throw new ApplicationException(whatever);

24

    return Message;

25

}

Ich bleibe bei meiner Meinung, für Deine Aufgabe ist 
Serialisieren/Deserialisieren am besten geeignet.

Wichtig ist, Dein struct/klasse mit dem Attribut Serializable() zu 
versehen.
Also etwa so:

[Serializable]
struct ComOut2
{
    byte start;
    byte adres;
    byte commando;
    int eine_nummer;
    unsigned char chksum;
    unsigned char ende;
}

Dann musst Du einen "Stream" mit Deinen Daten machen und das ganze dann 
mit einem "BinaryFormatter" serialisieren/deserialisieren, wobei 
natürlich als Datentyp Dein struct angegeben werden muss.
Hier habe ich ein schönes Beispiel gefunden, welches zwar mit einer 
Datei arbeitet, aber es lässt sich auch einfach für Daten von einer 
seriellen Schnittstelle ändern. Aber zum üben ist es mit einer Datei 
vielleicht gar nicht so schlecht.
http://forum.codecall.net/csharp-tutorials/7918-tutorial-visual-studio-2008-c-serialization.html

> // der zweite Fehler liegt daran, das die Member wie start private sind
> // (hätte eigentlich schon oben korrigiert werden müssen)

Genau, hätte er eigentlich auch drauf kommen können, wenn er 
entsprechende Warnungen/Fehlermeldungen angeschaut hätte.

Weiss denn Jemand eine andere Lösung um in C# ein Byte-Array in eine 
Struktur zu wandeln?
Ich habe es mit folgender Funktion probiert:

T ByteArrayToStructure<T>(byte[] bytes)
{
  GCHandle handle = GCHandle.Alloc(bytes, GCHandleType.Pinned);
  T structure = 
(T)Marshal.PtrToStructure(handle.AddrOfPinnedObject(),typeof(T));
  handle.Free();
  return structure;
}

Leider stimmen die Byte orders zwischen µC und PC nicht überein, so dass 
alle ints etc verdreht sind.
Kennt jemand eine einfache Lösung? Sollte doch irgendwie gehen...

Beispiel:
Eine Structure ist definiert als:

Hinweis:
Die Struct ist als unsafe deklariert, da sie zwei char arrays fester 
Größe besitzen soll. (Eines ist public fixed byte JobID[28])

[StructLayout(LayoutKind.Explicit, Size = 184)]
        unsafe struct MetaData
        {
            [FieldOffset(0)]    //1 bytes
            public byte MetaDataVersion;
            [FieldOffset(1)]    //1 bytes
            public byte Channel_FFTLength;
            [FieldOffset(2)]    //2 bytes
            public Int16 Reserved1;
            [FieldOffset(4)]    //28 bytes
            public fixed byte JobID[28];
            [FieldOffset(32)]   //8 bytes
            public Int64 XOversampling;
            [FieldOffset(40)]   //8 bytes
            public Int64 YStart;
            [FieldOffset(48)]   //8 bytes
            public Int64 YDelta;
            [FieldOffset(56)]   //8 bytes
            public Int64 YRange;
            [FieldOffset(64)]   //8 bytes
            public Int64 ProcessingGain;
            [FieldOffset(72)]   //8 bytes
            public Int64 Reserved2;
            [FieldOffset(80)]   //1 bytes
            public byte Jop_Gap_ADCOverload;
            [FieldOffset(81)]   //1 bytes
            public byte DataVideofiltered;
            [FieldOffset(82)]   //2 bytes
            public Int16 Reserved3;
            [FieldOffset(84)]    //4 bytes
            public Int32 Antenna;
            [FieldOffset(88)]   //8 bytes
            public Int64 Centerfreq;
            [FieldOffset(96)]   //8 bytes
            public Int64 XDelta;
            [FieldOffset(104)]   //8 bytes
            public Int64 Duration;
            [FieldOffset(112)]   //8 bytes
            public Int64 Attenuation;
            [FieldOffset(120)]   //8 bytes
            public Int64 GainCorrection;
            [FieldOffset(128)]   //8 bytes
            public Int64 DetectorHfFrequency;
            [FieldOffset(136)]   //4 bytes
            public Int32 DetectorHfSignalValue;
            [FieldOffset(140)]   //4 bytes
            public Int32 DetectorHfSignalDelta;
            [FieldOffset(144)]   //40 bytes
            public fixed byte Reserved4[40];
        }

Mit folgender Funktion kann man sich die Structur aus einem Byte Array 
herausholen. Der Ansatz ist oben schon besprochen worden (Autor Arcnet 
1.12.2008 Lösungsnummer 2):

private static Header GetHeader( byte[] InBuffer)
        {

            Header Localheader = new Header();
            byte[] Buffer = new byte[Marshal.SizeOf(Localheader)];
            IntPtr pntHeader = 
Marshal.AllocHGlobal(Marshal.SizeOf(Localheader));
            try
            {
                BinaryReader reader = new BinaryReader(new 
MemoryStream(InBuffer));
                Buffer = reader.ReadBytes(Marshal.SizeOf(Localheader));
                Marshal.Copy(Buffer, 0, pntHeader, 
Marshal.SizeOf(Localheader));
                Localheader = (Header)Marshal.PtrToStructure(pntHeader, 
typeof(Header));
                DateTime dtTOA = new DateTime(1970, 01, 01, 0, 0, 0, 
DateTimeKind.Utc) + new TimeSpan(Localheader.TOA * 10);
                return Localheader;
            }
            catch
            {
                return Localheader;
            }
            finally
            {
                // Free the unmanaged memory.
                Marshal.FreeHGlobal(pntHeader);
            }
        }

Gruß JG