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

Zuviel Werbung?
-> Hier kostenlos registrieren
Hab den (oder zumindest einen) Fehler gefunden.

Code: 
uc req_up_da[]= {
        0xff, 0x09, 0x00, 32,
        /* Anzahl Telegramme die ohne ack angenommen werden = 20  */
        MAXUNACKED, 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
    };
muss in

Code: 
uc req_up_da[]= {
        0xff, 0x09, 0x00, 32,
        /* Anzahl Telegramme die ohne ack angenommen werden = 20  */
        MAXUNACKED, 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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00
    };
geändert werden.

Ich hatte also nur 22 und nicht 32 Zeichen für den Dateinamen vorgesehen. Bei längeren Dateinamen als 22 wird dann anderer Speicher überschrieben.
 
Kommt jetzt nicht mehr zum Absturz. (Upload hat ja eigentlich eh schon funktioniert)

Ich test jetzt noch ein bisschen, sieht aber schon mal gut aus.
Danke!
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Ich überlege gerade wie ich auf die maximal 32 Zeichen komme. Weißt du ob es da im Dateisystem eine Beschränkung gibt?

Der Fehler ist deiner nodave.c auch noch in anderen Funktionen für die NC vorhanden. Einfach mal nach "32 Zeichen" suchen.
 
Ich denk die Kommen von mir.

Maximale Länge für Dateinamen ist 24
NC Syntax _N_ 3
Extension _SPF, _MPF, _DIR, _WPD 4
\0 1

24+3+4+1 -> 32
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Das ist seltsam.
Bei einer S7 ist bei Transport Size 5=INTEGER die Längenangabe in Bits. D.h. wenn ein INTEGER übertragen wird, dann steht im Längenfeld 0x10. WinCC flexible fragt meistens mit der dem Datentyp der Variable zugehörigen Transportgröße.
 
Zur Sicherheit gerade nochmal einen Test an einer Et200S CPU gemacht.
Wenn ich ein Array aus zwei Integern lese, dann antwortet die SPS mit Länge 0x0020 = 32 / 4 = 8 Bytes. D.h. so wie es mein Wireshark Filter und auch libnodave erwarten.

Mir fällt auch gerade nichts ein wie ich da eine Sonderbehandlung einbauen könnte. Das lässt sich nirgends erkennen, dass da anscheinend auf einmal auf die Byteanzahl gewechselt wurde.
 

Anhänge

  • s7comm-tsize.jpg
    s7comm-tsize.jpg
    46,2 KB · Aufrufe: 6
Das ist die Methode in NoDave mit dem zugehörigen Dump. (Wenn ich hart die len=2 schreibe funktioniert es.)

Code: 
/*
Execute a predefined read request. Store results into the resultSet structure.
*/
int DECL2 daveExecReadRequest(daveConnection * dc, PDU *p, daveResultSet* rl){
    PDU p2;
    uc * q;
    daveResult * cr, *c2;
    int res, i, len, rlen;
   if (daveDebug & daveDebugPDU)
   {
      LOG4("daveExecReadRequest(dc:%p, PDU:%p, rl:%p\n", dc, p, rl);
      FLUSH;    
   }
    dc->AnswLen=0;    // 03/12/05
    dc->resultPointer=NULL;
    dc->_resultPointer=NULL;
    res=_daveExchange(dc, p);
    if (res!=daveResOK) return res;
    res=_daveSetupReceivedPDU(dc, &p2);
    if (res!=daveResOK) return res;
    res=_daveTestReadResultMulti(&p2);
    if (res!=daveResOK) return res;
    i=0;
    if (rl!=NULL) {
        cr=(daveResult*)calloc(p2.param[1], sizeof(daveResult));
        rl->numResults=p2.param[1];
        rl->results=cr;
        c2=cr;
        q=p2.data;
        rlen=p2.dlen;
        while (i<p2.param[1]) {
            /*        printf("result %d: %d  %d %d %d\n",i, *q,q[1],q[2],q[3]); */
         if (daveDebug & daveDebugPDU)
         {
            LOG2("daveExecReadRequest result %d: %d  %d %d %d\n",i, *q,q[1],q[2],q[3]);
            FLUSH;
         }
            if ((*q==255)&&(rlen>4)) {
                len=q[2]*0x100+q[3];
                if (q[1]==4) {
                    len>>=3;    /* len is in bits, adjust */
                } else if (q[1]==5) {            /* Fehlenden Size-Type INTEGER ergänzt */
                    len>>=3;    /* len is in bits, adjust */
                } else if (q[1]==7) {            /* Fehlenden Size-Type REAL ergänzt */
                     /* len is already in bytes, ok */
                } else if (q[1]==9) {
                    /* len is already in bytes, ok */
                } else if (q[1]==3) {
                    /* len is in bits, but there is a byte per result bit, ok */
                } else if (q[1]==6) {
                    /* integer access, len is in bytes */
                } else {
                    if (daveDebug & daveDebugPDU)
                        LOG2("fixme: what to do with data type %d?\n",q[1]);
                }
            } else {
                len=0;
            }
            /*        printf("Store result %d length:%d\n", i, len); */
         if (daveDebug & daveDebugPDU)
         {
            LOG2("Store result %d length:%d\n", i, len);
            FLUSH;
            //len=2;
         }
            c2->length=len;
            if(len>0){
                c2->bytes=(uc*)malloc(len);
                memcpy(c2->bytes, q+4, len);
            }
            c2->error=daveUnknownError;


            if (q[0]==0xFF) {
                c2->error=daveResOK;    
            } else
                c2->error=q[0];    


            /*        printf("Error %d\n", c2->error); */
            q+=len+4;
            rlen-=len;
            if ((len % 2)==1) {
                q++;
                rlen--;
            }
            c2++;
            i++;
        }
    }
    return res;
}

