Modbus通讯库函数的测试程序

1. 
   
2. Modbus通讯库函数的测试程序 // #############################################################################
   
3. // *****************************************************************************
   
4. //             Copyright (c) 2003-2004, Bocon Automation Corp.
   
5. //     THIS IS AN UNPUBLISHED WORK CONTAINING CONFIDENTIAL AND PROPRIETARY
   
6. //           INFORMATION WHICH IS THE PROPERTY OF E-GUAGE AUTOMATION CORP.
   
7. //
   
8. //   ANY DISCLOSURE, USE, OR REPRODUCTION, WITHOUT WRITTEN AUTHORIZATION FROM
   
9. //           E-GUAGE AUTOMATION CORP., IS STRICTLY PROHIBITED.
   
10. // *****************************************************************************
    
11. // #############################################################################
    
12. //************************* DEBUGGING MACROS ***********************************
    
13. #define BLUE_TEXT   "\x1b[34m" // foreground colors for printf 字串4
    
14. #define RED_TEXT     "\x1b[31m" // foreground colors for printf
    
15. #define BLACK_TEXT   "\x1b[30m" // foreground colors for printf
    
16. #define BINBUFSIZE               255
    
17. #define BOUTBUFSIZE             255
    
18. #use "Modbus.lib"
    
19. #use "TCP-IP.lib"
    
20. #define MODBUS_RTU_MASTER         0x10
    
21. #define MODBUS_RTU_SLAVE           0x20
    
22. #define MODBUS_ASCII_MASTER         0x30
    
23. #define MODBUS_ASCII_SLAVE         0x40
    
24. #define MODBUS_TCP_MASTER         0x50
    
25. #define MODBUS_TCP_SLAVE           0x60
    
26. #define TRANSACTION_TIMEOUT         2000L
    
27. #define MODBUS_MASTER_POLLING_PERIOD   2000L
    
28. // ***************************************************************************** 字串3
    
29. // Design Notes: 非阻塞方式读取键盘输入
    
30. // -----------------------------------------------------------------------------
    
31. char PeekChar()
    
32. {
    
33.   auto char Key;
    
34.   if (!kbhit())
    
35.   {
    
36.     return 0;
    
37.   }
    
38.   dkGetCharFromStdio();
    
39.   Key = dkCharData;
    
40.   asm push      ip
    
41.   asm ipset 1
    
42.   dkCharReady--;
    
43.   asm pop      ip
    
44.   return Key;
    
45. }
    
46. // *****************************************************************************
    
47. // Design Notes: 打印测试信息
    
48. // -----------------------------------------------------------------------------
    
49. void PrintTestInfo()
    
50. {
    
51.   printf( RED_TEXT );
    
52.   printf( "+++Test the Modbus RTU/ASCII/TCP protocol:\n" );
    
53.   printf( "\t 1: Modbus-RTU Maser\n" );
    
54.   printf( "\t 2: Modbus-RTU Slave\n" );
    
55.   printf( "\t 3: Modbus-ASCII Master\n" );
    
56. 字串2
    
57. 
    
58. 
    
59.   printf( "\t 4: Modbus-ASCII Slave\n" );
    
60.   printf( "\t 5: Modbus-TCP Master\n" );
    
61.   printf( "\t 6: Modbus-TCP Slave\n" );
    
62.   printf( BLUE_TEXT );
    
63.   printf( "Press 'Q' to exit the program\n" );
    
64. }
    
65. // *****************************************************************************
    
66. // Design Notes: Print out the buffer contents
    
67. // -----------------------------------------------------------------------------
    
68. void DumpAsciiBuffer( char * pBuffer, int iStrlen )
    
69. {
    
70.   int i;
    
71.   printf( "\n==>The buffer length is %d\n", iStrlen );
    
72.   for ( i = 0; i < iStrlen; i++ )
    
73.   {
    
74.     printf( "%c ", pBuffer );
    
75.   }
    
76.   printf( "\n" );
    
77. }
    
78. // *****************************************************************************
    
79. // Design Notes: Print out the buffer contents 字串6
    
80. // -----------------------------------------------------------------------------
    
