标题: 分享libnodave-0.8.5，西门子PLC通讯方法 [打印本页]

---

作者: dennis22041    时间: 2018-9-6 18:01
标题: 分享libnodave-0.8.5，西门子PLC通讯方法
直接上附件。


单片机源程序如下:

1. /*
   
2. Part of Libnodave, a free communication libray for Siemens S7 200/300/400 via
   
3. the MPI adapter 6ES7 972-0CA22-0XAC
   
4. or  MPI adapter 6ES7 972-0CA23-0XAC
   
5. or  TS adapter 6ES7 972-0CA33-0XAC
   
6. or  MPI adapter 6ES7 972-0CA11-0XAC,
   
7. IBH/MHJ-NetLink or CPs 243, 343 and 443
   
8. 
   
9. (C) Thomas Hergenhahn (thomas.hergenhahn@web.de) 2002..2005
   
10. 
    
11. S5 basic communication parts (C) Andrew Rostovtsew 2004.
    
12. 
    
13. Libnodave is free software; you can redistribute it and/or modify
    
14. it under the terms of the GNU Library General Public License as published by
    
15. the Free Software Foundation; either version 2, or (at your option)
    
16. any later version.
    
17. 
    
18. Libnodave is distributed in the hope that it will be useful,
    
19. but WITHOUT ANY WARRANTY; without even the implied warranty of
    
20. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
21. GNU General Public License for more details.
    
22. 
    
23. You should have received a copy of the GNU Library General Public License
    
24. along with Libnodave; see the file COPYING.  If not, write to
    
25. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  
    
26. */
    
27. #include "nodave.h"
    
28. #include <stdio.h>
    
29. #include "log2.h"
    
30. #include <string.h>
    
31. 
    
32. #define DUMPLIMIT 11132
    
33. 
    
34. #define DAVE_HAVE_MEMCPY  // normally we have
    
35. 
    
36. //#define DEBUG_CALLS        // Define this and recompile to get parameters and results
    
37.                         // of each function call printed. I could have made this an
    
38.                         // option bit in daveDebug, but most applications will never,never
    
39.                         // need it. Still they would have to do the jumps...
    
40.                         // This option is just useful when developing bindings to new
    
41.                         // programming languages.
    
42. /**
    
43.     Library specific:
    
44. **/
    
45. #ifdef LINUX
    
46. #define HAVE_UNISTD
    
47. #define HAVE_SELECT
    
48. #define DECL2
    
49. #include <time.h>
    
50. #include <sys/time.h>
    
51. #endif
    
52. 
    
53. #ifdef HAVE_UNISTD
    
54. #include <unistd.h>
    
55. #define daveWriteFile(a,b,c,d) d=write(a,b,c)
    
56. #endif
    
57. 
    
58. #ifdef AVR
    
59. #include <unistd.h>
    
60. #endif
    
61. 
    
62. int daveDebug=0;
    
63. 
    
64. #ifdef BCCWIN
    
65. #include <winsock2.h>
    
66. #include "openS7online.h"        // We can use the Siemens transport dlls only on Windows
    
67. 
    
68. void setTimeOut(daveInterface * di, int tmo) {
    
69.     COMMTIMEOUTS cto;
    
70. #ifdef DEBUG_CALLS
    
71.     LOG3("setTimeOut(di:%p, time:%d)\n",        di,tmo);
    
72.     FLUSH;
    
73. #endif            
    
74. //    if(di->fd.connectionType==daveSerialConnection) {
    
75.         GetCommTimeouts(di->fd.rfd, &cto);
    
76.         cto.ReadIntervalTimeout=0;
    
77.         cto.ReadTotalTimeoutMultiplier=0;
    
78.         cto.ReadTotalTimeoutConstant=tmo/1000;
    
79.         SetCommTimeouts(di->fd.rfd,&cto);
    
80. //    } else if(di->fd.connectionType==daveTcpConnection) {  
    
81. //    }
    
82. }   
    
83. #endif
    
84. 
    
85. 
    
86. #ifdef HAVE_SELECT
    
87. int DECL2 stdwrite(daveInterface * di, char * buffer, int length) {
    
88.     if (daveDebug & daveDebugByte)
    
89.         _daveDump("I send", (uc*)buffer, length);
    
90.     return write(di->fd.wfd, buffer,length);
    
91. }
    
92. 
    
