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

Zuviel Werbung?
-> Hier kostenlos registrieren
Sind die ganzen NC-Funktionen denn schon bei Jochen in der libnodave Version, oder gibt es dazu eine andere Quelle?

Denke das meiste ist darin, oder? Glaube Hans hat noch ein paar Änderungen die aber nim Moment nicht kompatibel zu meiner Version sind. (oder? https://github.com/Nick135/DotNetSiemensPLCToolBoxLibrary ist doch dein github account?)
 
Die Funktion davePutNCProgram() sollte soweit ich das sehe so funktionieren wie in FileUpload_SINUMERIK_Operate.
Hast du mal eine Aufzeichnung bei der du diese Funktion verwendest und sie nicht funktioniert?
Denn in FileUpload_Error wird diese Funktion nicht verwendet, sondern der Standard-Upload der auch für S7-Programmbausteine verwendet wird.

Die Funktion "davePutNcProgram" wird zum download benötigt. Zum Upload verwende ich die "daveGetNCProgram" diese ist aber eine Kombination aus initUploadNC, doUploadNC und endUploadNC.
FileUpload_daveGetNCProgram_initUploadNC.jpg

"daveGetNCProgram" sollte daher auch auf die weiße wie "davePutNcProgram" funktionieren.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Jetzt bin ich im Bilde :-)
Ich schaue mir das mal an, sieht ja prinzipiell recht ähnlich der PutNC Funktion aus.

Ich bin gerade noch dabei die als "Malformed Packet" angezeigten Pakete aus deinem einen Logfile in Wireshark richtig zu verarbeiten. Da gibt es mal wieder eine neue Ausnahme bzw. Variante um NC-Daten zu lesen. Ist das ein neues oder älteres Gerät, oder etwas ganz exotisches?
 
"Malformed Packete" kommen immer wieder vor. Bei dem Schrieb "FileUpload_SINUMERIK_Operate" handelt es sich um die NC Version 4.7.4.1. Dies ist die neueste Offizielle Version.
 
"Malformed Packete" kommen immer wieder vor. Bei dem Schrieb "FileUpload_SINUMERIK_Operate" handelt es sich um die NC Version 4.7.4.1. Dies ist die neueste Offizielle Version.

Ab demnächst hoffentlich nicht mehr. Was das gegenüber der anderen Lesevariante für ein Vorteil hat, als dass man da unbedingt etwas ändern musste erschließt sich mir aber auch nicht.
Wenn im ersten Datenteil bei Transport-Size 0x12 steht, dann folgen die Items als NCK-Datenbereich.
s7comm-nc-spezial.jpg
 
Also zu diesen von mir "Push" genannten Telegrammen gibt es auch eine Antwort. Ich habe diese damals "Push" genannt, weil es bei der S7 Telegramme sind die ohne Anfrage selbstständig von der SPS versendet werden können.

Also falls die 6.131 ein Client ist und die 214.1 die NC, dann stellt der Client eine Anfrage um die angegebenen NCK-Bereiche zu lesen, und bekommt dann (ebenfalls via Push) eine Antwort darauf. Prinzipiell genau so wie es auch mit den "normalen" Job/Ack_Data Telegrammen funktioniert. Man hat damit so wie ich das sehe nichts gewonnen. Im Gegenteil sogar ist diese Variante schlechter, da der Parameterteil in diesen Telegrammen größer ist, was den Datenteil und damit die max. mögliche Anzahl an lesbaren Daten entsprechend kleiner werden lässt.
 
Ich habe mal einen Entwurf für diese Funktion geschrieben. Ich habe mich dabei an dem Logfile mit deinem "NC_File_Big_Upload2" orientiert. Bei großen Dateien werden dann z.B. 20 Telegramme gesendet die nicht bestätigt werden müssen, dann gibt es einen Fortsetzbefehl usw.
Die Funktion wird übersetzt, mehr kann ich leider nicht testen. Ich habe ein paar Debug-Ausgaben eingefügt, dann können wir hoffentlich sehen woran es ggf. hakt.

Die Buffergröße muss man vorher groß genug abschätzen. Es gibt auch keine Prüfung wie groß der Buffer ist und ob dieser evtl. zu klein ist. Bei den anderen libnodave Funktionen wird das auch nirgens geprüft, man muss also wissen was man tut.
Für length musst du einen Zeiger auf einen integer übergeben, in den dann die Gesamtlänge geschrieben wird.
Aufruf z.B. mit:
length = 0;
res = daveGetNCfile(dc, "N_TEST_UPLOAD2_MPF", buffer, &length);