81. void DumpHexBuffer( char * pBuffer, int iStrlen )
    
82. {
    
83.   int i;
    
84.   printf( "\n==>The buffer length is %d\n", iStrlen );
    
85.   for ( i = 0; i < iStrlen; i++ )
    
86.   {
    
87.     printf( "0x%02X ", pBuffer );
    
88.   }
    
89.   printf( "\n" );
    
90. }
    
91. // *****************************************************************************
    
92. // Design Notes:
    
93. // -----------------------------------------------------------------------------
    
94. void main()
    
95. {
    
96. char key;
    
97.   char mode;
    
98.   int iRetVal;
    
99.   unsigned long dwStartTime;
    
100.   char srcMsg[256];
     
101.   char dstMsg[256];
     
102.   unsigned short srcMsgLen;
     
103.   unsigned short dstMsgLen;
     
104.   struct MBSerial   mbSer;
     
105.   struct MBSerial * pMBSer;
     
106.   struct MBTCP     mbTCP;
     
107. 字串4
     
108. 
     
109. 
     
110.   struct MBTCP   * pMBTCP;
     
111.   // The server socket for passive calling
     
112.   tcp_Socket serverSock;
     
113.   struct TCPContext   server;
     
114.   struct TCPContext * pServer;
     
115.   // The client socket for active calling
     
116.   tcp_Socket clientSock;
     
117.   struct TCPContext   client;
     
118.   struct TCPContext * pClient;
     
119.   // Initialize memory for the server-node context
     
120.   pServer = &server;
     
121.   memset( pServer, 0x00, sizeof( struct TCPContext ) );
     
122.   pServer->m_pSocket = &serverSock;
     
123.   // Initialize memory for the client-node context
     
124.   pClient = &client;
     
125.   memset( pClient, 0x00, sizeof( struct TCPContext ) );
     
126.   pClient->m_pSocket = &clientSock;
     
127.   // Initialize the TCP/IP stack
     
128.   sock_init();
     
129.   // Initialize the network interface
     
130.   ifconfig(
     
131.     IF_ETH0,
     
132.     IFS_DOWN, 字串2
     
133.     IFS_IPADDR, aton( "172.21.66.25" ),
     
134.     IFS_NETMASK, 0xFFFFFF00uL,
     
135.     IFS_ROUTER_SET, aton( "172.21.66.1" ),
     
136.     IFS_NAMESERVER_SET, aton( "172.21.66.100" ),
     
137.     IFS_NAMESERVER_ADD, aton( "172.21.66.144" ),
     
138.     IFS_UP,
     
139.     IFS_END );
     
140.   // Make sure the interface exits pending status
     
141.   if ( ifpending( IF_ETH0 ) % 2 )
     
142.   {
     
143.     printf( "The cable is plugged out!\n" );
     
144.   }
     
145.   // Make sure the interface is up
     
146.   if ( !ifstatus( IF_ETH0 ) )
     
147.   {
     
148.     // Display some hardware-error information and reset the system
     
149.     forceSoftReset();
     
150.   }
     
151.   // Initialize Modbus Master node
     
152.   pClient->m_bIsTCPServer = 0;
     
153.   pClient->m_dwIPAddr = aton( "172.21.66.154" );
     
154.   pClient->m_usPort = 502; 字串1
     
155.   pClient->m_usMaxSockRetries = 5;
     
156.   pClient->m_usMaxSessionRetries = 3;
     
157.   // Reset the Modbus Master socket
     
158.   ResetTCPSocket( pClient );
     
159.   // Initialize the Modbus Slave node
     
160.   pServer->m_bIsTCPServer = 1;
     
161.   pServer->m_dwIPAddr = gethostid();
     
162.   pServer->m_usPort = 502;
     
163.   pServer->m_usMaxSockRetries = 5;
     
164.   pServer->m_usMaxSessionRetries = 3;
     
165.   // Reset the Modbus Slave socket
     
166.   ResetTCPSocket( pServer );
     
167.   serBopen( 2400 );
     
168.   serBparity( PARAM_NOPARITY );
     
169.   serBdatabits( PARAM_8BIT );
     
170.   // Print out the manipulation information
     
171.   PrintTestInfo();
     
172.   pMBSer = &mbSer;
     
173.   pMBTCP = &mbTCP;
     
174.   memset( pMBSer, 0x00, sizeof( struct MBSerial ) );
     
175.   memset( pMBTCP, 0x00, sizeof( struct MBTCP ) );
     
176.   mode = 0xFF;      // Invalid mode
     
177. 字串4
     
178. 
     
179. 
     
180.   while ( 1 )
     
181.   {
     
182.     // Thread 1st: The user input dispatch
     
183.     costate
     
184.     {
     
185.       key = PeekChar();
     
186.       switch ( key )
     
187.       {
     
188.       case '1':
     
189.         {
     
190.           mode = MODBUS_RTU_MASTER;
     
191.           printf( RED_TEXT );
     
192.           printf( "System now runs in Modbus RTU Maser mode\n" );
     
193.           printf( BLUE_TEXT );
     
194.         }
     
195.         break;
     
196.       case '2':
     
197.         {
     
198.           mode = MODBUS_RTU_SLAVE;
     
199.           printf( RED_TEXT );
     
200.           printf( "System now runs in Modbus RTU Slave mode\n" );
     
201.           printf( BLUE_TEXT ); 字串6
     
202.         }
     
203.         break;
     
204.       case '3':
     
205.         {
     
206.           mode = MODBUS_ASCII_MASTER;
     
207.           printf( RED_TEXT );
     
208.           printf( "System now runs in Modbus ASCII Master mode\n" );
     
209.           printf( BLUE_TEXT );
     
210.         }
     
211.         break;
     
212.       case '4':
     
213.         {
     
214.           mode = MODBUS_ASCII_SLAVE;
     
215.           printf( RED_TEXT );
     
216.           printf( "System now runs in Modbus ASCII Slave mode\n" );
     
217.           printf( BLUE_TEXT );
     
218.         }
     
219.         break;
     
220.       case '5':
     
221.         { 字串9
     
222.           mode = MODBUS_TCP_MASTER;
     
223.           printf( RED_TEXT );
     
224.           printf( "System now runs in Modbus TCP Master mode\n" );
     
225.           printf( BLUE_TEXT );
     
226.           ResetTCPSocket( pServer );
     
227.         }
     
228.         break;
     
229.       case '6':
     
230.         {
     
231.           mode = MODBUS_TCP_SLAVE;
     
232.           printf( RED_TEXT );
     
233.           printf( "System now runs in Modbus TCP Slve mode\n" );
     
234.           printf( BLUE_TEXT );
     
235.           ResetTCPSocket( pClient );
     
236.         }
     
237.         break;
     
238.       default:
     
239.         {
     
240. 字串7
     
241. 
     
242. 
     
243.         }
     
244.         break;
     
245.       }
     
246.     }

复制代码

1.    // Thread 2nd: Modbus-RTU Master
   
2.     costate
   
3.     {
   
4.       if ( mode != MODBUS_RTU_MASTER )
   
5.       {
   
6.         abort;
   
7.       }
   
8.       waitfor ( DelayMs( MODBUS_MASTER_POLLING_PERIOD ) );
   
9.       // Instantiate a modbus request
   
10.       pMBSer->m_ucNodeID = 23;
    
11.       pMBSer->m_MBReqeust.m_ucCMD = 3;
    
12.       pMBSer->m_MBReqeust.m_usStartAddr = 1234;
    
13.       pMBSer->m_MBReqeust.m_usRegNum = 19;
    
14.       // Initialize the modbus request string
    
15.       memset( srcMsg, 0x00, sizeof( srcMsg ) );
    
16.       ConstructModbusRTUMsg( pMBSer, srcMsg );
    
17.       // Dump the Modbus RTU request message 字串1
    
18.       DumpHexBuffer( srcMsg, 8 );
    
19.       // Issue out the Modbus requst
    
20.       serBwrite( srcMsg, 8 );
    
21.       waitfor ( DelayMs( TRANSACTION_TIMEOUT ) );
    
22.       // Receive the Modbus response from the Modbus Slave
    
23.       memset( srcMsg, 0x00, sizeof( srcMsg ) );
    
24.       srcMsgLen = 0;
    
25.       dwStartTime = MS_TIMER;
    
26.       while ( MS_TIMER - dwStartTime < TRANSACTION_TIMEOUT )
    
27.       {
    
28.         iRetVal = serBread( srcMsg + srcMsgLen, sizeof( srcMsg ), 0 );
    
29.         srcMsgLen += iRetVal;
    
30.       }
    
31.       if ( srcMsgLen > 0 )
    
32.       {
    
33.         DumpHexBuffer( srcMsg, srcMsgLen );
    
34.       }
    
35.     }
    
36.     // Thread 3rd: Modbus-RTU Slave
    
37. 字串6
    
38. 
    
39. 
    
40.     costate
    
41.     {
    
42.       if ( mode != MODBUS_RTU_SLAVE )
    
43.       {
    
44.         abort;
    
45.       }
    
46.       // Read Modbus request from the serial port
    
47.       memset( srcMsg, 0x00, sizeof( srcMsg ) );
    
48.       srcMsgLen = serBread( srcMsg, sizeof( srcMsg ), 100 );
    
49.       if ( srcMsgLen > 0 )
    
50.       {
    
51.         // Dump the buffer contents of the modbus request
    
52.         DumpHexBuffer( srcMsg, srcMsgLen );
    
53.         // Process the Modbus request, generate the Modbus respone message
    
54.         ProcessModbusRTUMsg( srcMsg, srcMsgLen, dstMsg, &dstMsgLen );
    
55.         // Send Modbus response message to the Modbus master node
    
56.         serBwrite( dstMsg, dstMsgLen ); 字串4
    
57.       }
    
58.     }
    
59.     // Thread 4th: Modbus-ASCII Master
    
60.     costate
    
61.     {
    
62.       if ( mode != MODBUS_ASCII_MASTER )
    
63.       {
    
64.         abort;
    
65.       }
    
66.       waitfor ( DelayMs( MODBUS_MASTER_POLLING_PERIOD ) );
    
67.       // Instantiate a modbus request
    
68.       pMBSer->m_ucNodeID = 23;
    
69.       pMBSer->m_MBReqeust.m_ucCMD = 3;
    
70.       pMBSer->m_MBReqeust.m_usStartAddr = 1234;
    
71.       pMBSer->m_MBReqeust.m_usRegNum = 19;
    
72.       // Initialize the modbus request string
    
73.       memset( srcMsg, 0x00, sizeof( srcMsg ) );
    
74.       ConstructModbusAsciiMsg( pMBSer, srcMsg );
    
75.       // Dump the modbus requst message
    
76.       DumpAsciiBuffer( srcMsg, 17 ); 字串1
    
77.       // Issue out the Modbus request message
    
78.       serBwrite( srcMsg, 17 );
    
79.       // Receive the response from the Modbus slave
    
80.       memset( srcMsg, 0x00, sizeof( srcMsg ) );
    
81.       srcMsgLen = 0;
    
82.       dwStartTime = MS_TIMER;
    
83.       while ( MS_TIMER - dwStartTime < TRANSACTION_TIMEOUT )
    
84.       {
    
85.         iRetVal = serBread( srcMsg + srcMsgLen, sizeof( srcMsg ), 0 );
    
86.         srcMsgLen += iRetVal;
    
87.       }
    
88.       if ( srcMsgLen > 0 )
    
89.       {
    
90.         DumpAsciiBuffer( srcMsg, srcMsgLen );
    
91.       }
    
92.     }
    
93.     // Thread 5th: Modbus-ASCII Slave
    
94.     costate
    
95.     {
    
96.       if ( mode != MODBUS_ASCII_SLAVE )
    
97. 字串6
    
98. 
    
99. 
    
100.       {
     
101.         abort;
     
102.       }
     
103.       // Read Modbus request from the serial port
     
104.       memset( srcMsg, 0x00, sizeof( srcMsg ) );
     
105.       srcMsgLen = serBread( srcMsg, sizeof( srcMsg ), 100 );
     
106.       if ( srcMsgLen > 0 )
     
107.       {
     
108.         // Dump the buffer contents of the modbus request
     
109.         DumpAsciiBuffer( srcMsg, srcMsgLen );
     
110.         ProcessModbusAsciiMsg( srcMsg, srcMsgLen, dstMsg, &dstMsgLen );
     
111.         // Dump the contents of the modbus response
     
112.         DumpAsciiBuffer( dstMsg, dstMsgLen );
     
113.         // Send response message to the modbus master node
     
114.         serBwrite( dstMsg, dstMsgLen );
     
115.       }
     
116.     }
     
117.     // Thread 6th: Modbus-TCP Master
     
118. 字串4
     
119. 
     
120. 
     
121.     costate
     
122.     {
     
123.       if ( mode != MODBUS_TCP_MASTER )
     
124.       {
     
125.         abort;
     
126.       }
     
127.       waitfor ( DelayMs( 500 ) );
     
128.       RefreshTCPSocketStatus( pClient );
     
129.       if ( pClient->m_bIsConnected )
     
130.       {
     
131.         pMBTCP->m_MBHeader.m_usProtoID = 0;
     
132.         pMBTCP->m_MBHeader.m_usMsgLen = 6;
     
133.         pMBTCP->m_MBHeader.m_ucUnitID = 29;
     
134.         pMBTCP->m_MBReqeust.m_ucCMD = 3;
     
135.         pMBTCP->m_MBReqeust.m_usStartAddr = 1234;
     
136.         pMBTCP->m_MBReqeust.m_usRegNum = 50;
     
137.         memset( srcMsg, 0x00, sizeof( srcMsg ) );
     
138.         ConstructModbusTCPMsg( pMBTCP, srcMsg );
     
139.         sock_fastwrite( pClient->m_pSocket, srcMsg, 12 ); 字串1
     
140.         memset( srcMsg, 0x00, sizeof( srcMsg ) );
     
141.         srcMsgLen = 0;
     
142.         dwStartTime = MS_TIMER;
     
143.         while ( MS_TIMER - dwStartTime < TRANSACTION_TIMEOUT )
     
144.         {
     
145.           tcp_tick( pClient->m_pSocket );
     
146.           iRetVal = sock_fastread( pClient->m_pSocket, srcMsg + srcMsgLen, sizeof( srcMsg ) );
     
147.           srcMsgLen += iRetVal;
     
148.         }
     
149.         if ( srcMsgLen != 0 )
     
150.         {
     
151.           DumpHexBuffer( srcMsg, srcMsgLen );
     
152.         }
     
153.       }
     
154.     }
     
155.     // Thread 7th: Modbus-TCP Slave
     
156.     costate
     
157.     {
     
158.       if ( mode != MODBUS_TCP_SLAVE )
     
159. 字串9
     
160. 
     
161. 
     
162.       {
     
163.         abort;
     
164.       }
     
165.       waitfor ( DelayMs( 500 ) );
     
166.       RefreshTCPSocketStatus( pServer );
     
167.       if ( pServer->m_bIsConnected )
     
168.       {
     
169.         memset( srcMsg, 0x00, sizeof( srcMsg ) );
     
170.         srcMsgLen = sock_fastread( pServer->m_pSocket, srcMsg, sizeof( srcMsg ) );
     
171.         if ( srcMsgLen != 0 )
     
172.         {
     
173.           DumpHexBuffer( srcMsg, srcMsgLen );
     
174.           memset( dstMsg, 0x00, sizeof( dstMsg ) );
     
175.           ProcessModbusTCPMsg( srcMsg, srcMsgLen, dstMsg, &dstMsgLen );
     
176.           if ( dstMsgLen != 0 )
     
177.           {
     
178.             sock_fastwrite( pServer->m_pSocket, dstMsg, dstMsgLen );
     
179. 字串6
     
180. 
     
181. 
     
182.             DumpHexBuffer( dstMsg, dstMsgLen );
     
183.           }
     
184.         }
     
185.       }
     
186.     }
     
187.   }
     
188. }

复制代码