93. int DECL2 stdread(daveInterface * di, char * buffer, int length) {
    
94.     fd_set FDS;        
    
95.     struct timeval t;
    
96.     int i;
    
97.     t.tv_sec = di->timeout / 1000000;
    
98.     t.tv_usec = (di->timeout % 1000000);
    
99.     FD_ZERO(&FDS);
    
100.     FD_SET(di->fd.rfd, &FDS);
     
101.     i=0;
     
102.     if(select(di->fd.rfd + 1, &FDS, NULL, NULL, &t)>0) {
     
103.         i=read(di->fd.rfd, buffer, length);
     
104.     }
     
105. //    if (daveDebug & daveDebugByte)
     
106. //        _daveDump("got",buffer,i);
     
107.     return i;
     
108. }
     
109. #endif
     
110. 
     
111. #ifdef BCCWIN
     
112. 
     
113. int DECL2 stdread(daveInterface * di,
     
114.          char * buffer,
     
115.          int length) {
     
116.     unsigned long i;
     
117.     ReadFile(di->fd.rfd, buffer, length, &i, NULL);
     
118. //    if (daveDebug & daveDebugByte)
     
119. //        _daveDump("got",buffer,i);
     
120.     return i;
     
121. }
     
122. 
     
123. int DECL2 stdwrite(daveInterface * di, char * buffer, int length) {
     
124.     unsigned long i;
     
125.     if (daveDebug & daveDebugByte)
     
126.         _daveDump("I send",buffer,length);
     
127. //    EscapeCommFunction(di->fd.rfd, CLRRTS);  // patch from Keith Harris. He says:
     
128.                                              //******* this is what microwin does (needed for usb-serial)        
     
129.     WriteFile(di->fd.rfd, buffer, length, &i,NULL);
     
130. // patch from Andrea. He says:
     
131. // In this way the PC Adapter connected to CPU313C hangs waiting for RTS line before answering back.
     
132. // Added the following to regain answers:
     
133. //    EscapeCommFunction(di->fd.rfd, SETRTS);
     
134.     return i;
     
135. }
     
136. #endif
     
137. 
     
138. 
     
139. /*
     
140.     Setup a new interface structure from an initialized serial interface's handle and a name.
     
141. */
     
142. daveInterface * DECL2 daveNewInterface(_daveOSserialType nfd, char * nname, int localMPI, int protocol, int speed){
     
143.     daveInterface * di=(daveInterface *) calloc(1, sizeof(daveInterface));
     
144. #ifdef DEBUG_CALLS
     
145.     LOG7("daveNewInterface(fd.rfd:%d fd.wfd:%d name:%s local MPI:%d protocol:%d PB speed:%d)\n",
     
146.         nfd.rfd,nfd.wfd,nname, localMPI, protocol, speed);
     
147.     FLUSH;        
     
148. #endif        
     
149.     if (di) {
     
150. //        di->name=nname;
     
151.         strncpy(di->realName,nname,20);
     
152.         di->name=di->realName;
     
153.         di->fd=nfd;
     
154.         di->localMPI=localMPI;
     
155.         di->protocol=protocol;
     
156.         di->timeout=1000000; /* 1 second */
     
157.         di->nextConnection=0x14;
     
158.         di->speed=speed;
     
159.         
     
160.         di->getResponse=_daveGetResponseISO_TCP;
     
161.         di->ifread=stdread;
     
162.         di->ifwrite=stdwrite;
     
163.         di->initAdapter=_daveReturnOkDummy;        
     
164.         di->connectPLC=_daveReturnOkDummy2;
     
165.         di->disconnectPLC=_daveReturnOkDummy2;
     
166.         di->disconnectAdapter=_daveReturnOkDummy;        
     
167.         di->listReachablePartners=_daveListReachablePartnersDummy;
     
168.         switch (protocol) {
     
169.             case daveProtoMPI:
     
170.                 di->initAdapter=_daveInitAdapterMPI1;
     
171.                 di->connectPLC=_daveConnectPLCMPI1;
     
172.                 di->disconnectPLC=_daveDisconnectPLCMPI;
     
173.                 di->disconnectAdapter=_daveDisconnectAdapterMPI;
     
174.                 di->exchange=_daveExchangeMPI;
     
175.                 di->sendMessage=_daveSendMessageMPI;
     
176.                 di->getResponse=_daveGetResponseMPI;
     
177.                 di->listReachablePartners=_daveListReachablePartnersMPI;
     
178.                 break;        
     
179.                     
     
180.             case daveProtoMPI2:
     
181.             case daveProtoMPI4:
     
182.                 di->initAdapter=_daveInitAdapterMPI2;
     
183.                 di->connectPLC=_daveConnectPLCMPI2;
     
184.                 di->disconnectPLC=_daveDisconnectPLCMPI;
     
185.                 di->disconnectAdapter=_daveDisconnectAdapterMPI;
     
186.                 di->exchange=_daveExchangeMPI;
     
187.                 di->sendMessage=_daveSendMessageMPI;
     
188.                 di->getResponse=_daveGetResponseMPI;
     
189.                 di->listReachablePartners=_daveListReachablePartnersMPI;
     
190.                 di->nextConnection=0x3;
     
191.                 break;
     
192.             
     
193.             case daveProtoMPI3:
     
194.                 di->initAdapter=_daveInitAdapterMPI3;
     
195.                 di->connectPLC=_daveConnectPLCMPI3;
     
196.                 di->disconnectPLC=_daveDisconnectPLCMPI3;
     
197.                 di->disconnectAdapter=_daveDisconnectAdapterMPI3;
     
198.                 di->exchange=_daveExchangeMPI3;
     
199.                 di->sendMessage=_daveSendMessageMPI3;
     
200.                 di->getResponse=_daveGetResponseMPI3;
     
201.                 di->listReachablePartners=_daveListReachablePartnersMPI3;
     
202.                 di->nextConnection=0x3;
     
203.                 break;        
     
204. 
     
205.             case daveProtoISOTCP:
     
206.             case daveProtoISOTCP243:
     
207.                 di->getResponse=_daveGetResponseISO_TCP;
     
208.                 di->connectPLC=_daveConnectPLCTCP;
     
209.                 di->exchange=_daveExchangeTCP;
     
210.                 break;               
     
211.                
     
212.             case daveProtoPPI:
     
213.                 di->getResponse=_daveGetResponsePPI;
     
214.                 di->exchange=_daveExchangePPI;
     
215.                 di->connectPLC=_daveConnectPLCPPI;
     
216.                 di->timeout=150000; /* 0.15 seconds */
     
217.                 break;
     
218.             case daveProtoMPI_IBH:
     
219.                 di->exchange=_daveExchangeIBH;
     
220.                 di->connectPLC=_daveConnectPLC_IBH;
     
221.                 di->disconnectPLC=_daveDisconnectPLC_IBH;
     
222.                 di->sendMessage=_daveSendMessageMPI_IBH;
     
223.                 di->getResponse=_daveGetResponseMPI_IBH;
     
224.                 di->listReachablePartners=_daveListReachablePartnersMPI_IBH;
     
225.                 break;        
     
226.             case daveProtoPPI_IBH:
     
227.                 di->exchange=_daveExchangePPI_IBH;
     
228.                 di->connectPLC=_daveConnectPLCPPI;
     
229.                 di->sendMessage=_daveSendMessageMPI_IBH;
     
230.                 di->getResponse=_daveGetResponsePPI_IBH;
     
231.                 di->listReachablePartners=_daveListReachablePartnersMPI_IBH;
     
232.                 break;        
     
233.             case daveProtoS7online:
     
234.                 di->exchange=_daveExchangeS7online;
     
235.                 di->connectPLC=_daveConnectPLCS7online;
     
236.                 di->sendMessage=_daveSendMessageS7online;
     
237.                 di->getResponse=_daveGetResponseS7online;
     
238.                 di->listReachablePartners=_daveListReachablePartnersS7online;
     
239.                 di->disconnectPLC=_daveDisconnectPLCS7online;
     
240. //                di->disconnectAdapter=_daveDisconnectAdapterS7online;
     
241.                 break;               
     
242.             case daveProtoAS511:
     
243.                 di->connectPLC=_daveConnectPLCAS511;
     
244.                 di->disconnectPLC=_daveDisconnectPLCAS511;
     
245.                 di->exchange=_daveFakeExchangeAS511;
     
246.                 di->sendMessage=_daveFakeExchangeAS511;
     
247.                 break;               
     
248.             case daveProtoNLpro:
     
249.                 di->initAdapter=_daveInitAdapterNLpro;
     
250.                 di->connectPLC=_daveConnectPLCNLpro;
     
251.                 di->disconnectPLC=_daveDisconnectPLCNLpro;
     
252.                 di->disconnectAdapter=_daveDisconnectAdapterNLpro;
     
253.                 di->exchange=_daveExchangeNLpro;
     
254.                 di->sendMessage=_daveSendMessageNLpro;
     
255.                 di->getResponse=_daveGetResponseNLpro;
     
256.                 di->listReachablePartners=_daveListReachablePartnersNLpro;
     
257.                 break;
     
258.         
     
259.         }
     
260. #ifdef BCCWIN
     
261.         setTimeOut(di, di->timeout);
     
262. #endif
     
263.     }
     
264.     return di;        
     
265. }
     