Code: 
 Dump
PDU header: 
                            0:0x32,0x01,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x00,
plen: 12 dlen: 0
Parameter: 
                            0:0x04,0x01,0x12,0x08,0x82,0xA1,0x01,0x90,0x00,0x01,0x1A,0x01,
daveExecReadRequest(dc:000000001A6DA810, PDU:000000001A6D6DF0, rl:000000001A6A3560
_daveExchange PDU number: 65536
ReadFromNck enter _daveExchangeTCP
send packet: : 
                            0:0x03,0x00,0x00,0x1D,0x02,0xF0,0x80,0x32,0x01,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,
                            10:0x00,0x04,0x01,0x12,0x08,0x82,0xA1,0x01,0x90,0x00,0x01,0x1A,0x01,
readISOpacket: 27 bytes read, 27 needed
readISOpacket: packet: 
                            0:0x03,0x00,0x00,0x1B,0x02,0xF0,0x80,0x32,0x03,0x00,0x00,0x00,0x00,0x00,0x02,0x00,
                            10:0x06,0x00,0x00,0x04,0x01,0xFF,0x05,0x00,0x02,0x00,0xF4,
ReadFromNck _daveExchangeTCP res from read 27
result of exchange: 0
PDU header: 
                            0:0x32,0x03,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x06,0x00,0x00,
plen: 2 dlen: 6
Parameter: 
                            0:0x04,0x01,
Data     : 
                            0:0xFF,0x05,0x00,0x02,0x00,0xF4,
Data hdr : 
                            0:0xFF,0x05,0x00,0x02,
Data     : 
                            0:0x00,0xF4,
error: ok
dave test result: p-param[0]: 4
daveExecReadRequest result 0: 0  443168096 65537 4079216
Store result 0 length:-348275808
daveUseResult(dc:000000001A6DA810, result set:000000001A6A3560, number:0)
result set has 1 results
result error: 0
result length: 0
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Wenn dann müsste bei der Abfrage sizetype=5 die Division durch 8 entfallen, weil die Länge bereits in der Anzahl an Bytes ist.
Code: 
} else if (q[1]==5) {            /* Fehlenden Size-Type INTEGER ergänzt */
  /* only for NC: len is already in bytes, ok */
}

Aber dann funktioniert das an einer S7 nicht mehr.

Ich habe mir noch mal ein paar Aufzeichnungen angesehen. Bei anderen NC-Logfiles die ich so habe war das Verhalten auch schon so.
Diverse S7-SPS machen es aber anders. Wer von beiden das "richtig" im Sinne der vermutlichen Siemens Spezifikation macht, weiß ich nicht.
Wäre mal interessant was WinCC flexible macht wenn es ein NC-Bereich liest. Wenn das funktioniert, dann müsste dort eine Unterscheidung stattfinden. D.h. wird ein NC Bereich angefragt dann ist tsize in Bytes, sonst in Bits.
 