Code:
int DECL2 
daveGetNCfile(daveConnection *dc, const char *filename, char *buffer, int *length)
{
    PDU p, p2;
    int res = 0;
    uc unackcount = 0;
    int filename_len = 0;
    int tot_len = 0;
    int part_len = 0;

    /* Request upload */
    uc req_up_pa[]= {
        0x00, 0x01, 0x12, 0x04, 0x11, 0x7f, 0x06, 0x00
    };
    uc req_up_da[]= {
        0xff, 0x09, 0x00, 32,
        /* Anzahl Telegramme die ohne ack angenommen werden = 20  */
        20, 0x00,
        /* Dateiname max. 32 Zeichen */
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00
    };

    /* Continue upload */
    uc cont_up_pa[]= {
        0x00, 0x01, 0x12, 0x04, 0x11, 0x3f, 0x08, 0x00
    };
    uc cont_up_da[]= {
        0xff, 0x09, 0x00, 0x02,
        /* Anzahl Telegramme die ohne ack angenommen werden = 20 */
        20, 0x00
    };

    *length = 0;
    filename_len = strlen(filename);    /* max. 32 chars */
    if (filename_len > 32) {
        return -1;
    }
    req_up_da[3] = filename_len + 2;    /* + 1 Byte Anzahl Telegramme + 1 Byte unbekannt */
    memcpy(&req_up_da[6], filename, filename_len);

    p.header = dc->msgOut + dc->PDUstartO;
    _daveInitPDUheader(&p, 7);
    _daveAddParam(&p, req_up_pa, sizeof(req_up_pa));
    _daveAddData(&p, req_up_da, 6 + filename_len);

    res = _daveExchange(dc, &p);
    if (res != daveResOK) {
        return res;
    }
    res = _daveSetupReceivedPDU(dc, &p2);
    if (daveGetDebug() & daveDebugPDU) {
        _daveDumpPDU(&p2);
    }
    /* Errorcode im Parameterteil prüfen */
    res = daveGetU16from(&p2.param[10]);
    LOG2("daveGetNCfile: Response start upload, param.errorcode=0x%04x\n", res);
    if (res != 0) {
        return -2;
    }
    cont_up_pa[7] = p2.param[7];      /* Sequenznummer für alle folgenden Continue-Uploads verwenden */
    LOG2("daveGetNCfile: Verwendete Sequenznummer=%d\n", cont_up_pa[7]);
    res = _daveTestResultData(&p2);
    if (daveDebug & daveDebugPDU) {
        LOG3("_daveTestReadResult() returned: %d=%s\n", res, daveStrerror(res));
    }
    if (res != daveResOK) {
        return res;
    }
    LOG2("daveGetNCfile: Response start upload, p2.udlen=%d\n", p2.udlen);
    /* Vor den eigentlichen Daten sind hier noch 2 Bytes unbekannter Funktion eingeschoben */
    part_len = p2.udlen - 2;
    if (part_len <= 0) {
        return -3;
    }
    memcpy(buffer + tot_len, p2.data + 6, part_len);
    tot_len += part_len;
    /* Wenn ab hier noch nicht alles gelesen, dann werden bis zu 20 Telegramme gesendet die 
     * nicht bestätigt werden müssen. Dann gibt es ein ack usw. usf.
     */
    while (p2.param[9] != 0) {     /* 0 = Last data unit */
        LOG2("daveGetNCfile: unackcount=%d\n", unackcount);
        /* Nach 20 Telegrammen continue Telegramm senden */
        if (++unackcount == 20) {
            _daveAddParam(&p, cont_up_pa, sizeof(cont_up_pa));
            _daveAddData(&p, cont_up_da, sizeof(cont_up_da));
            if (daveGetDebug() & daveDebugPDU) {
                _daveDumpPDU(&p);
            }
            res = _daveSendTCP(dc, &p);
            if (res != daveResOK) {
                return res;
            }
            unackcount = 0;
        }
        res = _daveGetResponseISO_TCP(dc);
        if (res != daveResOK) {
            return res;
        }
        res = _daveSetupReceivedPDU(dc, &p2);
        if (daveGetDebug() & daveDebugPDU) {
            _daveDumpPDU(&p2);
        }
        /* Errorcode im Parameterteil prüfen */
        res = daveGetU16from(&p2.param[10]);
        LOG2("daveGetNCfile: continue upload, param.errorcode=0x%04x\n", res);
        if (res != 0) {
            return -2;
        }
        res = _daveTestResultData(&p2);
        if (daveDebug & daveDebugPDU) {
            LOG3("_daveTestReadResult() returned: %d=%s\n", res, daveStrerror(res));
        }
        if (res != daveResOK) {
            return res;
        }
        LOG2("daveGetNCfile: Response start upload, p2.udlen=%d\n", p2.udlen);
        part_len = p2.udlen - 2;
        if (part_len <= 0) {
            return -3;
        }
        memcpy(buffer + tot_len, p2.data + 6, part_len);
        tot_len += part_len;
    }
    *length = tot_len;
    return res;
}
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Richtig, 6.131 ist das HMI und 214.1 ist die NC.

Ich kann jetzt nur mutmaßen ob es sich hier um den Änderungsdienst der NC handelt.
Es ist möglich bei der NC einen Event auf eine Variable anzumelden. Wenn die NC den Event anlegt, überträgt sie zunächst den aktuellen Wert und später dann bei Änderung.
 
Übrigens in deinem alten Logfile wurde vorher per entsprechendem PI-Service ein Dateitransfer eingeleitet. Das scheint laut deinem neuen Logfile nicht mehr gemacht zu werden. Nur zur Info. Aber die Möglichkeit der PI-Service Funktionen sind in libnodave ja auch ergänzt worden.
 
@Hans
darf ich mal fragen was das für ein Bedienteil ist das diese Probleme auslöst.

und NC Software aktuell freigegeben ist bei 4.7 SP4 HF 7 (04070407) nicht 04070401 und das ist auch nicht das neuste freigegebene das es auch schon den 4.8 SP1 HF 3 gibt
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Es ist von der Datei abhängig, ob diese per PI-Service zunächst zum Upload angewählt werden muss oder nicht. Für NC-Programme wird dies benötigt, nicht jedoch für Binärdateien .acx. Da geht auch der PI-Dienst schief.

Danke für die Methode.
Hab jetzt mal eine Anfrage an meinen Teststand geschickt. Die (Problem) Maschine ist nicht per VPN erreichbar.

Sieht gut aus.
 

Anhänge

Du müsstest das Ganze dann auch mal an einer größeren Datei prüfen, d.h. wenn die Übertragung mehr als 20 Telegramme benötigt. Oder testweise die Stellen mit der 20 im Code und in den Telegrammen auf z.B. 3 herunter setzen, damit das schon eher notwendig wird.
Und auch prüfen ob alles im buffer korrekt zusammengesetzt wird.
 
darf ich mal fragen was das für ein Bedienteil ist das diese Probleme auslöst.

Es handelt sich um ein Schubert Bedienpanel. Dieses hat einen Win10 Ipc und solange die Schubertdienste laufen kommt es zu den Einschränkungen.

und NC Software aktuell freigegeben ist bei 4.7 SP4 HF 7 (04070407) nicht 04070401 und das ist auch nicht das neuste freigegebene das es auch schon den 4.8 SP1 HF 3 gibt

Wegen mir gibt es schon eine neuere 4.7 Version. Die 4.7.4.1 ist jedenfalls die Neueste von uns eingesetzt Version und auf dieser Version Basierend sind auch Betaversionen im Einsatz um Siemens Fehler zu finden.
 
Beim Laden von Großen Dateien kommt es zum Fehler mit dem Rückgabewert -2.
Ok, die erste Antwort zählt wohl nicht zu den unacked Telegrammen dazu. Wobei dann eigentlich ein Timeout hätte kommen müssen.

Probier die Schleife mal so:
Code:
    while (p2.param[9] != 0) {     /* 0 = Last data unit */
        LOG2("daveGetNCfile: unackcount=%d\n", unackcount);
        /* Nach 20 Telegrammen continue Telegramm senden */
        if (unackcount == 20) {
            p.header = dc->msgOut + dc->PDUstartO;
            _daveInitPDUheader(&p, 7);
            _daveAddParam(&p, cont_up_pa, sizeof(cont_up_pa));
            _daveAddData(&p, cont_up_da, sizeof(cont_up_da));
            if (daveGetDebug() & daveDebugPDU) {
                _daveDumpPDU(&p);
            }
            res = _daveSendTCP(dc, &p);
            if (res != daveResOK) {
                return res;
            }
            unackcount = 0;
        }
        res = _daveGetResponseISO_TCP(dc);
        if (res != daveResOK) {
            return res;
        }
        res = _daveSetupReceivedPDU(dc, &p2);
        if (daveGetDebug() & daveDebugPDU) {
            _daveDumpPDU(&p2);
        }
        /* Errorcode im Parameterteil prüfen */
        res = daveGetU16from(&p2.param[10]);
        LOG2("daveGetNCfile: continue upload, param.errorcode=0x%04x\n", res);
        if (res != 0) {
            return -4;
        }
        res = _daveTestResultData(&p2);
        if (daveDebug & daveDebugPDU) {
            LOG3("_daveTestReadResult() returned: %d=%s\n", res, daveStrerror(res));
        }
        if (res != daveResOK) {
            return res;
        }
        LOG2("daveGetNCfile: Response start upload, p2.udlen=%d\n", p2.udlen);
        part_len = p2.udlen - 2;
        if (part_len <= 0) {
            return -5;
        }
        memcpy(buffer + tot_len, p2.data + 6, part_len);
        tot_len += part_len;
        unackcount++;
    }
 
Kannst du mal die daveDebug einschalten und die Ausgaben in eine Textdatei kopieren und anhängen?

Wenn die 4 Telegramme aus deinem Screenshot im Buffer landen, dann sieht es irgendwie so aus als ob die unterlagerten libnodave-Funktionen ein Problem damit haben, wenn mehrere S7comm-Pakete in einem TCP Telegramm vorhanden sind.
Du könntest mal testweise an den Stellen wo der Wert 20 eingetragen ist eine 1 einsetzen. Dann sollte es nach jedem Telegramm von der NC ein Continue-Telegramm von libnodave geben.
Die drei Stellen sind in req_up_da, cont_up_da und in der Abfrage if (unackcount == 20) {.
Oder du setzt an den Stellen ein #define:
#define MAXUNACKED 1

und dann an allen Stellen MAXUNACKED einsetzen.
 
Zurück
Oben