266. 
     
267. daveInterface * DECL2 davePascalNewInterface(_daveOSserialType* nfd, char * nname, int localMPI, int protocol, int speed){
     
268. #ifdef DEBUG_CALLS
     
269.     LOG7("davePascalNewInterface(fd.rfd:%d fd.wfd:%d name:%s local MPI:%d protocol:%d PB speed:%d)\n",
     
270.         nfd->rfd,nfd->wfd,nname, localMPI, protocol, speed);
     
271.     FLUSH;        
     
272. #endif        
     
273.     return daveNewInterface(*nfd,nname, localMPI, protocol, speed);
     
274. }
     
275. 
     
276. /*
     
277.     debugging:
     
278.     set debug level by setting variable daveDebug. Debugging is split into
     
279.     several topics. Output goes to stderr.
     
280.     The file descriptor is written after the module name, so you may
     
281.     distinguish messages from multiple connections.
     
282.    
     
283.     naming: all stuff begins with dave... to avoid conflicts with other
     
284.     namespaces. Things beginning with _dave.. are not intended for
     
285.     public use.
     
286. */
     
287. 
     
288. 
     
289. 
     
290. void DECL2 daveSetDebug(int nDebug) {
     
291. #ifdef DEBUG_CALLS
     
292.     LOG2("daveSetDebug(%d)\n",nDebug);
     
293.     FLUSH;
     
294. #endif        
     
295.     daveDebug=nDebug;
     
296. }
     
297. 
     
298. int DECL2 daveGetDebug() {
     
299. #ifdef DEBUG_CALLS
     
300.     LOG1("daveGetDebug()\n");
     
301.     FLUSH;
     
302. #endif        
     
303.     return daveDebug;
     
304. }
     
305. /**
     
306.     C# interoperability:
     
307. **/
     
308. void DECL2 daveSetTimeout(daveInterface * di, int tmo) {
     
309. #ifdef DEBUG_CALLS
     
310.     LOG3("daveSetTimeOut(di:%p, time:%d)\n",        di,tmo);
     
311. #endif            
     
312.     di->timeout=tmo;
     
313. #ifdef BCCWIN
     
314.     setTimeOut(di,tmo);
     
315. #endif   
     
316. }
     
317. 
     
318. int DECL2 daveGetTimeout(daveInterface * di) {
     
319. #ifdef DEBUG_CALLS
     
320.     LOG2("daveGetTimeOut(di:%p)\n",di);
     
321.     FLUSH;
     
322. #endif            
     
323.     return di->timeout;
     
324. }
     
325. 
     
326. char * DECL2 daveGetName(daveInterface * di) {
     
327. #ifdef DEBUG_CALLS
     
328.     LOG2("daveGetName(di:%p)\n",di);
     
329.     FLUSH;
     
330. #endif            
     
331.     return di->name;
     
332. }
     
333. 
     
334. 
     
335. int DECL2 daveGetMPIAdr(daveConnection * dc) {
     
336. #ifdef DEBUG_CALLS
     
337.     LOG2("daveGetMPIAdr(dc:%p)\n",dc);
     
338.     FLUSH;
     
339. #endif            
     
340.     return dc->MPIAdr;
     
341. }
     
342. 
     
343. int DECL2 daveGetAnswLen(daveConnection * dc) {
     
344. #ifdef DEBUG_CALLS
     
345.     LOG2("daveGetAnswLen(dc:%p)\n",dc);
     
346.     FLUSH;
     
347. #endif            
     
348.     return dc->AnswLen;
     
349. }
     
350. 
     
351. int DECL2 daveGetMaxPDULen(daveConnection * dc) {
     
352. #ifdef DEBUG_CALLS
     
353.     LOG2("daveGetMaxPDULen(dc:%p)\n",dc);
     
354.     FLUSH;
     
355. #endif            
     
356.     return dc->maxPDUlength;
     
357. }
     
358. 
     
359. /**
     
360.     PDU handling:
     
361. **/
     
362. 
     
363. /*
     
364.     set up the header. Needs valid header pointer
     
365. */
     
366. void DECL2 _daveInitPDUheader(PDU * p, int type) {
     
367.     memset(p->header, 0, sizeof(PDUHeader));
     
368.     if (type==2 || type==3)
     
369.         p->hlen=12;
     
370.     else
     
371.         p->hlen=10;
     
372.     p->param=p->header+p->hlen;
     
373.     ((PDUHeader*)p->header)->P=0x32;
     
374.     ((PDUHeader*)p->header)->type=type;
     
375.     p->dlen=0;
     
376.     p->plen=0;
     
377.     p->udlen=0;
     
378.     p->data=NULL;
     
379.     p->udata=NULL;
     
380. }
     