Die Methode "_daveDumpPDU" scheint es ja richtig zu machen.

Code: 
PDU header: 
                            0:0x32,0x03,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x0E,0x00,0x00,
plen: 2 dlen: 14
Parameter: 
                            0:0x04,0x02,
Data     : 
                            0:0xFF,0x05,0x00,0x02,0x00,0xF4,0xFF,0x07,0x00,0x04,0x41,0x9B,0x33,0x30,
Data hdr : 
                            0:0xFF,0x05,0x00,0x02,
Data     : 
                            0:0x00,0xF4,
Data hdr : 
                            0:0xFF,0x07,0x00,0x04,
Data     : 
                            0:0x41,0x9B,0x33,0x30,
error: ok

Code: 
/*
Hex dump PDU:
*/
void DECL2 _daveDumpPDU(PDU * p) {
    int i,dl;
    uc * pd;
    _daveDump("PDU header", p->header, p->hlen);
    LOG3("plen: %d dlen: %d\n",p->plen, p->dlen);
    if(p->plen>0) _daveDump("Parameter",p->param,p->plen);
    if(p->dlen>0) _daveDump("Data     ",p->data,p->dlen);
    if ((p->plen==2)&&(p->param[0]==daveFuncRead)) {
        pd=p->data;
        for (i=0;i<p->param[1];i++) {
            _daveDump("Data hdr ",pd,4);


            dl=0x100*pd[2]+pd[3];
            if (pd[1]==4) dl/=8;
            pd+=4;        
            _daveDump("Data     ",pd,dl);
            if(i<p->param[1]-1) dl=dl+(dl%2);      // the PLC places extra bytes at the end of all 
            // but last result, if length is not a multiple 
            // of 2
            pd+=dl;
        }
    } else if ((p->header[1]==1)&&/*(p->plen==2)&&*/(p->param[0]==daveFuncWrite)) {
        pd=p->data;
        for (i=0;i<p->param[1];i++) {
            _daveDump("Write Data hdr ",pd,4);


            dl=0x100*pd[2]+pd[3];
            if (pd[1]==4) dl/=8;
            pd+=4;        
            _daveDump("Data     ",pd,dl);
            if(i<p->param[1]-1) dl=dl+(dl%2);      // the PLC places extra bytes at the end of all 
            // but last result, if length is not a multiple 
            // of 2
            pd+=dl;
        }
    } else {    
        /*    
        if(p->dlen>0) {
        if(p->udlen==0)
        _daveDump("Data     ",p->data,p->dlen);
        else
        _daveDump("Data hdr ",p->data,4);
        }    
        if(p->udlen>0) _daveDump("result Data ",p->udata,p->udlen);
        */    
    }
    if ((p->header[1]==2)||(p->header[1]==3)) {
        LOG2("error: %s\n",daveStrerror(daveGetPDUerror(p)));
    }    
}
 
Zuviel Werbung?
-> Hier kostenlos registrieren
libnodave kannte die anderen Transportgrößen 5 und 7 überhaupt nicht, vermutlich haben wir das irgendwann mal ergänzt aber nicht bei der dump-Funktion?
Bei einer S7 SPS braucht libnodave diese auch nicht zu kennen, weil wenn du bei der Anfrage angibst du möchtest 2 Bytes lesen, dann kommt auch niemals die Transportgröße 5 oder 7 zurück, sondern die SPS schickt dir auch Transportgröße Byte (dann ist die Anzahl in Bits). Frag mich nicht warum Siemens das überhaupt so vorgesehen hat.

Festzustellen ist, dass wenn du einen NC Bereich anfragst, die Transportgröße 5 anders zu interpretieren ist als bei einer S7-SPS. Bei Siemens muss man einiges einfach so hinnehmen wie es ist.
 
Hab mal alle bekannten Datentypen des Antriebs ausgelesen.

Code: 
V1_M_p04001_INT                              Error (3): this result contains no data
                                                                       AnzVar 1; akVar 0
                                                                       readsizes 2
                                                                       usedShortRequest False
V1_M_r0035_REAL                              19,8
V1_M_p00051_WORD                        2
V1_M_p0015_DWORD                       0
V1_M_p0161_CHAR                            0
V1_M_p9802_DINT                             Error (3): this result contains no data
                                                                       AnzVar 1; akVar 0
                                                                       readsizes 4
                                                                       usedShortRequest False

