Zuviel Werbung? - > Hier kostenlos beim SPS-Forum registrieren

Seite 1 von 3 123 LetzteLetzte
Ergebnis 1 bis 10 von 26

Thema: Typ-Casting, Pointer, call by reference, wie geht das mit PCWORX?

  1. #1
    Registriert seit
    18.12.2012
    Beiträge
    9
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Hallo!
    Kurze Erklärung vorweg:
    Ich programmiere eigentlich nur Hochsprachen (meist C++) und entwickle gerade ein neues Steuerungs-System unter Windows.
    Als I/O-Ebene und für die nötigen Echtzeit-Routinen sind Phoenix ILC's geplant, die wir bislang nur für eher kleine Steuerungsaufgaben und dann meist mit der Web-Client-Schnittstelle verwendet haben. (Das machen bislang aber andere Kollegen)

    Die Kommunikation soll über UDP und Sockets laufen, Tests mit kleinen Datenpaketen funktionieren bereits. Nun aber zu meinem Problem (das ist dann auch grundsätzlicher Natur):

    Ich möchte eine Struktur (Sollwerte, Parameter, Outputs etc., insgesamt rund 8 KB) aus der Windows-Welt zyklisch auf die SPS-Ebene übertragen. Die Struktur beinhaltet INT16, INT32, Arrays, Chars usw. Auf PC-Seite wird dieser Block aufgrund der maximalen UDP-Paketgröße in 1400-Byte-Häppchen geteilt und versendet. (Dort caste ich die Struktur auf einen Char-Pointer und lasse eine Funktion entsprechend diesen 8K-Block 1:1 verschicken)

    Auf der SPS-Seite habe ich die gleiche Struktur als TYP erstellt und möchte nun die jeweils empfangenen Pakete zu je 1400Byte wieder zu einem 8K-Block zusammenfügen und diesen Block dann entweder in die Struktur kopieren oder gleich jedes Paket an die richtige Stelle in die Struktur einfügen. Dazu hatte ich erwartet, einfach einen gecasteten Byte-Pointer auf den Anfang der Struktur (die ja eigentlich auch nur ein Memory-Block irgendwo im Speicher ist) legen zu können und die Einzel-Pakete uninterpretiert dort an die entsprechenden Stellen (alle 1400 Byte) hinein zu kopieren.
    Aber ich finde bislang keine Möglichkeit dazu, auch die Kollegen kennen keine Pointer in dieser SPS und gucken mich mitleidig an wie einen Alien.
    Ein Versuch über einen FB, der als Parameter einen Blockcounter, den Receive-Buffer und die Struktur bekommt (Was ja über sog. "Call-by-Reference", also Pointer erfolgt) bringt mich nicht weiter, weil PCWORX mich innerhalb des FB ebenfalls nur über die Struktur darauf zugreifen lässt.

    Das muss doch irgendwie gehen!?!
    (Und ich weiß auch, dass ich noch alle INTs noch Motorolafreundlich drehen darf - Das mache ich aber vorher schon auf dem PC)

    Und wenn es schon keine CAST-Direktiven gibt, kennt jemand zumindest einen Workaround?

    Danke im voraus..
    Zitieren Zitieren Typ-Casting, Pointer, call by reference, wie geht das mit PCWORX?  

  2. #2
    Registriert seit
    25.06.2008
    Ort
    Blomberg/Lippe
    Beiträge
    1.293
    Danke
    51
    Erhielt 130 Danke für 124 Beiträge

    Standard

    Also ich würde von Hand die Bytes zusammenstricken und dann an die Struktur übergeben. So mach ich das immer bei TCP und UDP.
    Gruß
    Mobi


    „Das Einfache kompliziert zu machen ist alltäglich. Das Komplizierte einfach zu machen –
    das ist Kreativität“ (Charles Mingus).

  3. #3
    e-hyp ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    18.12.2012
    Beiträge
    9
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Also, mit Verlaub, aber genau das will ich doch gerade NICHT machen.
    Ich möchte doch nicht ausrechnen und fest codieren müssen, an welcher Position im x. Empfangsbuffer sich ein Element meiner (komplexen) Struktur befindet, um von dort entsprechende Bytes zu kopieren.
    Und wenn ich zukünftig die Struktur erweitern muss, darf ich alle Adressen neu berechnen?

    mal davon abgesehen, dass so aus einem simplen universellen 5-zeiler ein unflexibles, fehleranfälliges Byte-geschubbse über mehrere Seiten wird.

    ..nee, ich will wirklich nicht in diese mittelalterliche programmierhölle.

  4. #4
    Registriert seit
    25.06.2008
    Ort
    Blomberg/Lippe
    Beiträge
    1.293
    Danke
    51
    Erhielt 130 Danke für 124 Beiträge

    Standard

    Oh entschuldigen sie euer Hohheit.
    Wusste nicht, dass sie eine weniger arbeitsintensive Möglichkeit suchen.

    Evtl. können sich es auch mit den BUF_TO_* Bausteinen hinbekommen.
    Aber da müssten sie auch die Startadresse angeben. Also auch wieder Mist.

    Und zum ausrechnen der Adressen bei einer Änderung, können sie sich ja ein kleines Tool schreiben.
    Sie können ja eine Hochsprache.

    Na dann viel Spaß.
    Gruß
    Mobi


    „Das Einfache kompliziert zu machen ist alltäglich. Das Komplizierte einfach zu machen –
    das ist Kreativität“ (Charles Mingus).

  5. #5
    e-hyp ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    18.12.2012
    Beiträge
    9
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Warum Hoheit?
    Weil mich der Vorschlag nicht weiter bringt? hm.


    Egal, nun wissen Sie ja, dass ich in der Tat eine weniger arbeitsintensive Variante suche. Und nein, Faulheit ist nicht der Grund, sondern weil diese Art eine einfache Funktionalität enorm verkompliziert, fehleranfällig macht und zukünftige Erweiterungen nur schwer berücksichtigen kann. Die Struktur hat etwa 8KB Datenumfang, Arrays, Ints, Chars bunt gemischt.

    Der BUF_TO_* - FB konvertiert nur EINEN Standard-Datentyp, macht hier also keinen Sinn.

    Trotzdem Danke, Knappe Mobi.

  6. #6
    Registriert seit
    25.06.2008
    Ort
    Blomberg/Lippe
    Beiträge
    1.293
    Danke
    51
    Erhielt 130 Danke für 124 Beiträge

    Standard

    Zitat Zitat von e-hyp Beitrag anzeigen
    Warum Hoheit?
    Weil mich der Vorschlag nicht weiter bringt? hm.
    Ne wegen dem "mit Verlaub". Das hab ich beim letzten Mal in einem Märchen gehört.
    Wusste garnicht, dass das noch im deutschen Sprachgebrauch drin ist.

    Zitat Zitat von e-hyp Beitrag anzeigen
    Egal, nun wissen Sie ja,
    Sie können ruhig du zu mir sagen.

    Zitat Zitat von e-hyp Beitrag anzeigen
    dass ich in der Tat eine weniger arbeitsintensive Variante suche. Und nein, Faulheit ist nicht der Grund, sondern weil diese Art eine einfache Funktionalität enorm verkompliziert, fehleranfällig macht und zukünftige Erweiterungen nur schwer berücksichtigen kann. Die Struktur hat etwa 8KB Datenumfang, Arrays, Ints, Chars bunt gemischt.
    Faulheit hätte ich jetzt nicht gesagt, ich weiß schon das man nach der leichtesten Möglichkeit sucht. Aber manchmal klappt es halt nicht.
    Naja die Fehleranfälligkeit liegt ja beim Programmierer, je nachdem wiegut er die Verarbeitung und das Errorhandling macht.

    Zitat Zitat von e-hyp Beitrag anzeigen
    Der BUF_TO_* - FB konvertiert nur EINEN Standard-Datentyp, macht hier also keinen Sinn.
    Wie nur einen? Da gibt es doch mehrere Varianten von.

    Zitat Zitat von e-hyp Beitrag anzeigen
    Trotzdem Danke, Knappe Mobi.
    Bitte, bitte euer Hohheit


    Aber haben sie evtl. eine Beispielübertragung und den genauen Aufbau der Struktur. Evtl. kann ich ihnen da ein bisschen unter die Arme greifen.
    Einfach mal mit Wireshark ein paar Pakete aufzeichnen, dann kann man den Part für die SPS am leichtesten aufbauen.
    Gruß
    Mobi


    „Das Einfache kompliziert zu machen ist alltäglich. Das Komplizierte einfach zu machen –
    das ist Kreativität“ (Charles Mingus).

  7. #7
    e-hyp ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    18.12.2012
    Beiträge
    9
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Moin.

    Das Problem ist ja nicht die Übertragung (Wireshark ist also nicht nötig), sondern das ausfriemeln von Bytes aus mehreren 1400 Byte großen unstrukturierten Buffern (Receivebuffer) in einen Strukturierten Bereich. Die Daten liegen ja schon 1:1 an den richtigen Stellen, nur im falschen Buffer..


    Das ist die Struktur (eine von zweien, die mit den Sollwerten, es gibt noch eine mit Istwerten) auf der PC-Seite: (ST_RT_COM_JOB) ist Bestandteil von ST_DUPO_O. ST_DUPO_O wird an die SPS versendet. MAX_DO und MAX_AO ist erstmal 32, MAX_RTSLOTS ist erstmal 200. in den RTSLOTS stehen Echtzeiterforderliche-Aufgaben, die die SPS ausführen soll. Die SPS arbeitet also als eine Art Interpreter und soll für die einzelnen Projekte nicht jeweils neu programmiert werden.

    --------------------------------------------------------------------------------------------------
    typedef struct
    {
    bool HSHAKE; // Handshake zum RT-Bereich (Flag: neuer Befehl)
    bool READY; // Rückmeldung: 1=OK, 0=unbenutzt/in Arbeit
    bool USED; // ComPath ist belegt
    short command;
    short sub;
    char ea_1[2]; // Modul + Kanal
    char ea_2[2]; // Modul + Kanal
    char ea_3[2]; // Modul + Kanal
    short bis, ab_puls;
    short puls, pause;
    short status;
    } ST_RT_COM_JOB;


    typedef struct
    {
    short WATCHDOG; // Flag: Watchdog (2)
    bool REPARATUR; // Flag: Reparatur-Modus (1)
    char externdo [MAX_DO][32]; // MAX_DO Module zu je 32 Kanäle (EXTERN) (1024)
    short externao [MAX_AO][16]; // MAX_AO Module zu je 16 Kanäle (EXTERN) (1024)
    ST_RT_COM_JOB RTSlotJob [MAX_RTSLOTS]; // Struktur der RealTime Jobs (Echtzeit-Aufgaben von Waagen, Ausgänge etc.)
    } ST_RT_DP_O;
    --------------------------------------------------------------------------------------------------



    Die Struktur auf SPS-Seite lautet demnach:
    --------------------------------------------------------------------------------------------------
    (* Struktur der COM-JOBS zum Abarbeiten der Externen Aufträge ----------------------- *)
    TYPE ST_RT_COM_JOB : STRUCT


    HSHAKE : BOOL;
    READY : BOOL;
    USED : BOOL;
    command : INT;
    sub_com : INT;
    ea_1m : BYTE;
    ea_1k : BYTE;
    ea_2m : BYTE;
    ea_2k : BYTE;
    ea_3m : BYTE;
    ea_3k : BYTE;
    bis : INT;
    ab_puls : INT;
    puls : INT;
    pause : INT;
    status : INT;
    END_STRUCT;
    END_TYPE


    (* Struktur der übergebenen Soll-Ausgänge von Extern ----------------------- *)


    TYPE AST_RT_COM_JOB : ARRAY [0..199] OF ST_RT_COM_JOB; END_TYPE


    TYPE ST_RT_DP_O : STRUCT
    WATCHDOG : INT;
    REPARATUR : BOOL;
    externdo : DO_ARRAY;
    externao : AO_ARRAY;
    RTSlotJob : AST_RT_COM_JOB;
    END_STRUCT;
    END_TYPE
    --------------------------------------------------------------------------------------------------


    Das Senden auf PC-Seite: (SOCKBLLEN ist 1400, der Socket M4IO.m_SPSSocket wurde vorher geöffnet)
    --------------------------------------------------------------------------------------------------
    char sendbuf [SOCKBLLEN+2], *pb;
    int b, blocks;

    blocks = sizeof (m_DUPO_O)/SOCKBLLEN;
    for (pb=(char *)&m_DUPO_O, b=0; b<blocks; b++, pb+=SOCKBLLEN)
    {
    sendbuf [0] = 100+b; // Paketnummer (ab #100)
    sendbuf [1] = blocks+1; // Anzahl der zu sendenden Pakete
    memcpy (&sendbuf[2], pb, SOCKBLLEN);
    send (M4IO.m_SPSSocket, pb, SOCKBLLEN, 0);
    }
    send (M4IO.m_SPSSocket, pb, sizeof (m_DUPO_O)-b*SOCKBLLEN, 0); // Den restlichen (kleineren) Block
    ----------------------------------------------------------------------------------------------------

    Wie man sehen kann, lege ich den char-Pointer *pb auf die (gecastete) Instanz m_DUPO_O der Struktur ST_DUPO_O, und versende sie in SOCKBLEN-Große Päckchen per Socketstream an die SPS. (Dort kommen Sie auch prima an)
    (Fehlerroutinen hab ich hier zum besseren Verständnis weggelassen.)

    Ich suche nun eine Möglichkeit, auf der SPS-Seite das entsprechende Gegenstück zu implementieren.

    Hab ich mich halbwegs verständlich machen können?

    Andreas

  8. #8
    e-hyp ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    18.12.2012
    Beiträge
    9
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Sorry, fehlten noch ein paar Datentypen auf der SPS-Seite:

    TYPE BYTE32_ARRAY : ARRAY [0..31] OF BYTE; END_TYPE
    TYPE INT16_ARRAY : ARRAY [0..15] OF INT; END_TYPE


    TYPE DI_ARRAY : ARRAY [0..31] OF BYTE32_ARRAY; END_TYPE (* DI-FELD *)
    TYPE DO_ARRAY : ARRAY [0..31] OF BYTE32_ARRAY; END_TYPE (* DO-FELD *)
    TYPE AI_ARRAY : ARRAY [0..31] OF INT16_ARRAY; END_TYPE (* AI-FELD *)
    TYPE AO_ARRAY : ARRAY [0..31] OF INT16_ARRAY; END_TYPE (* AO-FELD *)

    (Und irgendwie klaut die thread-Darstellung meine Formatierung..)

  9. #9
    Registriert seit
    25.06.2008
    Ort
    Blomberg/Lippe
    Beiträge
    1.293
    Danke
    51
    Erhielt 130 Danke für 124 Beiträge

    Standard

    Ja haste.

    Trotzdem würde ich gerne mal ein gesendetes Paket sehen. Also die reinen Bytes.
    Sowie man das bei Wireshark sieht. Mir würde dann auch die *.pcapng reichen.
    So kann ich mir das besser vorstellen.
    Und dann wo die reinen Werte stehen in der Struktur, welche dann den Bytes entsprechen.

    Kannst mir es auch per PN schicken, wenn du es nicht hier zeigen willst.
    Gruß
    Mobi


    „Das Einfache kompliziert zu machen ist alltäglich. Das Komplizierte einfach zu machen –
    das ist Kreativität“ (Charles Mingus).

  10. #10
    Registriert seit
    25.06.2008
    Ort
    Blomberg/Lippe
    Beiträge
    1.293
    Danke
    51
    Erhielt 130 Danke für 124 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Wozu die Arrays für die DI's und DO's. Du kannst auch direkt ein DWord an die DI's bzw. DO's geben
    Gruß
    Mobi


    „Das Einfache kompliziert zu machen ist alltäglich. Das Komplizierte einfach zu machen –
    das ist Kreativität“ (Charles Mingus).

Ähnliche Themen

  1. call-by-reference Beckhoff?
    Von gingele im Forum CODESYS und IEC61131
    Antworten: 6
    Letzter Beitrag: 22.07.2011, 09:12
  2. Störmeldungen, wie geht das?
    Von carsten im Forum Simatic
    Antworten: 9
    Letzter Beitrag: 23.11.2007, 09:05
  3. Antworten: 1
    Letzter Beitrag: 08.11.2006, 14:28
  4. Antworten: 7
    Letzter Beitrag: 01.02.2006, 08:29

Stichworte

Lesezeichen

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •