设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 电子技术分类讨论区 › PLC/自动化/工控 › 分享libnodave-0.8.5，西门子PLC通讯方法
返回列表 发新帖
查看: 2663|回复: 1
打印 上一主题 下一主题
收起左侧

分享libnodave-0.8.5，西门子PLC通讯方法

[复制链接]
跳转到指定楼层
楼主
ID:394669 发表于 2018-9-6 18:01 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
直接上附件。


单片机源程序如下:
  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

  9. (C) Thomas Hergenhahn (thomas.hergenhahn@web.de) 2002..2005

  11. S5 basic communication parts (C) Andrew Rostovtsew 2004.

  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.

  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.

  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>

  32. #define DUMPLIMIT 11132

  34. #define DAVE_HAVE_MEMCPY  // normally we have

  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

  53. #ifdef HAVE_UNISTD
  54. #include <unistd.h>
  55. #define daveWriteFile(a,b,c,d) d=write(a,b,c)
  56. #endif

  58. #ifdef AVR
  59. #include <unistd.h>
  60. #endif

  62. int daveDebug=0;

  64. #ifdef BCCWIN
  65. #include <winsock2.h>
  66. #include "openS7online.h"        // We can use the Siemens transport dlls only on Windows

  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


  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. }

  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

  111. #ifdef BCCWIN

  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. }

  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


  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;        

  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. }

  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. }

  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. */



  290. void DECL2 daveSetDebug(int nDebug) {
  291. #ifdef DEBUG_CALLS
  292.     LOG2("daveSetDebug(%d)\n",nDebug);
  293.     FLUSH;
  294. #endif        
  295.     daveDebug=nDebug;
  296. }

  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. }

  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. }

  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. }


  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. }

  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. }

  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. }

  359. /**
  360.     PDU handling:
  361. **/

  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. }

  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. }

  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. }

  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

  441.     dtype=p->data+p->dlen-4+1;                        /* position of first byte in the 4 byte sequence */

  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;        

  461. …………
  462. …………
  463. …………限于本文篇幅 余下代码请从51黑下载附件…………

复制代码

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


分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:394669 发表于 2018-9-6 18:04 | 只看该作者
自己顶
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表