Anhang anzeigen Drive-Int_Real_Word_DWord_Char-DInt.rar

Code: 
PDU header: 
                            0:0x32,0x01,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x00,
plen: 12 dlen: 0
Parameter: 
                            0:0x04,0x01,0x12,0x08,0x82,0xA1,0x01,0x90,0x00,0x01,0x1A,0x01,
PDU header: 
                            0:0x32,0x01,0x00,0x00,0x00,0x00,0x00,0x16,0x00,0x00,
plen: 22 dlen: 0
Parameter: 
                            0:0x04,0x02,0x12,0x08,0x82,0xA1,0x01,0x90,0x00,0x01,0x1A,0x01,0x12,0x08,0x82,0xA1,
                            10:0x00,0x23,0x00,0x01,0x1A,0x01,
PDU header: 
                            0:0x32,0x01,0x00,0x00,0x00,0x00,0x00,0x20,0x00,0x00,
plen: 32 dlen: 0
Parameter: 
                            0:0x04,0x03,0x12,0x08,0x82,0xA1,0x01,0x90,0x00,0x01,0x1A,0x01,0x12,0x08,0x82,0xA1,
                            10:0x00,0x23,0x00,0x01,0x1A,0x01,0x12,0x08,0x82,0xA1,0x00,0x05,0x00,0x01,0x1A,0x01,
PDU header: 
                            0:0x32,0x01,0x00,0x00,0x00,0x00,0x00,0x2A,0x00,0x00,
plen: 42 dlen: 0
Parameter: 
                            0:0x04,0x04,0x12,0x08,0x82,0xA1,0x01,0x90,0x00,0x01,0x1A,0x01,0x12,0x08,0x82,0xA1,
                            10:0x00,0x23,0x00,0x01,0x1A,0x01,0x12,0x08,0x82,0xA1,0x00,0x05,0x00,0x01,0x1A,0x01,
                            20:0x12,0x08,0x82,0xA1,0x00,0x0F,0x00,0x01,0x1A,0x01,
PDU header: 
                            0:0x32,0x01,0x00,0x00,0x00,0x00,0x00,0x34,0x00,0x00,
plen: 52 dlen: 0
Parameter: 
                            0:0x04,0x05,0x12,0x08,0x82,0xA1,0x01,0x90,0x00,0x01,0x1A,0x01,0x12,0x08,0x82,0xA1,
                            10:0x00,0x23,0x00,0x01,0x1A,0x01,0x12,0x08,0x82,0xA1,0x00,0x05,0x00,0x01,0x1A,0x01,
                            20:0x12,0x08,0x82,0xA1,0x00,0x0F,0x00,0x01,0x1A,0x01,0x12,0x08,0x82,0xA1,0x00,0xA1,
                            30:0x00,0x01,0x1A,0x01,
PDU header: 
                            0:0x32,0x01,0x00,0x00,0x00,0x00,0x00,0x3E,0x00,0x00,
plen: 62 dlen: 0
Parameter: 
                            0:0x04,0x06,0x12,0x08,0x82,0xA1,0x01,0x90,0x00,0x01,0x1A,0x01,0x12,0x08,0x82,0xA1,
                            10:0x00,0x23,0x00,0x01,0x1A,0x01,0x12,0x08,0x82,0xA1,0x00,0x05,0x00,0x01,0x1A,0x01,
                            20:0x12,0x08,0x82,0xA1,0x00,0x0F,0x00,0x01,0x1A,0x01,0x12,0x08,0x82,0xA1,0x00,0xA1,
                            30:0x00,0x01,0x1A,0x01,0x12,0x08,0x82,0xA1,0x26,0x4A,0x00,0x01,0x1A,0x01,