381. 
     
382. /*
     
383.     add parameters after header, adjust pointer to data.
     
384.     needs valid header
     
385. */
     
386. void DECL2 _daveAddParam(PDU * p,uc * param,us len) {
     
387. #ifdef DEBUG_CALLS
     
388.     LOG4("_daveAddParam(PDU:%p, param %p, len:%d)\n", p, param, len);
     
389.     FLUSH;
     
390. #endif
     
391.     p->plen=len;
     
392. #ifdef DAVE_HAVE_MEMCPY
     
393.     memcpy(p->param, param, len);
     
394. #else
     
395.     int i;
     
396.     for (i=0;i<len;i++) p->param[i]=param[i];
     
397. #endif
     
398.     ((PDUHeader2*)p->header)->plenHi=len/256;
     
399.     ((PDUHeader2*)p->header)->plenLo=len%256;
     
400. //    ((PDUHeader*)p->header)->plen=daveSwapIed_16(len);
     
401.     p->data=p->param+len;
     
402.     p->dlen=0;
     
403. }
     
404. 
     
405. /*
     
406.     add data after parameters, set dlen
     
407.     needs valid header,parameters
     
408. */
     
409. void DECL2 _daveAddData(PDU * p,void * data,int len) {
     
410. #ifdef DEBUG_CALLS
     
411.     LOG4("_daveAddData(PDU:%p, data %p, len:%d)\n", p, data, len);
     
412. //    _daveDumpPDU(p);
     
413.     FLUSH;
     
414. #endif
     
415.     uc * dn= p->data+p->dlen;
     
416.     p->dlen+=len;
     
417. #ifdef DAVE_HAVE_MEMCPY
     
418.     memcpy(dn, data, len);
     
419. #else
     
420.     int i; uc * d=(uc*)data;
     
421.     for (i=0;i<len;i++) p->data[p->dlen+i]=d[i];
     
422. #endif
     
423.     ((PDUHeader2*)p->header)->dlenHi=p->dlen/256;
     
424.     ((PDUHeader2*)p->header)->dlenLo=p->dlen%256;
     
425. //    ((PDUHeader*)p->header)->dlen=daveSwapIed_16(p->dlen);
     
426. }
     
427. 
     
428. /*
     
429.     add values after value header in data, adjust dlen and data count.
     
430.     needs valid header,parameters,data,dlen
     
431. */
     
432. void DECL2 _daveAddValue(PDU * p,void * data,int len) {
     
433.     us dCount;
     
434.     uc * dtype;
     
435. #ifdef DEBUG_CALLS
     
436.     LOG4("_daveAddValue(PDU:%p, data %p, len:%d)\n", p, data, len);
     
437.     _daveDumpPDU(p);
     
438.     FLUSH;
     
439. #endif
     
440. 
     
441.     dtype=p->data+p->dlen-4+1;                        /* position of first byte in the 4 byte sequence */
     
442. 
     
443.     dCount= p->data[p->dlen-4+2+1];
     
444.     dCount+= 256*p->data[p->dlen-4+2];
     
445.    
     
446.     if (daveDebug & daveDebugPDU)
     
447.         LOG2("dCount: %d\n", dCount);
     
448.     if (*dtype==4) {        /* bit data, length is in bits */
     
449.         dCount+=8*len;
     
450.     } else if (*dtype==9) {        /* byte data, length is in bytes */
     
451.         dCount+=len;
     
452.     } else if (* dtype==3) {        /* bit data, length is in bits */
     
453.         dCount+=len;        
     
454.     } else {
     
455.         if (daveDebug & daveDebugPDU)
     
456.             LOG2("unknown data type/length: %d\n", *dtype);
     
457.     }            
     
458.     if (p->udata==NULL) p->udata=p->data+4;
     
459.     p->udlen+=len;        
     
460. 
     
461. …………
     
462. …………
     
463. …………限于本文篇幅 余下代码请从51黑下载附件…………
     
464. 
     

复制代码

所有资料51hei提供下载:
libnodave-0.8.5.rar (3.26 MB, 下载次数: 11)

2018-9-6 18:01 上传

点击文件名下载附件
西门子通讯方法
下载积分: 黑币 -5

---

作者: dennis22041    时间: 2018-9-6 18:04
自己顶

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1