This file contains higher level modbus TCP utility functions.
History: Date Author Comment 08-17-2005 AceLan Kao. Create it.
Definition in file mbtcp.c.
#include <string.h>
#include "mbtcp.h"
Include dependency graph for mbtcp.c:
Go to the source code of this file.
Functions | |
int | MBTCPBlockRead (int fd, u8 *buf, int len) |
block read from TCP socket | |
int | MBTCPClientClose (int fd) |
int | MBTCPClientConnect (const int clientfd, const char *addr, int port) |
connect to TCP server | |
int | MBTCPClientInit (int *clientfd) |
initialize modbus TCP client | |
int | MBTCPGetMBAP (u8 *adu, pMBAPStruct mbap) |
get MBAP struct from adu | |
int | MBTCPGetPDU (u8 *buf, u8 *adu, int len) |
get PDU from adu | |
int | MBTCPMakeMBAP (pMBAPStruct mbap, u16 tid, u16 len, u8 uid) |
make MBAP struct | |
int | MBTCPMaskwWriteRegister (int fd, u16 reg, u16 andmask, u16 ormask, pMBAPStruct mbap) |
send Mask Write Register request and get response(0x16) | |
int | MBTCPNonBlockRead (int fd, u8 *buf, int len) |
non-block read from TCP socket | |
int | MBTCPReadCoils (int fd, u16 startcoils, u16 no, u8 *value, pMBAPStruct mbap) |
send Read Coils request and get response(0x01) | |
int | MBTCPReadDecreteInputs (int fd, u16 startdec, u16 no, u8 *value, pMBAPStruct mbap) |
Modbus over TCP/IP master function. | |
int | MBTCPReadFIFOQueue (int fd, u16 FIFOAddr, u16 *FIFOCount, u16 *FIFOValue, pMBAPStruct mbap) |
send Read FIFO Queue request and get response(0x18) | |
int | MBTCPReadHoldingRegisters (int fd, u16 startreg, u16 no, u16 *value, pMBAPStruct mbap) |
send Read Holding Registers request and get response(0x03) | |
int | MBTCPReadInputRegisters (int fd, u16 startreg, u16 no, u16 *value, pMBAPStruct mbap) |
send Read Input Registers request and get response(0x04) | |
int | MBTCPReadWriteMultipleRegisters (int fd, u16 rsreg, u16 rno, u16 *rv, u16 wsreg, u16 wno, u8 count, u16 *wv, pMBAPStruct mbap) |
send Read Write Multiple Registers request and get response(0x17) | |
int | MBTCPSendAndWaitResponse (int fd, u8 *buf, u8 *pdu, int len, pMBAPStruct mbap) |
send adu packet through TCP socket and wait response adu from slave | |
int | MBTCPSendReadCoils (int fd, u16 no, u8 *value, pMBAPStruct mbap) |
send Read Coils response(0x01) | |
int | MBTCPSendReadDecreteInputs (int fd, u16 no, u8 *value, pMBAPStruct mbap) |
Modbus over TCP/IP slave function. | |
int | MBTCPSendReadFIFOQueue (int fd, u16 no, u16 count, u16 *value, pMBAPStruct mbap) |
send Read FIFO Queue response(0x18) | |
int | MBTCPSendReadHoldingRegisters (int fd, u16 no, u16 *value, pMBAPStruct mbap) |
send Read Holding Registers response(0x03) | |
int | MBTCPSendReadInputRegisters (int fd, u16 no, u16 *value, pMBAPStruct mbap) |
send Read Input Registers response(0x04) | |
int | MBTCPSendWriteMultipleRegisters (int fd, u16 startdevreg, u16 noreg, u8 count, u16 *value, pMBAPStruct mbap) |
send Write Multiple Registers response(0x10) | |
int | MBTCPSendWriteSingleCoil (int fd, u16 coilreg, u16 onoff, pMBAPStruct mbap) |
send Write Single Coil response(0x05) | |
int | MBTCPSendWriteSingleRegister (int fd, u16 reg, u16 value, pMBAPStruct mbap) |
send Write Single Register response(0x06) | |
int | MBTCPServerClose (int fd) |
int | MBTCPServerInit (int port, int *serverfd) |
Modbus over TCP/IP API. | |
int | MBTCPServerWaitConnection (const int serverfd, int *clientfd, char *client_addr) |
wait modbus master device connect | |
int | MBTCPWrite (int fd, u8 *pdu, int len, pMBAPStruct mbap) |
write to TCP socket | |
int | MBTCPWriteMBAP (char *buf, pMBAPStruct mbap) |
write MBAP struct to buffer | |
int | MBTCPWriteMultipleCoils (int fd, u16 startcoils, u16 no, u8 *value, pMBAPStruct mbap) |
send Write Multiple Coils request and get response(0x0F) | |
int | MBTCPWriteMultipleRegisters (int fd, u16 startreg, u16 noreg, u8 count, u16 *value, pMBAPStruct mbap) |
send Write Multiple Registers request and get response(0x10) | |
int | MBTCPWriteSingleCoil (int fd, u16 coilreg, u16 onoff, pMBAPStruct mbap) |
send Write Single Coil request and get response(0x05) | |
int | MBTCPWriteSingleRegister (int fd, u16 devicereg, u16 value, pMBAPStruct mbap) |
send Write Single Register request and get response(0x06) |
|
block read from TCP socket
Definition at line 103 of file mbtcp.c. References TCPBlockRead(). Referenced by MBTCPSendAndWaitResponse(), and serial_slave(). 00104 { 00105 return TCPBlockRead( fd, buf, len); 00106 }
Here is the call graph for this function: ![]() |
|
Definition at line 135 of file mbtcp.c.
|
|
connect to TCP server
Definition at line 75 of file mbtcp.c. References TCPClientConnect(). Referenced by serial_master(), and serial_master_child(). 00076 { 00077 return TCPClientConnect( clientfd, addr, port); 00078 }
Here is the call graph for this function: ![]() |
|
initialize modbus TCP client
Definition at line 61 of file mbtcp.c. References TCPClientInit(). Referenced by serial_master(), and serial_master_child(). 00062 { 00063 return TCPClientInit( clientfd); 00064 }
Here is the call graph for this function: ![]() |
|
get MBAP struct from adu
Definition at line 148 of file mbtcp.c. References GETU16, _MBAP_Struct::Length, MB_OK, _MBAP_Struct::ProtocolIdentifier, _MBAP_Struct::TransactionIdentifier, and _MBAP_Struct::UnitIdentifier. Referenced by MBTCPSendAndWaitResponse(), serial_master_child(), and serial_slave_child(). 00149 { 00150 GETU16( mbap->TransactionIdentifier, adu); 00151 GETU16( mbap->ProtocolIdentifier, adu+ 2); 00152 GETU16( mbap->Length, adu+ 4); 00153 mbap->UnitIdentifier= adu[ 6]; 00154 00155 return MB_OK; 00156 }
|
|
get PDU from adu
Definition at line 205 of file mbtcp.c. Referenced by MBTCPMaskwWriteRegister(), MBTCPReadCoils(), MBTCPReadDecreteInputs(), MBTCPReadFIFOQueue(), MBTCPReadHoldingRegisters(), MBTCPReadInputRegisters(), MBTCPReadWriteMultipleRegisters(), MBTCPWriteMultipleCoils(), MBTCPWriteMultipleRegisters(), MBTCPWriteSingleCoil(), MBTCPWriteSingleRegister(), serial_master_child(), and serial_slave_child(). 00206 { 00207 bcopy( (const char *)(adu+ 7), (char *)buf, len- 7); 00208 00209 return len- 7; 00210 }
|
|
make MBAP struct
Definition at line 168 of file mbtcp.c. References _MBAP_Struct::Length, MB_OK, _MBAP_Struct::ProtocolIdentifier, _MBAP_Struct::TransactionIdentifier, and _MBAP_Struct::UnitIdentifier. Referenced by serial_master_child(), and serial_slave_child(). 00169 { 00170 mbap->TransactionIdentifier= tid; 00171 mbap->ProtocolIdentifier= 0; 00172 mbap->Length= len; 00173 mbap->UnitIdentifier= uid; 00174 00175 return MB_OK; 00176 }
|
|
send Mask Write Register request and get response(0x16)
Definition at line 564 of file mbtcp.c. References _MBAP_Struct::Length, MAX_BUFFER_SIZE, MB_ASCII_ADU_MAX_LENGTH, MB_ERROR_EXECPTION, MB_OK, MBGetResponseMaskWriteRegister(), MBMaskWriteRegister(), MBTCPGetPDU(), and MBTCPSendAndWaitResponse(). 00565 { 00566 u8 adu[ MB_ASCII_ADU_MAX_LENGTH], pdu[ MAX_BUFFER_SIZE]; 00567 int pdu_len= 0, adu_len= 0, ret= 0; 00568 u16 ret_reg, ret_and, ret_or; 00569 00570 pdu_len= MBMaskWriteRegister( pdu, reg, andmask, ormask); // make PDU 00571 mbap->Length= pdu_len+ 1; // plus 1 for address 00572 00573 adu_len= MBTCPSendAndWaitResponse( fd, adu, pdu, pdu_len, mbap); 00574 00575 if( adu_len < 0) 00576 return adu_len; 00577 00578 pdu_len= MBTCPGetPDU( pdu, adu, adu_len); 00579 ret= MBGetResponseMaskWriteRegister( pdu, &ret_reg, &ret_and, &ret_or); 00580 00581 if( ret < 0) 00582 return ret; 00583 if( ( ret_reg != reg) || ( ret_and != andmask) || ( ret_or != ormask)) 00584 return MB_ERROR_EXECPTION; 00585 return MB_OK; 00586 }
Here is the call graph for this function: ![]() |
|
non-block read from TCP socket
Definition at line 89 of file mbtcp.c. References TCPNonBlockRead(). 00090 { 00091 return TCPNonBlockRead( fd, buf, len); 00092 }
Here is the call graph for this function: ![]() |
|
send Read Coils request and get response(0x01)
Definition at line 289 of file mbtcp.c. References _MBAP_Struct::Length, MAX_BUFFER_SIZE, MB_ASCII_ADU_MAX_LENGTH, MBGetResponseReadCoils(), MBReadCoils(), MBTCPGetPDU(), and MBTCPSendAndWaitResponse(). 00290 { 00291 u8 adu[ MB_ASCII_ADU_MAX_LENGTH], pdu[ MAX_BUFFER_SIZE]; 00292 int pdu_len= 0, adu_len= 0, ret= 0; 00293 u8 ret_no; 00294 00295 pdu_len= MBReadCoils( pdu, startcoils, no); // make PDU 00296 mbap->Length= pdu_len+ 1; // plus 1 for address 00297 00298 adu_len= MBTCPSendAndWaitResponse( fd, adu, pdu, pdu_len, mbap); 00299 00300 if( adu_len < 0) 00301 return adu_len; 00302 00303 pdu_len= MBTCPGetPDU( pdu, adu, adu_len); 00304 ret= MBGetResponseReadCoils( pdu, &ret_no, value); 00305 if( ret < 0) 00306 return ret; 00307 return ret_no; 00308 }
Here is the call graph for this function: ![]() |
|
Modbus over TCP/IP master function.
Definition at line 257 of file mbtcp.c. References _MBAP_Struct::Length, MAX_BUFFER_SIZE, MB_ASCII_ADU_MAX_LENGTH, MBGetResponseReadDecreteInputs(), MBReadDecreteInputs(), MBTCPGetPDU(), and MBTCPSendAndWaitResponse(). 00258 { 00259 u8 adu[ MB_ASCII_ADU_MAX_LENGTH], pdu[ MAX_BUFFER_SIZE]; 00260 int pdu_len= 0, adu_len= 0, ret= 0; 00261 u8 ret_no; 00262 00263 pdu_len= MBReadDecreteInputs( pdu, startdec, no); // make PDU 00264 mbap->Length= pdu_len+ 1; // plus 1 for address 00265 00266 adu_len= MBTCPSendAndWaitResponse( fd, adu, pdu, pdu_len, mbap); 00267 00268 if( adu_len < 0) 00269 return adu_len; 00270 00271 pdu_len= MBTCPGetPDU( pdu, adu, adu_len); 00272 ret= MBGetResponseReadDecreteInputs( pdu, &ret_no, value); 00273 if( ret < 0) 00274 return ret; 00275 return ret_no; 00276 }
Here is the call graph for this function: ![]() |
|
send Read FIFO Queue request and get response(0x18)
Definition at line 599 of file mbtcp.c. References _MBAP_Struct::Length, MAX_BUFFER_SIZE, MB_ASCII_ADU_MAX_LENGTH, MB_OK, MBGetResponseReadFIFOQueue(), MBReadFIFOQueue(), MBTCPGetPDU(), and MBTCPSendAndWaitResponse(). 00600 { 00601 u8 adu[ MB_ASCII_ADU_MAX_LENGTH], pdu[ MAX_BUFFER_SIZE]; 00602 int pdu_len= 0, adu_len= 0, ret= 0; 00603 00604 pdu_len= MBReadFIFOQueue( pdu, FIFOAddr); // make PDU 00605 mbap->Length= pdu_len+ 1; // plus 1 for address 00606 00607 adu_len= MBTCPSendAndWaitResponse( fd, adu, pdu, pdu_len, mbap); 00608 00609 if( adu_len < 0) 00610 return adu_len; 00611 00612 pdu_len= MBTCPGetPDU( pdu, adu, adu_len); 00613 ret= MBGetResponseReadFIFOQueue( pdu, FIFOCount, FIFOValue); 00614 00615 if( ret < 0) 00616 return ret; 00617 00618 return MB_OK; 00619 }
Here is the call graph for this function: ![]() |
|
send Read Holding Registers request and get response(0x03)
Definition at line 425 of file mbtcp.c. References _MBAP_Struct::Length, MAX_BUFFER_SIZE, MB_ASCII_ADU_MAX_LENGTH, MBGetResponseReadHoldingRegisters(), MBReadHoldingRegisters(), MBTCPGetPDU(), and MBTCPSendAndWaitResponse(). 00426 { 00427 u8 adu[ MB_ASCII_ADU_MAX_LENGTH], pdu[ MAX_BUFFER_SIZE]; 00428 int pdu_len= 0, adu_len= 0, ret= 0; 00429 u8 ret_no; 00430 00431 pdu_len= MBReadHoldingRegisters( pdu, startreg, no); // make PDU 00432 mbap->Length= pdu_len+ 1; // plus 1 for address 00433 00434 adu_len= MBTCPSendAndWaitResponse( fd, adu, pdu, pdu_len, mbap); 00435 00436 if( adu_len < 0) 00437 return adu_len; 00438 00439 pdu_len= MBTCPGetPDU( pdu, adu, adu_len); 00440 ret= MBGetResponseReadHoldingRegisters( pdu, &ret_no, value); 00441 if( ret < 0) 00442 return ret; 00443 return ret_no; 00444 }
Here is the call graph for this function: ![]() |
|
send Read Input Registers request and get response(0x04)
Definition at line 393 of file mbtcp.c. References _MBAP_Struct::Length, MAX_BUFFER_SIZE, MB_ASCII_ADU_MAX_LENGTH, MBGetResponseReadInputRegisters(), MBReadInputRegisters(), MBTCPGetPDU(), and MBTCPSendAndWaitResponse(). 00394 { 00395 u8 adu[ MB_ASCII_ADU_MAX_LENGTH], pdu[ MAX_BUFFER_SIZE]; 00396 int pdu_len= 0, adu_len= 0, ret= 0; 00397 u8 ret_no; 00398 00399 pdu_len= MBReadInputRegisters( pdu, startreg, no); // make PDU 00400 mbap->Length= pdu_len+ 1; // plus 1 for address 00401 00402 adu_len= MBTCPSendAndWaitResponse( fd, adu, pdu, pdu_len, mbap); 00403 00404 if( adu_len < 0) 00405 return adu_len; 00406 00407 pdu_len= MBTCPGetPDU( pdu, adu, adu_len); 00408 ret= MBGetResponseReadInputRegisters( pdu, &ret_no, value); 00409 if( ret < 0) 00410 return ret; 00411 return ret_no; 00412 }
Here is the call graph for this function: ![]() |
|
send Read Write Multiple Registers request and get response(0x17)
Definition at line 529 of file mbtcp.c. References _MBAP_Struct::Length, MAX_BUFFER_SIZE, MB_ASCII_ADU_MAX_LENGTH, MB_ERROR_EXECPTION, MB_OK, MBGetResponseReadWriteMultipleRegisters(), MBReadWriteMultipleRegisters(), MBTCPGetPDU(), and MBTCPSendAndWaitResponse(). 00530 { 00531 u8 adu[ MB_ASCII_ADU_MAX_LENGTH], pdu[ MAX_BUFFER_SIZE]; 00532 int pdu_len= 0, adu_len= 0, ret= 0; 00533 u8 ret_no; 00534 00535 pdu_len= MBReadWriteMultipleRegisters( pdu, rsreg, rno, wsreg, wno, count, wv); 00536 mbap->Length= pdu_len+ 1; // plus 1 for address // make PDU 00537 00538 adu_len= MBTCPSendAndWaitResponse( fd, adu, pdu, pdu_len, mbap); 00539 00540 if( adu_len < 0) 00541 return adu_len; 00542 00543 pdu_len= MBTCPGetPDU( pdu, adu, adu_len); 00544 ret= MBGetResponseReadWriteMultipleRegisters( pdu, (u8 *)&ret_no, wv); 00545 00546 if( ret < 0) 00547 return ret; 00548 if( ret_no != rno*2) 00549 return MB_ERROR_EXECPTION; 00550 return MB_OK; 00551 }
Here is the call graph for this function: ![]() |
|
send adu packet through TCP socket and wait response adu from slave
Definition at line 224 of file mbtcp.c. References MB_ERROR_EXECPTION, MB_RTU_ADU_MAX_LENGTH, MBTCPBlockRead(), MBTCPGetMBAP(), MBTCPWrite(), and _MBAP_Struct::TransactionIdentifier. Referenced by MBTCPMaskwWriteRegister(), MBTCPReadCoils(), MBTCPReadDecreteInputs(), MBTCPReadFIFOQueue(), MBTCPReadHoldingRegisters(), MBTCPReadInputRegisters(), MBTCPReadWriteMultipleRegisters(), MBTCPWriteMultipleCoils(), MBTCPWriteMultipleRegisters(), MBTCPWriteSingleCoil(), MBTCPWriteSingleRegister(), and serial_master_child(). 00225 { 00226 int ret_len= 0; 00227 int tid= 0; 00228 pMBAPStruct ret_mbap= (pMBAPStruct)malloc(sizeof(MBAPStruct)); 00229 00230 tid= mbap->TransactionIdentifier; 00231 MBTCPWrite( fd, pdu, len, mbap); 00232 00233 ret_len= MBTCPBlockRead( fd, buf, MB_RTU_ADU_MAX_LENGTH); 00234 00235 MBTCPGetMBAP( buf, ret_mbap); 00236 00237 // TODO: reply for another transaction, drop it now, but may correct one day 00238 if( ret_mbap->TransactionIdentifier != tid) 00239 return MB_ERROR_EXECPTION; 00240 00241 return ret_len; 00242 }
Here is the call graph for this function: ![]() |
|
send Read Coils response(0x01)
Definition at line 658 of file mbtcp.c. References _MBAP_Struct::Length, MAX_BUFFER_SIZE, MB_OK, MBResponseReadCoils(), and MBTCPWrite(). 00659 { 00660 u8 pdu[ MAX_BUFFER_SIZE]; 00661 int pdu_len= 0, adu_len= 0; 00662 00663 pdu_len= MBResponseReadCoils( pdu, no, value); // make PDU 00664 mbap->Length= pdu_len+ 1; // plus 1 for address 00665 00666 adu_len= MBTCPWrite( fd, pdu, pdu_len, mbap); 00667 00668 if( adu_len < 0) 00669 return adu_len; 00670 00671 return MB_OK; 00672 }
Here is the call graph for this function: ![]() |
|
Modbus over TCP/IP slave function.
Definition at line 632 of file mbtcp.c. References _MBAP_Struct::Length, MAX_BUFFER_SIZE, MB_OK, MBResponseReadDecreteInputs(), and MBTCPWrite(). 00633 { 00634 u8 pdu[ MAX_BUFFER_SIZE]; 00635 int pdu_len= 0, adu_len= 0; 00636 00637 pdu_len= MBResponseReadDecreteInputs( pdu, no, value); // make PDU 00638 mbap->Length= pdu_len+ 1; // plus 1 for address 00639 00640 adu_len= MBTCPWrite( fd, pdu, pdu_len, mbap); 00641 00642 if( adu_len < 0) 00643 return adu_len; 00644 00645 return MB_OK; 00646 }
Here is the call graph for this function: ![]() |
|
send Read FIFO Queue response(0x18)
Definition at line 817 of file mbtcp.c. References _MBAP_Struct::Length, MAX_BUFFER_SIZE, MB_OK, MBResponseReadFIFOQueue(), and MBTCPWrite(). 00818 { 00819 u8 pdu[ MAX_BUFFER_SIZE]; 00820 int pdu_len= 0, adu_len= 0; 00821 00822 pdu_len= MBResponseReadFIFOQueue( pdu, no, count, value); // make PDU 00823 mbap->Length= pdu_len+ 1; // plus 1 for address 00824 00825 adu_len= MBTCPWrite( fd, pdu, pdu_len, mbap); 00826 00827 if( adu_len < 0) 00828 return adu_len; 00829 00830 return MB_OK; 00831 }
Here is the call graph for this function: ![]() |
|
send Read Holding Registers response(0x03)
Definition at line 710 of file mbtcp.c. References _MBAP_Struct::Length, MAX_BUFFER_SIZE, MB_OK, MBResponseReadHoldingRegisters(), and MBTCPWrite(). 00711 { 00712 u8 pdu[ MAX_BUFFER_SIZE]; 00713 int pdu_len= 0, adu_len= 0; 00714 00715 pdu_len= MBResponseReadHoldingRegisters( pdu, no, value); // make PDU 00716 mbap->Length= pdu_len+ 1; // plus 1 for address 00717 00718 adu_len= MBTCPWrite( fd, pdu, pdu_len, mbap); 00719 00720 if( adu_len < 0) 00721 return adu_len; 00722 00723 return MB_OK; 00724 }
Here is the call graph for this function: ![]() |
|
send Read Input Registers response(0x04)
Definition at line 684 of file mbtcp.c. References _MBAP_Struct::Length, MAX_BUFFER_SIZE, MB_OK, MBResponseReadInputRegisters(), and MBTCPWrite(). 00685 { 00686 u8 pdu[ MAX_BUFFER_SIZE]; 00687 int pdu_len= 0, adu_len= 0; 00688 00689 pdu_len= MBResponseReadInputRegisters( pdu, no, value); // make PDU 00690 mbap->Length= pdu_len+ 1; // plus 1 for address 00691 00692 adu_len= MBTCPWrite( fd, pdu, pdu_len, mbap); 00693 00694 if( adu_len < 0) 00695 return adu_len; 00696 00697 return MB_OK; 00698 }
Here is the call graph for this function: ![]() |
|
send Write Multiple Registers response(0x10)
Definition at line 738 of file mbtcp.c. References _MBAP_Struct::Length, MAX_BUFFER_SIZE, MB_OK, MBResponseWriteMultipleRegisters(), and MBTCPWrite(). 00739 { 00740 u8 pdu[ MAX_BUFFER_SIZE]; 00741 int pdu_len= 0, adu_len= 0; 00742 00743 pdu_len= MBResponseWriteMultipleRegisters( pdu, startdevreg, noreg); // make PDU 00744 mbap->Length= pdu_len+ 1; // plus 1 for address 00745 00746 adu_len= MBTCPWrite( fd, pdu, pdu_len, mbap); 00747 00748 if( adu_len < 0) 00749 return adu_len; 00750 00751 return MB_OK; 00752 }
Here is the call graph for this function: ![]() |
|
send Write Single Coil response(0x05)
Definition at line 764 of file mbtcp.c. References _MBAP_Struct::Length, MAX_BUFFER_SIZE, MB_OK, MBResponseWriteSingleCoil(), and MBTCPWrite(). 00765 { 00766 u8 pdu[ MAX_BUFFER_SIZE]; 00767 int pdu_len= 0, adu_len= 0; 00768 00769 pdu_len= MBResponseWriteSingleCoil( pdu, coilreg, onoff); // make PDU 00770 mbap->Length= pdu_len+ 1; // plus 1 for address 00771 00772 adu_len= MBTCPWrite( fd, pdu, pdu_len, mbap); 00773 00774 if( adu_len < 0) 00775 return adu_len; 00776 00777 return MB_OK; 00778 }
Here is the call graph for this function: ![]() |
|
send Write Single Register response(0x06)
Definition at line 790 of file mbtcp.c. References _MBAP_Struct::Length, MAX_BUFFER_SIZE, MB_OK, MBResponseWriteSingleRegister(), and MBTCPWrite(). 00791 { 00792 u8 pdu[ MAX_BUFFER_SIZE]; 00793 int pdu_len= 0, adu_len= 0; 00794 00795 pdu_len= MBResponseWriteSingleRegister( pdu, reg, value); // make PDU 00796 mbap->Length= pdu_len+ 1; // plus 1 for address 00797 00798 adu_len= MBTCPWrite( fd, pdu, pdu_len, mbap); 00799 00800 if( adu_len < 0) 00801 return adu_len; 00802 00803 return MB_OK; 00804 }
Here is the call graph for this function: ![]() |
|
Definition at line 130 of file mbtcp.c.
|
|
Modbus over TCP/IP API.
Definition at line 31 of file mbtcp.c. References TCPServerInit(). Referenced by serial_slave(). 00032 { 00033 TCPServerInit( port, serverfd); 00034 }
Here is the call graph for this function: ![]() |
|
wait modbus master device connect
Definition at line 45 of file mbtcp.c. References MB_ERROR_TCP_NOT_CONNECTED, and TCPServerWaitConnection(). Referenced by serial_slave(). 00046 { 00047 *clientfd= TCPServerWaitConnection( serverfd, clientfd, client_addr); 00048 if( *clientfd < 0 ) 00049 return MB_ERROR_TCP_NOT_CONNECTED; 00050 00051 return *clientfd; 00052 }
Here is the call graph for this function: ![]() |
|
write to TCP socket
Definition at line 118 of file mbtcp.c. References MB_RTU_ADU_MAX_LENGTH, MBTCPWriteMBAP(), and TCPWrite(). Referenced by MBTCPSendAndWaitResponse(), MBTCPSendReadCoils(), MBTCPSendReadDecreteInputs(), MBTCPSendReadFIFOQueue(), MBTCPSendReadHoldingRegisters(), MBTCPSendReadInputRegisters(), MBTCPSendWriteMultipleRegisters(), MBTCPSendWriteSingleCoil(), MBTCPSendWriteSingleRegister(), and serial_slave_child(). 00119 { 00120 u8 adu[ MB_RTU_ADU_MAX_LENGTH]; 00121 int adu_len= 0; 00122 00123 adu_len= MBTCPWriteMBAP( adu, mbap); 00124 bcopy( (const char *)pdu, (char *)(adu+ adu_len), len); 00125 adu_len+= len; 00126 00127 return TCPWrite( fd, adu, adu_len); 00128 }
Here is the call graph for this function: ![]() |
|
write MBAP struct to buffer
Definition at line 186 of file mbtcp.c. References _MBAP_Struct::Length, _MBAP_Struct::ProtocolIdentifier, PUTU16, _MBAP_Struct::TransactionIdentifier, and _MBAP_Struct::UnitIdentifier. Referenced by MBTCPWrite(). 00187 { 00188 PUTU16( buf, mbap->TransactionIdentifier); 00189 PUTU16( buf+ 2, mbap->ProtocolIdentifier); 00190 PUTU16( buf+ 4, mbap->Length); 00191 buf[ 6]= mbap->UnitIdentifier; 00192 00193 return 7; // MBAP length 00194 }
|
|
send Write Multiple Coils request and get response(0x0F)
Definition at line 354 of file mbtcp.c. References _MBAP_Struct::Length, MAX_BUFFER_SIZE, MB_ASCII_ADU_MAX_LENGTH, MB_ERROR_EXECPTION, MB_OK, MBGetResponseWriteMultipleCoils(), MBTCPGetPDU(), MBTCPSendAndWaitResponse(), and MBWriteMultipleCoils(). 00355 { 00356 u8 adu[ MB_ASCII_ADU_MAX_LENGTH], pdu[ MAX_BUFFER_SIZE]; 00357 int pdu_len= 0, adu_len= 0, ret= 0; 00358 u16 count; 00359 u16 ret_addr, ret_value; 00360 00361 count= (u8)no/8; 00362 if( count*8 < no) 00363 count++; 00364 00365 pdu_len= MBWriteMultipleCoils( pdu, startcoils, no, count, value); // make PDU 00366 mbap->Length= pdu_len+ 1; // plus 1 for address 00367 00368 adu_len= MBTCPSendAndWaitResponse( fd, adu, pdu, pdu_len, mbap); 00369 00370 if( adu_len < 0) 00371 return adu_len; 00372 00373 pdu_len= MBTCPGetPDU( pdu, adu, adu_len); 00374 ret= MBGetResponseWriteMultipleCoils( pdu, &ret_addr, &ret_value); 00375 if( ret < 0) 00376 return ret; 00377 if( ( ret_addr != startcoils) || ( ret_value != no)) 00378 return MB_ERROR_EXECPTION; 00379 return MB_OK; 00380 }
Here is the call graph for this function: ![]() |
|
send Write Multiple Registers request and get response(0x10)
Definition at line 491 of file mbtcp.c. References _MBAP_Struct::Length, MAX_BUFFER_SIZE, MB_ASCII_ADU_MAX_LENGTH, MB_ERROR_EXECPTION, MB_OK, MBGetResponseWriteMultipleRegisters(), MBTCPGetPDU(), MBTCPSendAndWaitResponse(), and MBWriteMultipleRegisters(). 00492 { 00493 u8 adu[ MB_ASCII_ADU_MAX_LENGTH], pdu[ MAX_BUFFER_SIZE]; 00494 int pdu_len= 0, adu_len= 0, ret= 0; 00495 u16 ret_addr, ret_value; 00496 00497 pdu_len= MBWriteMultipleRegisters( pdu, startreg, noreg, count, value); 00498 mbap->Length= pdu_len+ 1; // plus 1 for address // make PDU 00499 00500 adu_len= MBTCPSendAndWaitResponse( fd, adu, pdu, pdu_len, mbap); 00501 00502 if( adu_len < 0) 00503 return adu_len; 00504 00505 pdu_len= MBTCPGetPDU( pdu, adu, adu_len); 00506 ret= MBGetResponseWriteMultipleRegisters( pdu, &ret_addr, &ret_value); 00507 if( ret < 0) 00508 return ret; 00509 if( ( ret_addr != startreg) || ( ret_value != noreg)) 00510 return MB_ERROR_EXECPTION; 00511 return MB_OK; 00512 }
Here is the call graph for this function: ![]() |
|
send Write Single Coil request and get response(0x05)
Definition at line 320 of file mbtcp.c. References _MBAP_Struct::Length, MAX_BUFFER_SIZE, MB_ASCII_ADU_MAX_LENGTH, MB_ERROR_EXECPTION, MB_OK, MBGetResponseWriteSingleCoil(), MBTCPGetPDU(), MBTCPSendAndWaitResponse(), and MBWriteSingleCoil(). 00321 { 00322 u8 adu[ MB_ASCII_ADU_MAX_LENGTH], pdu[ MAX_BUFFER_SIZE]; 00323 int pdu_len= 0, adu_len= 0, ret= 0; 00324 u16 ret_addr, ret_value; 00325 00326 pdu_len= MBWriteSingleCoil( pdu, coilreg, onoff); // make PDU 00327 mbap->Length= pdu_len+ 1; // plus 1 for address 00328 00329 adu_len= MBTCPSendAndWaitResponse( fd, adu, pdu, pdu_len, mbap); 00330 00331 if( adu_len < 0) 00332 return adu_len; 00333 00334 pdu_len= MBTCPGetPDU( pdu, adu, adu_len); 00335 ret= MBGetResponseWriteSingleCoil( pdu, &ret_addr, &ret_value); 00336 if( ret < 0) 00337 return ret; 00338 if( ( ret_addr != coilreg) || ( ret_value != onoff)) 00339 return MB_ERROR_EXECPTION; 00340 return MB_OK; 00341 }
Here is the call graph for this function: ![]() |
|
send Write Single Register request and get response(0x06)
Definition at line 456 of file mbtcp.c. References _MBAP_Struct::Length, MAX_BUFFER_SIZE, MB_ASCII_ADU_MAX_LENGTH, MB_ERROR_EXECPTION, MB_OK, MBGetResponseWriteSingleRegister(), MBTCPGetPDU(), MBTCPSendAndWaitResponse(), and MBWriteSingleRegister(). 00457 { 00458 u8 adu[ MB_ASCII_ADU_MAX_LENGTH], pdu[ MAX_BUFFER_SIZE]; 00459 int pdu_len= 0, adu_len= 0, ret= 0; 00460 u16 ret_addr, ret_value; 00461 00462 pdu_len= MBWriteSingleRegister( pdu, devicereg, value); // make PDU 00463 mbap->Length= pdu_len+ 1; // plus 1 for address 00464 00465 adu_len= MBTCPSendAndWaitResponse( fd, adu, pdu, pdu_len, mbap); 00466 00467 if( adu_len < 0) 00468 return adu_len; 00469 00470 pdu_len= MBTCPGetPDU( pdu, adu, adu_len); 00471 ret= MBGetResponseWriteSingleRegister( pdu, &ret_addr, &ret_value); 00472 if( ret < 0) 00473 return ret; 00474 if( ( ret_addr != devicereg) || ( ret_value != value)) 00475 return MB_ERROR_EXECPTION; 00476 return MB_OK; 00477 }
Here is the call graph for this function: ![]() |