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

Seite 13 von 31 ErsteErste ... 3111213141523 ... LetzteLetzte
Ergebnis 121 bis 130 von 304

Thema: DotNetSiemensPLCToolBoxLibrary (LibNoDave) Zugriff auf Dual-Port RAM / FB15

  1. #121
    Hans54216 ist offline Erfahrener Benutzer
    Themenstarter
    Registriert seit
    06.04.2013
    Beiträge
    208
    Danke
    10
    Erhielt 5 Danke für 5 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Zitat Zitat von Thomas_v2.1 Beitrag anzeigen
    Mit welchem von den dreien kommunizierst du, wenn du eine Datei überträgst, einen PI-Service aufrufst, oder eine Variable liest?
    Siemens schreibt bei seinem PI_START(/NC, P01, _N_TEST_EDI, _N_F_CLOS)

  2. #122
    Registriert seit
    29.03.2004
    Beiträge
    5.739
    Danke
    143
    Erhielt 1.686 Danke für 1.225 Beiträge

    Standard

    Zitat Zitat von Hans54216 Beitrag anzeigen
    In der "doUploadNC" und "endUploadNC" ist pa[4]=1, bei den SPS Funktionen war dieser 0. Weiß jedoch nicht was dieser aussagt.
    uc pa[]= {0x1f,0,0,0,1,0,0,1};

    Hab die jetzigen Upload Funktionen soweit angepasst, dass ich nen Erfolgreichen Upload durchführen konnte.
    Vielleicht besteht die upload ID aus 4 Bytes, und nicht nur aus einem? Dann wären die Funktionen für den Upload zwischen SPS und NC grundsätzlich identisch.
    Bei der SPS baust du den Dateinamen aus Sektion, Blocktyp, Blocknummer und Dateisystem (Aktiv/Passiv) zusammen, bei der NC gibst du einfach den Dateinamen an. Gehört bei der NC das "_N_" mit zum Dateinamen, oder ist das auch sowas wie ein Prefix?
    Die Genialität einer Konstruktion liegt in ihrer Einfachheit – Kompliziert bauen kann jeder.

    (Sergei Pawlowitsch Koroljow, sowjetischer Konstrukteur von Raketen und Weltraumpionier)

  3. #123
    Registriert seit
    29.03.2004
    Beiträge
    5.739
    Danke
    143
    Erhielt 1.686 Danke für 1.225 Beiträge

    Standard

    Also die UploadID besteht definitiv aus 4 Bytes.

    Ich habe es gerade getestet, indem ich die 4 Bytes von der SPS auf dem Weg zum PG (Step7) mit eigenen Werten modifiziert habe. Step7 schickt daraufhin in beim nächsten Upload-Befehl diese 4 Bytes mit genau diesen Werten wieder zurück. D.h. so wie es jetzt in libnodave steht mag es zwar funktionieren, aber ist prinzipiell falsch.
    Die Genialität einer Konstruktion liegt in ihrer Einfachheit – Kompliziert bauen kann jeder.

    (Sergei Pawlowitsch Koroljow, sowjetischer Konstrukteur von Raketen und Weltraumpionier)

  4. #124
    Hans54216 ist offline Erfahrener Benutzer
    Themenstarter
    Registriert seit
    06.04.2013
    Beiträge
    208
    Danke
    10
    Erhielt 5 Danke für 5 Beiträge

    Standard

    @Thomas_v2.1

    Der Upload einer kleinen Datei hat funktioniert. Wenn ich nun eine Größere Datei von der Steuerung hochlade funktioniert dieser zwar soweit, dass der Wireshark stimmt, jedoch liefert die Funktion keine oder falsche Rückgabeparameter.

    Wenn more = 0 -> alles gut
    Wenn more != 0 -> Problem

    Laut Wireshark sollte die Länge "len" bis auf das letzte Paket 946 lang sein. Es wird jedoch abwechselnd 942 und 0 geliefert. Wenn 0 geliefert wird ist der Buffer auch leer, jedoch nicht das PDU laut Wireshark.

    Die Variable "more" liefert auch komische Werte. 1, 95, 1, 117, 1, 77, 1, 67 wobei sich die Werte != 1 auch ändern.


    Wo ist mein Fehler?

    Code:
    int DECL2 doUploadNC(daveConnection * dc, int * more, uc**buffer, int * len, int uploadID){    PDU p1,p2;
        int res, netLen;
        p1.header=dc->msgOut+dc->PDUstartO;
        _daveConstructDoUploadNC(&p1, uploadID);
        res=_daveExchange(dc, &p1);
        if (daveDebug & daveDebugUpload) {
            LOG2("error:%d\n", res);
            FLUSH;
        }    
        *more=0;
        if(res!=daveResOK) return res;
        res=_daveSetupReceivedPDU(dc, &p2);
        *more=p2.param[1];
        if(res!=daveResOK) return res;
        //    netLen=p2.data[1] /* +256*p2.data[0]; */ /* for long PDUs, I guess it is so */;
        netLen=p2.data[1]+256*p2.data[0]; /* some user confirmed my guess... */;
        //if (*buffer) {
            memcpy(buffer,p2.data+4,netLen);
            *buffer+=netLen;
            if (daveDebug & daveDebugUpload) {
                LOG2("buffer:%p\n",*buffer);
                FLUSH;
            }
        //}
        *len=netLen;
        return res;
    }

  5. #125
    Registriert seit
    29.03.2004
    Beiträge
    5.739
    Danke
    143
    Erhielt 1.686 Danke für 1.225 Beiträge

    Standard

    Hast du mal einen Wireshark-Mitschnitt von so einem Upload einer großen Datei? Also durchgeführt mit der originalen Software.
    Die Genialität einer Konstruktion liegt in ihrer Einfachheit – Kompliziert bauen kann jeder.

    (Sergei Pawlowitsch Koroljow, sowjetischer Konstrukteur von Raketen und Weltraumpionier)

  6. #126
    Hans54216 ist offline Erfahrener Benutzer
    Themenstarter
    Registriert seit
    06.04.2013
    Beiträge
    208
    Danke
    10
    Erhielt 5 Danke für 5 Beiträge

    Standard

    Hier der Wireshark des Uploads.

    NC_File_Big_Upload.rar

  7. #127
    Registriert seit
    29.03.2004
    Beiträge
    5.739
    Danke
    143
    Erhielt 1.686 Danke für 1.225 Beiträge

    Standard

    Das ist bis auf den Dateinamen der bei Startupload eingefügt wird, und der aus 4 Bytes bestehenden Upload-ID doch identisch mit dem SPS Upload.

    Du hast ja nur eine Funktion gezeigt, ich würde alle zugehörigen wie folgt anpassen.
    Code:
    int DECL2 initUploadNC(daveConnection *dc, char *filename, uc *uploadID){
        PDU p1,p2;
        int res;
        if (daveDebug & daveDebugUpload) {
            LOG1("****initUploadNC\n");
        }
        p1.header = dc->msgOut + dc->PDUstartO;
        _daveConstructUploadNC(&p1, filename);
        res = _daveExchange(dc, &p1);
        if (daveDebug & daveDebugUpload) {
            LOG2("error:%d\n", res);
            FLUSH;
        }
        if (res != daveResOK) return res;
        res = _daveSetupReceivedPDU(dc, &p2);
        if (res != daveResOK) return res;
        uploadID[0] = p2.param[4];
        uploadID[1] = p2.param[5];
        uploadID[2] = p2.param[6];
        uploadID[3] = p2.param[7];
        return 0;
    }
    
    int DECL2 doUploadNC(daveConnection *dc, int *more, uc **buffer, int *len, uc *uploadID){
        PDU p1,p2;
        int res, netLen;
        p1.header = dc->msgOut + dc->PDUstartO;
        _daveConstructDoUploadNC(&p1, uploadID);
        res=_daveExchange(dc, &p1);
        if (daveDebug & daveDebugUpload) {
            LOG2("error:%d\n", res);
            FLUSH;
        }
        *more = 0;
        if (res != daveResOK) return res;
        res = _daveSetupReceivedPDU(dc, &p2);
        *more = p2.param[1];
        if (res != daveResOK) return res;
        netLen = p2.data[1] + 256*p2.data[0];
        if (*buffer) {
            memcpy(*buffer, p2.data+4, netLen);
            *buffer += netLen;
            if (daveDebug & daveDebugUpload) {
                LOG2("buffer:%p\n",*buffer);
                FLUSH;
            }
        }
        *len+=netLen;
        return res;
    }
    
    int DECL2 endUploadNC(daveConnection *dc, uc *uploadID){
        PDU p1,p2;
        int res;
        
        p1.header = dc->msgOut + dc->PDUstartO;
        _daveConstructEndUploadNC(&p1, uploadID);
        res = _daveExchange(dc, &p1);
        if (daveDebug & daveDebugUpload) {
            LOG2("error:%d\n", res);
            FLUSH;
        }
        if(res != daveResOK) return res;
        res = _daveSetupReceivedPDU(dc, &p2);
        return res;
    }
    
    void DECL2 _daveConstructUploadNC(PDU *p, char *filename) {
        uc pa[260];
        memset(pa, 0, sizeof(pa));
        pa[0] = 0x1d;
        pa[8] = strlen(filename);
        memcpy(&pa[9], filename, strlen(filename));
        _daveInitPDUheader(p, 1);
        _daveAddParam(p, pa, strlen(filename) + 9);
        if (daveDebug & daveDebugPDU) {
            _daveDumpPDU(p);
        }
    }
    
    void DECL2 _daveConstructDoUploadNC(PDU *p, uc *uploadID) {
        uc pa[] = {0x1e,0,0,0,0,0,0,1};
        pa[4] = uploadID[0];
        pa[5] = uploadID[1];
        pa[6] = uploadID[2];
        pa[7] = uploadID[3];
        _daveInitPDUheader(p, 1);
        _daveAddParam(p, pa, sizeof(pa));
        if (daveDebug & daveDebugPDU) {
            _daveDumpPDU(p);
        }
    }
    
    void DECL2 _daveConstructEndUploadNC(PDU * p, uc *uploadID) {
        uc pa[] = {0x1f,0,0,0,0,0,0,1};
        pa[4] = uploadID[0];
        pa[5] = uploadID[1];
        pa[6] = uploadID[2];
        pa[7] = uploadID[3];
        _daveInitPDUheader(p,1);
        _daveAddParam(p, pa, sizeof(pa));
        if (daveDebug & daveDebugPDU) {
            _daveDumpPDU(p);
        }
    }
    Für die Upload ID musst du ausserhalb ein unsigned char Array mit 4 Elementen anlegen, quasi so:
    Code:
    unsigned char uploadID[4];
    /* Verbindung aufbauen usw. */
    res = initUploadNC(dc, "_N_TEST_UPLOAD_MPF", uploadID);
    ...
    und diese dann in gleicher Weise an die folgenden Funktionen übergeben.
    Die Genialität einer Konstruktion liegt in ihrer Einfachheit – Kompliziert bauen kann jeder.

    (Sergei Pawlowitsch Koroljow, sowjetischer Konstrukteur von Raketen und Weltraumpionier)

  8. #128
    Registriert seit
    29.03.2004
    Beiträge
    5.739
    Danke
    143
    Erhielt 1.686 Danke für 1.225 Beiträge

    Standard

    Könntest du noch einen Mitschnitt von einem Download einer großen Datei machen, d.h. eine die mehrere PDUs benötigt? Und evtl. auch mal einen fehlerhaften Download erzeugen, wenn das irgendwie möglich ist.
    Die Genialität einer Konstruktion liegt in ihrer Einfachheit – Kompliziert bauen kann jeder.

    (Sergei Pawlowitsch Koroljow, sowjetischer Konstrukteur von Raketen und Weltraumpionier)

  9. #129
    Hans54216 ist offline Erfahrener Benutzer
    Themenstarter
    Registriert seit
    06.04.2013
    Beiträge
    208
    Danke
    10
    Erhielt 5 Danke für 5 Beiträge

    Standard

    Zitat Zitat von Thomas_v2.1 Beitrag anzeigen
    Könntest du noch einen Mitschnitt von einem Download einer großen Datei machen, d.h. eine die mehrere PDUs benötigt? Und evtl. auch mal einen fehlerhaften Download erzeugen, wenn das irgendwie möglich ist.
    NC_File_Big_Download.rar

    Das ist mal ein funktionierender Download.

  10. #130
    Hans54216 ist offline Erfahrener Benutzer
    Themenstarter
    Registriert seit
    06.04.2013
    Beiträge
    208
    Danke
    10
    Erhielt 5 Danke für 5 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Mit dem Upload von großen Dateien hab ich noch Probleme.

    Hab die Funktionen jetzt mal so eingebaut, wie du sie geschrieben hast. Problem ist aber das selbe. Unterscheiden sich ja auch nur darin, das die "uploadID" als uc[4] übergibst.

    Hier mal die Funktion für den Upload.

    //C#
    Code:
    int length = 0;
    byte[] buffer = new byte[size];
    res = _dc.daveGetNCProgram(filename, buffer, ref length);
    Code:
    protected static extern int daveGetNCProgram64(IntPtr dc, string filename, byte[] buffer, ref int length);

    //nodave
    Code:
    int DECL2 daveGetNCProgram(daveConnection *dc, const char *filename, uc *buffer, int *length) {
       int res, len, more, totlen;
       unsigned char uploadID[4];
       uc *bb=(uc*)buffer;
       len=0;    totlen=0;
       //if (dc->iface->protocol==daveProtoAS511) {
       //    return daveGetS5ProgramBlock(dc, blockType, number, buffer, length);
       //}
       res=initUploadNC(dc, filename, uploadID);
        if (res!=0) return res;
       do {
           res=doUploadNC(dc, &more, &bb, &len, uploadID);
           totlen+=len;
           if (res!=0) return res;
       } while (more);
       res=endUploadNC(dc, uploadID);
       *length=totlen;
       return res;}
    NcBigUpload_Fehler_3.rar

    Problem:
    - jedes zweite Paket wird nicht richtig in den Buffer geschrieben.
    - Ist der Upload zu Groß oder wird der Code nicht per Einzelschritt ausgeführt, kommt es zum Fehler: "Ein Ausnahmefehler des Typs "System.AccessViolationException" ist in DotNetSiemensPLCToolBoxLibrary.dll aufgetreten."

    //######################################################

    Möglichkeit 2:
    initUploadNC, doSingleUploadNC, endUploadNC werden vom C# Pogramm separat aufgerufen.

    Dazu hab ich die "doUploadNC" so angepasst, dass der Pointer für den Buffer nicht mehr weiter gestellt wird.
    Die Idee ist, die Funktion wird solange vom C# Programm aufgerufen, bis "more == 0". Der Buffer wird jedesmal anhand der "len" wegkopiert.
    Somit theoretisch unendliche Größe für Uploads möglich.

    Hier besteht aber ebenfalls das Problem, das bei jedem zweiten Aufruf die "len == 0" und für "more" irgend ein Wert != 0 zurückkommt.
    Es werden auch scheinbar doppelt so viele Jobs erzeugt.
    -> Upload ist laut Wireshark schon fertig, da werden immer noch Jobs an nodave geschickt. Die Daten im Buffer sind auch erst bei der hälfte der Datei.
    -> Auf diese zusätzlichen Jobs antwortet die NC mit Fehler, nodave liefert aber noch (jedes zweite mal) die fehlenden Daten.
    -> Das ret der Funktion ist über diesen Zeitraum immer 0.

    Jobs, die in ein PDU passen funktionieren!

    Wireshark und Ausgabe des Buffers im Anhang: NcBigUpload_Fehler_2.rar

    //C#
    Code:
    do{
       System.Threading.Thread.Sleep(100);
       res = _dc.doUploadNC(out more, buffer, out len, id);
       if (res != 0)
       {
           break;
       }
       try
       {
           ret = System.Text.Encoding.Default.GetString(buffer, 0, len);                                                                                         //
           lstRetStr.Add(System.Text.Encoding.Default.GetString(buffer, 0, len));                                                                            // Siehe Anhang
           lstRet.Add(new stTest() { value = System.Text.Encoding.Default.GetString(buffer, 0, len), more = more, len = len });     //
       }    catch (Exception ex)
       {    }
       System.Threading.Thread.Sleep(100);}
    while (more != 0);
    //nodave
    Code:
    int DECL2 doSingleUploadNC(daveConnection *dc, int *more, uc *buffer, int *len, uc *uploadID){
       PDU p1,p2;
       int res, netLen;
       p1.header = dc->msgOut + dc->PDUstartO;
       _daveConstructDoUploadNC(&p1, uploadID);
       res=_daveExchange(dc, &p1);
       if (daveDebug & daveDebugUpload) {
           LOG2("error:%d\n", res);
           FLUSH;    }
       *more = 0;
       if (res != daveResOK) return res;
       res = _daveSetupReceivedPDU(dc, &p2);
       *more = p2.param[1];
       if (res != daveResOK) return res;
       netLen = p2.data[1] + 256*p2.data[0];
       if (netLen > 1024) return -1;
       //if (*buffer) {
           memcpy(buffer, p2.data+4, netLen);
           //*buffer += netLen;
           if (daveDebug & daveDebugUpload) {
               LOG2("buffer:%p\n",*buffer);
               FLUSH;        }
       //}
       *len=netLen;
       return res;
    }
    Geändert von Hans54216 (02.05.2016 um 17:42 Uhr)

Ähnliche Themen

  1. Zugriff auf WinAC RTX mit LibnoDave
    Von rm2001 im Forum Hochsprachen - OPC
    Antworten: 2
    Letzter Beitrag: 27.04.2012, 20:31
  2. Libnodave & VB.NET Zugriff auf geschützte Speicherbereiche
    Von KJ1234 im Forum Hochsprachen - OPC
    Antworten: 1
    Letzter Beitrag: 10.11.2007, 16:02
  3. Zugriff mit libnodave (unter Delphi) auf S7-CP443-1
    Von Frank im Forum Hochsprachen - OPC
    Antworten: 19
    Letzter Beitrag: 29.04.2007, 13:59
  4. Zugriff auf Siemens S7 per libnodave (MPI)
    Von Anonymous im Forum Hochsprachen - OPC
    Antworten: 15
    Letzter Beitrag: 02.11.2005, 17:09
  5. Fehler bei Zugriff auf COM- Port
    Von h_matthias im Forum Simatic
    Antworten: 16
    Letzter Beitrag: 08.03.2004, 22:14

Stichworte

Lesezeichen

Berechtigungen

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