daveExecReadRequest(dc:000000001A84DB10, PDU:000000001A8302B0, rl:000000001A83A250
_daveExchange PDU number: 65536
ReadFromNck enter _daveExchangeTCP
send packet: : 
                            0:0x03,0x00,0x00,0x4F,0x02,0xF0,0x80,0x32,0x01,0x00,0x00,0x00,0x00,0x00,0x3E,0x00,
                            10:0x00,0x04,0x06,0x12,0x08,0x82,0xA1,0x01,0x90,0x00,0x01,0x1A,0x01,0x12,0x08,0x82,
                            20:0xA1,0x00,0x23,0x00,0x01,0x1A,0x01,0x12,0x08,0x82,0xA1,0x00,0x05,0x00,0x01,0x1A,
                            30:0x01,0x12,0x08,0x82,0xA1,0x00,0x0F,0x00,0x01,0x1A,0x01,0x12,0x08,0x82,0xA1,0x00,
                            40:0xA1,0x00,0x01,0x1A,0x01,0x12,0x08,0x82,0xA1,0x26,0x4A,0x00,0x01,0x1A,0x01,
readISOpacket: 63 bytes read, 63 needed
readISOpacket: packet: 
                            0:0x03,0x00,0x00,0x3F,0x02,0xF0,0x80,0x32,0x03,0x00,0x00,0x00,0x00,0x00,0x02,0x00,
                            10:0x2A,0x00,0x00,0x04,0x06,0xFF,0x05,0x00,0x02,0x00,0xF4,0xFF,0x07,0x00,0x04,0x41,
                            20:0x9E,0x66,0x64,0xFF,0x06,0x00,0x02,0x00,0x02,0xFF,0x06,0x00,0x04,0x00,0x00,0x00,
                            30:0x00,0xFF,0x06,0x00,0x01,0x00,0x00,0xFF,0x05,0x00,0x04,0x00,0x00,0x00,0x00,
ReadFromNck _daveExchangeTCP res from read 63
result of exchange: 0
PDU header: 
                            0:0x32,0x03,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x2A,0x00,0x00,
plen: 2 dlen: 42
Parameter: 
                            0:0x04,0x06,
Data     : 
                            0:0xFF,0x05,0x00,0x02,0x00,0xF4,0xFF,0x07,0x00,0x04,0x41,0x9E,0x66,0x64,0xFF,0x06,
                            10:0x00,0x02,0x00,0x02,0xFF,0x06,0x00,0x04,0x00,0x00,0x00,0x00,0xFF,0x06,0x00,0x01,
                            20:0x00,0x00,0xFF,0x05,0x00,0x04,0x00,0x00,0x00,0x00,
Data hdr : 
                            0:0xFF,0x05,0x00,0x02,
Data     : 
                            0:0x00,0xF4,
Data hdr : 
                            0:0xFF,0x07,0x00,0x04,
Data     : 
                            0:0x41,0x9E,0x66,0x64,
Data hdr : 
                            0:0xFF,0x06,0x00,0x02,
Data     : 
                            0:0x00,0x02,
Data hdr : 
                            0:0xFF,0x06,0x00,0x04,
Data     : 
                            0:0x00,0x00,0x00,0x00,
Data hdr : 
                            0:0xFF,0x06,0x00,0x01,
Data     : 
                            0:0x00,
Data hdr : 
                            0:0xFF,0x05,0x00,0x04,
Data     : 
                            0:0x00,0x00,0x00,0x00,
error: ok
dave test result: p-param[0]: 4
daveExecReadRequest result 0: 0  444834384 65537 5197216
Store result 0 length:-202130528
daveExecReadRequest result 1: -202130528  444834384 65537 0
Store result 1 length:-202130528
daveExecReadRequest result 2: -202130528  444834384 65537 0
Store result 2 length:-202130528
daveExecReadRequest result 3: -202130528  444834384 65537 0
Store result 3 length:-202130528
daveExecReadRequest result 4: -202130528  444834384 65537 0
Store result 4 length:-202130528
daveExecReadRequest result 5: -202130528  444834384 65537 0
Store result 5 length:-202130528
daveUseResult(dc:000000001A84DB10, result set:000000001A83A250, number:0)
result set has 6 results
result error: 0
result length: 0
 
Der Unterschied ist nur bei Transportgröße 5, bei allen anderen passt es ja.

Wie gesagt habe ich Logfiles von verschiedenen S7-Steuerungen wo die Größe hier anders interpretiert werden muss, und so ist es z.Zt. auch in Wireshark gemacht.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Thomas_v2.1 schrieb:
libnodave kannte die anderen Transportgrößen 5 und 7 überhaupt nicht, vermutlich haben wir das irgendwann mal ergänzt aber nicht bei der dump-Funktion?
Bei einer S7 SPS braucht libnodave diese auch nicht zu kennen, weil wenn du bei der Anfrage angibst du möchtest 2 Bytes lesen, dann kommt auch niemals die Transportgröße 5 oder 7 zurück, sondern die SPS schickt dir auch Transportgröße Byte (dann ist die Anzahl in Bits). Frag mich nicht warum Siemens das überhaupt so vorgesehen hat.

Festzustellen ist, dass wenn du einen NC Bereich anfragst, die Transportgröße 5 anders zu interpretieren ist als bei einer S7-SPS. Bei Siemens muss man einiges einfach so hinnehmen wie es ist.
Zum Vergrößern anklicken....

Nochmal zur Klarstellung:
Es wird zwar die Methode "ReadFromNck" verwendet, jedoch werden Drive Daten vom Sinamics Antrieb gelesen.
Auf Nck Daten (NC, Kanal, Achse,...) antwortet die NC immer als "Octet String".

2018-04-07 12_57_02-Nc Integer Parameter.png
Anhang anzeigen Nc Integer Parameter.rar
 
Thomas_v2.1 schrieb:
libnodave kannte die anderen Transportgrößen 5 und 7 überhaupt nicht, vermutlich haben wir das irgendwann mal ergänzt aber nicht bei der dump-Funktion?
Bei einer S7 SPS braucht libnodave diese auch nicht zu kennen, weil wenn du bei der Anfrage angibst du möchtest 2 Bytes lesen, dann kommt auch niemals die Transportgröße 5 oder 7 zurück, sondern die SPS schickt dir auch Transportgröße Byte (dann ist die Anzahl in Bits). Frag mich nicht warum Siemens das überhaupt so vorgesehen hat.

Festzustellen ist, dass wenn du einen NC Bereich anfragst, die Transportgröße 5 anders zu interpretieren ist als bei einer S7-SPS. Bei Siemens muss man einiges einfach so hinnehmen wie es ist.
Zum Vergrößern anklicken....

Brauch ich das jetzt für die SPS oder nicht?
Wenn ich es Auskommentiere funktioniert es zumindest für den Antrieb und für die Nck sowieso.

Code: 
if ((*q==255)&&(rlen>4)) {
				len=q[2]*0x100+q[3];
				if (q[1]==4) {
					len>>=3;	/* len is in bits, adjust */
				} else if (q[1]==5) {			/* Fehlenden Size-Type INTEGER ergänzt */
		    		//len>>=3;	/* len is in bits, adjust */
 
Ich glaube den Wert hatte ich mal ergänzt, falls optional symbolisch auf die 1200er zuzugreifen. Bei den aktuellen 1200ern funktioniert das aber eh wieder völlig anders.
Meiner Meinung nach kannst du es für deine Zwecke entfernen, dann sollte dein NC Zugriff funktionieren und auch der SPS Variablenzugriff, weil libnodave dort immer in Byte-Größen anfragt.

Ich weiß nur noch nicht was ich bei Wireshark mache, ich denke mal wenn dann wird man dort eher SPS Datenverkehr zu Gesicht bekommen. Ansonsten müsste ich schon zur Antwort die Anfrage heraussuchen, und wenn dort ein NCK Bereich angefragt wurde, dann die 5 anders interpretieren. Aber das ist nicht mal grad eben.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Ich hatte in meinem libnodave fork ja den Symbolischen 1200er Zugriff eingebaut. Antwortet die SPS denn darauf immer mit 5? Oder ist das nur bei Integer Variablen so? (Teilt die SPS so die größe mit?)

Geht es denn überhaupt wenn du libnodave änderst und mit "5" anträgst?
 
Ich bin auf ein neues Problem gestoßen.

Wenn ich von der NC viele Variablen lese, werden diese automatisch in mehrere PDUs aufgeteilt.
Im konkreten Fall werden 300 LReal von der NC gelesen und die PDUs werden jeweils bei 77 gesplittet.

Wenn ich an die NC einen Lesebefehl für Drive-Daten schicke bekomme ich bei mehr als 19 Variablen diese Fehlermeldung:
[Error code: This service is not implemented on the module or a frame error was reported (0x8104)]

2018-05-18 15_07_50-Drive PDU Error.png


Wo erfolgt das aufteilen auf mehrere PDUs?

LibNoDave oder DotNetSiemensPlcToolBox
 

Similar threads

E
Snap7 Zugriff auf Dual-Port RAM / FB15 / SINUMERIK
Antworten
1
Aufrufe
4K
Jochen Kühner
Jochen Kühner
Zurück
Oben