54c410e8-1394-47d6-9b2d-09c1d6934ac4 Semaphore used for thread safe access Flag indicating this message is in use by a N4K_Call e7f93e9d-b72b-413c-aef0-be3d910df45b reply data bytes 8350c0ad-55b7-45bf-a02d-fad6d2ebc37e total reply length unique message ID success flag of the call padding to enforce header size to 16 bytes bd93192c-d0d9-46bd-bc2e-98490d717252 zero terminated function name followed by request data bytes 4da207f7-eb0a-4183-bbad-ba0c918d7cb8 total request length unique message ID number of request data bytes expected number of reply data bytes df547b05-5210-46d9-9a11-ea6293426b2f N4K_STATUS_TOO_MANY_ACTIVE Too many active N4K_Call function blocks N4K_STATUS_NOT_INITIALIZED The N4K_Communication function block is not (yet) initialized/operational. N4K_STATUS_INVALID_REPLY The format of the reply message is not as expected 48f61eb1-4d20-4090-bad9-d607efcc5aac Execute this function block Name of the Cm socket server function to run The function places the message on the request queue, within the specified timeout Cm socket server Index, for multiple subsystems in a network Address of input data buffer Size of input data buffer Address of output data buffer Size of output data buffer Client should call this function block as long as Active is TRUE Flag indicating the function timed out. Client must call this function block until the function results in Error or Done. Address of input data buffer Size of input data buffer Address of output data buffer Size of output data buffer index to the claimed message buffer index to the claimed request buffer String pointer to the buffer data pointer to buffer (* First check if the communication is initialized/operational *) IF Execute AND NOT bN4kInitialized_gb THEN IF NOT Error THEN fbN4kLogMsg_gb.AddMessage(Msg := 'ERROR: N4K Communication is not operational (any more)'); Error := TRUE; ErrorID := N4K_STATUS_NOT_INITIALIZED; Active := FALSE; uiMessageBufferIndex := uiMSG_BUFFER_INDEX_EMPTY; END_IF; RETURN; (* If the function block is active; continue processing until the reply is received. *) ELSIF Execute AND NOT Active AND NOT Done AND NOT Error THEN Active := TRUE; bLocalError := FALSE; enLocalErrorID := N4K_STATUS_NONE; uiMessageBufferIndex := uiMSG_BUFFER_INDEX_EMPTY; Timedout := FALSE; (* Check if the request data fits in the request buffer *) IF (LEN(FunctionName) + 1 + UINT_TO_INT(SizeIn)) > UINT_TO_INT(SIZEOF(arN4kRequestBuffers_gb[0].arData)) THEN fbN4kLogMsg_gb.AddMessage(Msg := CONCAT('Too much data; the request does not fit in the send buffer; ', FunctionName)); bLocalError := TRUE; enLocalErrorID := N4K_STATUS_INVALID_INPUT_DATA; RETURN; END_IF (* Check if the request data fits in the response buffer *) IF SizeOut > uiMAX_SOCKET_REPLY_DATA_SIZE THEN fbN4kLogMsg_gb.AddMessage(Msg := CONCAT('Too much data; the response will not fit in the response buffer; ', FunctionName)); bLocalError := TRUE; enLocalErrorID := N4K_STATUS_INVALID_INPUT_DATA; RETURN; END_IF (* Claim a free message ID *) bfound := FALSE; uiMessageBufferIndex := 0; WHILE (uiMessageBufferIndex <= 250) AND NOT bfound DO udiResult := SysSemTry(arN4kMessages_gb[uiMessageBufferIndex].pbySem); IF (NOT arN4kMessages_gb[uiMessageBufferIndex].bWaitForReply) AND (udiResult = CXA_SocketComm.CmpErrors.Errors.ERR_OK) THEN (*Don't stress the semaphore access*) arN4kMessages_gb[uiMessageBufferIndex].bWaitForReply := TRUE; SysSemLeave(arN4kMessages_gb[uiMessageBufferIndex].pbySem); bfound := TRUE; ELSE uiMessageBufferIndex := uiMessageBufferIndex + 1; END_IF END_WHILE IF NOT bfound THEN fbN4kLogMsg_gb.AddMessage(Msg := CONCAT('ERROR: No more free message IDs; ', FunctionName)); bLocalError := TRUE; enLocalErrorID := N4K_STATUS_OUT_OF_RESOURCES; uiMessageBufferIndex := uiMSG_BUFFER_INDEX_EMPTY; RETURN; END_IF (* Store the input data in local variables *) strFunctionName := FunctionName; pusiAddressIn := InputBuffer; uiSizeIn := SizeIn; pusiAddressOut := OutputBuffer; uiSizeOut := SizeOut; tonTimerReqBuf(IN := FALSE, PT := UINT_TO_TIME(Timeout)); iRequestBufferIndex := -1; ELSIF Active THEN IF bLocalError THEN Error := TRUE; ErrorID := enLocalErrorID; Active := FALSE; RETURN; END_IF tonTimerReqBuf(IN := TRUE); IF tonTimerReqBuf.Q THEN Timedout := TRUE; END_IF IF iRequestBufferIndex < 0 THEN (* No request send yet *) IF Timedout THEN fbN4kLogMsg_gb.AddMessage(Msg := CONCAT('ERROR: Failed to send the request within the specified timeout; ', FunctionName)); Error := TRUE; ErrorID := N4K_STATUS_TIMEOUT; Active := FALSE; RETURN; END_IF (* Claim a request buffer *) udiResult := SysSemTry(pbyN4kRequestBufferIndexSem_gb); IF udiResult = CXA_SocketComm.CmpErrors.Errors.ERR_OK THEN IF arN4kRequestBuffers_gb[usiN4kNextRequestBuffer_gb].stHeader.uiLength = 0 THEN iRequestBufferIndex := usiN4kNextRequestBuffer_gb; usiN4kNextRequestBuffer_gb := UINT_TO_USINT((usiN4kNextRequestBuffer_gb + 1) MOD uiN4kNumBuffers_gb); SysSemLeave(pbyN4kRequestBufferIndexSem_gb); ELSE SysSemLeave(pbyN4kRequestBufferIndexSem_gb); fbN4kLogMsg_gb.AddMessage(Msg := 'No more free request buffers'); Error := TRUE; ErrorID := N4K_STATUS_OUT_OF_RESOURCES; Active := FALSE; RETURN; END_IF ELSE (* Failed to claim a request buffer; try to claim the buffer the next PLC-cycle *) fbN4kLogMsg_gb.AddMessage(Msg := 'DBG: SEMAPHORE IN ACTION... Failed to claim pbyN4kRequestBufferIndexSem_gb'); RETURN; END_IF (* copy the request to the request buffer *) arN4kRequestBuffers_gb[iRequestBufferIndex].stHeader.uiMsgId := uiMessageBufferIndex; arN4kRequestBuffers_gb[iRequestBufferIndex].stHeader.uiSizeIn := uiSizeIn; arN4kRequestBuffers_gb[iRequestBufferIndex].stHeader.uiSizeOut := uiSizeOut; (* Copy function name *) pstrBuffer := ADR(arN4kRequestBuffers_gb[iRequestBufferIndex].arData); pstrBuffer^ := strFunctionName; (* Copy function name (incl. zero terminator) *) (* Copy input data to the sendBuffer directly after the function name *) uiLength := INT_TO_UINT(LEN(strFunctionName)) + 1; pusiBuffer := pstrBuffer + UINT_TO_DWORD(uiLength); uiLength := uiLength + uiSizeIn + SIZEOF(arN4kRequestBuffers_gb[iRequestBufferIndex].stHeader); WHILE uiSizeIn > 0 DO pusiBuffer^ := pusiAddressIn^; pusiBuffer := pusiBuffer + 1; pusiAddressIn := pusiAddressIn + 1; uiSizeIn := uiSizeIn - 1; END_WHILE (* Setting the uiLength field transfers ownership of the request buffer to the N4K_Communication program *) arN4kRequestBuffers_gb[iRequestBufferIndex].stHeader.uiLength := uiLength; ELSE (* Request is sent, wait for a reply *) IF NOT arN4kMessages_gb[uiMessageBufferIndex].bWaitForReply THEN (* N4K PLC software stack failure (serious bug) *) fbN4kLogMsg_gb.AddMessage(Msg := 'ERROR: A reply was requested for an inactive MsgId'); Error := TRUE; ErrorID := N4K_STATUS_ERROR; Active := FALSE; RETURN; END_IF IF arN4kMessages_gb[uiMessageBufferIndex].pstRecvBuffer <> 0 THEN (* reply received *) IF arN4kMessages_gb[uiMessageBufferIndex].pstRecvBuffer^.stHeader.uiMsgId <> uiMessageBufferIndex OR arN4kMessages_gb[uiMessageBufferIndex].pstRecvBuffer^.stHeader.usiStatus <= N4K_STATUS_PROCESSING THEN (* N4K PLC software stack failure (serious bug) *) fbN4kLogMsg_gb.AddMessage(Msg := 'ERROR: N4K PLC Software stack failure'); Error := TRUE; ErrorID := N4K_STATUS_ERROR; Active := FALSE; RETURN; END_IF IF arN4kMessages_gb[uiMessageBufferIndex].pstRecvBuffer^.stHeader.usiStatus = N4K_STATUS_READY THEN (* Function executed successfully *) uiLength := arN4kMessages_gb[uiMessageBufferIndex].pstRecvBuffer^.stHeader.uiLength - SIZEOF(arN4kMessages_gb[uiMessageBufferIndex].pstRecvBuffer^.stHeader); (* strip header from received data buffer *) IF uiLength = uiSizeOut THEN (* Copy the data from the receive buffer to OutputBuffer *) pusiBuffer := ADR(arN4kMessages_gb[uiMessageBufferIndex].pstRecvBuffer^.arData); WHILE (uiLength > 0) DO pusiAddressOut^ := pusiBuffer^; uiLength := uiLength - 1; pusiBuffer := pusiBuffer + 1; pusiAddressOut := pusiAddressOut + 1; END_WHILE Done := TRUE; ELSE fbN4kLogMsg_gb.AddMessage(Msg := CONCAT('ERROR: received wrong nr of bytes; ', FunctionName)); Error := TRUE; ErrorID := N4K_STATUS_INVALID_REPLY; END_IF ELSE (* The Cm socket server failed to properly execute the function *) fbN4kLogMsg_gb.AddMessage(Msg := CONCAT('ERROR: The Cm socket server failed to execute the function; ', FunctionName)); Error := TRUE; ErrorID := arN4kMessages_gb[uiMessageBufferIndex].pstRecvBuffer^.stHeader.usiStatus; END_IF Active := FALSE; (* Release the receive buffer *) arN4kMessages_gb[uiMessageBufferIndex].pstRecvBuffer^.stHeader.uiLength := 0; (* Mark the receive buffer as free buffer *) (* Release the Message ID *) arN4kMessages_gb[uiMessageBufferIndex].pstRecvBuffer := 0; arN4kMessages_gb[uiMessageBufferIndex].bWaitForReply := FALSE; (* Mark the msgId as free *) uiMessageBufferIndex := uiMSG_BUFFER_INDEX_EMPTY; END_IF END_IF (* Stop executing command. *) ELSIF NOT Execute AND (Done OR Error) THEN IF uiMessageBufferIndex <> uiMSG_BUFFER_INDEX_EMPTY THEN IF arN4kMessages_gb[uiMessageBufferIndex].pstRecvBuffer <> 0 THEN arN4kMessages_gb[uiMessageBufferIndex].pstRecvBuffer^.stHeader.uiLength := 0; (* Mark the receive buffer as free buffer *) arN4kMessages_gb[uiMessageBufferIndex].pstRecvBuffer := 0; END_IF arN4kMessages_gb[uiMessageBufferIndex].bWaitForReply := FALSE; (* Mark the msgId as free *) uiMessageBufferIndex := uiMSG_BUFFER_INDEX_EMPTY; END_IF Done := FALSE; Error := FALSE; END_IF 6158f4d9-4f32-4e01-b4e7-0b490de2015d IP Address of the Cm socket server Cm socket server port Max nr. of retries (30sec) to connect with the Cm socket server Index to the current receive buffer Number of bytes received in the current receive buffer Number of requests waiting for a reply Variables used by SysSockSelect Tmp variables Max nr of recv / send actions per PLC cycle Disable nagle algorithm, so use TCP_NODELAY FB which creates and closes either a server or client Flag for PLC and Cm socket server communication is alive CASE step nr. of retries Delay time before a retry will be executed Time On Delay for retry a connection Reset FB's Open an asynchronous connection to the Cm socket server Close the asychronous connection to the Cm socket server Count the amount of retries Asychronous connection to the Cm socket server was succesfull An error occurred (* Checks the communication with the Cm socket server, using async communication. States: | PLC | PC/Node | Cm socket server | Result | ----------------------------------------------------------------------------------------- | ON | OFF | OFF | AsyncConnect ERROR --> Retries --> Error | | ON | ON | OFF | AsyncConnect ERROR --> Retries --> Error | | ON | ON | ON | AsyncConnect OK | Notes: fbN4kLogMsg_gb.AddMessage only works when Cm socket server has started!!! *) CASE iStep OF STEP_INITIAL: fbIL_TCPConnectionAsync(Enable := FALSE); tonRetry(IN := FALSE); iStep := STEP_ASYNC_CONNECT; STEP_ASYNC_CONNECT: fbIL_TCPConnectionAsync(Enable := TRUE, Server := FALSE, Address := IpAddress, Port := TO_UINT(Port)); tonRetry(IN := TRUE, PT := tRetryDelay); IF fbIL_TCPConnectionAsync.Done THEN fbN4kLogMsg_gb.AddMessage(Msg := 'PLC --> Cm socket server asynchronous TCP connection established'); tonRetry(IN := FALSE); iStep := STEP_ASYNC_DISCONNECT; ELSIF tonRetry.Q THEN istep := STEP_RETRY; ELSIF fbIL_TCPConnectionAsync.Error THEN istep := STEP_ERROR; END_IF STEP_ASYNC_DISCONNECT: fbIL_TCPConnectionAsync(Enable := FALSE); fbN4kLogMsg_gb.AddMessage(Msg := 'PLC --> Cm socket server asynchronous TCP connection closed'); iStep := STEP_END; STEP_RETRY: iRetry := iRetry + 1; IF iRetry < RetryMax THEN istep := STEP_INITIAL; ELSE istep := STEP_ERROR; END_IF STEP_END: bCommAsyncOK := TRUE; STEP_ERROR: Error := TRUE; END_CASE 769c53a9-a8c9-4568-907b-854966aeb199 (*At start-up or after an error: First check PC communication with Asynchronous Function*) IF Enable AND NOT bCommAsyncOK AND NOT Error THEN CheckCommunication(); ELSIF Enable AND bCommAsyncOK AND NOT Error THEN IF NOT InOperation THEN (*Initialize the connection to Cm socket server*) IF NOT bN4kInitialized_gb THEN (*Initialize global N4k buffers just once*) (*Initialize buffer sizes*) uiN4kBufferSize_gb := SIZEOF(arN4kRequestBuffers_gb[0]); uiN4kNumBuffers_gb := DINT_TO_UINT(SIZEOF(arN4kRequestBuffers_gb) / uiN4kBufferSize_gb); (*Initialize buffers*) FOR uiIndex := 0 TO uiN4kNumbuffers_gb - 1 DO arN4kRequestBuffers_gb[uiIndex].stHeader.uiLength := 0; arReplyBuffers[uiIndex].stHeader.uiLength := 0; END_FOR pbyN4kRequestBufferIndexSem_gb := SysSemCreate(ADR(udiResult)); IF udiResult <> CXA_SocketComm.CmpErrors.Errors.ERR_OK THEN fbN4kLogMsg_gb.AddMessage(Msg := 'ERROR: SysSemCreate failed'); Error := TRUE; RETURN; END_IF (*Initialize msgIds*) FOR uiIndex := 0 TO 255 DO arN4kMessages_gb[uiIndex].pbySem := SysSemCreate(ADR(udiResult)); IF udiResult <> CXA_SocketComm.CmpErrors.Errors.ERR_OK THEN fbN4kLogMsg_gb.AddMessage(Msg := 'ERROR: SysSemCreate failed'); Error := TRUE; RETURN; END_IF arN4kMessages_gb[uiIndex].bWaitForReply := FALSE; arN4kMessages_gb[uiIndex].pstRecvBuffer := 0; END_FOR bN4kInitialized_gb := TRUE; END_IF (*Create Cm socket server socket address*) stAddress.sin_family := CXA_SocketComm.SysSocket.SysSocket_Interfaces.SOCKET_AF_INET; udiResult := CXA_SocketComm.SysSocket.SysSocket_Implementation.SysSockInetAddr(IpAddress, ADR(stAddress.sin_addr.ulAddr)); IF udiResult = CXA_SocketComm.CmpErrors.Errors.ERR_OK THEN IF Port >= 1024 THEN stAddress.sin_port := CXA_SocketComm.SysSocket.SysSocket_Implementation.SysSockHtons(DINT_TO_WORD(Port)); (*Create a socket*) pbySocket := CXA_SocketComm.SysSocket.SysSocket_Implementation.SysSockCreate(CXA_SocketComm.SysSocket.SysSocket_Interfaces.SOCKET_AF_INET, CXA_SocketComm.SysSocket.SysSocket_Interfaces.SOCKET_STREAM, 0, ADR(udiResult)); IF udiResult = CXA_SocketComm.CmpErrors.Errors.ERR_OK THEN (*Set TCP_NODELAY option*) udiResult := CXA_SocketComm.SysSocket.SysSocket_Implementation.SysSockSetOption(pbySocket, CXA_SocketComm.SysSocket.SysSocket_Interfaces.SOCKET_IPPROTO_TCP, CXA_SocketComm.SysSocket.SysSocket_Interfaces.SOCKET_TCP_NODELAY, ADR(diSockOptionNoDelay), SIZEOF(diSockOptionNoDelay)); IF udiResult = CXA_SocketComm.CmpErrors.Errors.ERR_OK THEN (*Connect to the Cm socket server*) udiResult := CXA_SocketComm.SysSocket.SysSocket_Implementation.SysSockConnect(pbySocket, ADR(stAddress), SIZEOF(stAddress)); IF udiResult = CXA_SocketComm.CmpErrors.Errors.ERR_OK THEN InOperation := TRUE; fbN4kLogMsg_gb.AddMessage(Msg := 'PLC --> Cm socket server synchronous TCP connection established.'); (* initialize variables for SysSockSelect *) stTvTimeout.tv_sec := 0; stTvTimeout.tv_usec := 0; (* initialize variables for receive buffer management *) uiExpectedInputLength := 0; uiInputSize := uiExpectedInputLength; uiRecvBufIndex := 0; ELSE fbN4kLogMsg_gb.AddMessage(Msg := 'ERROR: Failed to connect to Cm socket server'); Error := TRUE; END_IF ELSE fbN4kLogMsg_gb.AddMessage(Msg := 'ERROR: Failed to set socket option'); Error := TRUE; END_IF ELSE fbN4kLogMsg_gb.AddMessage(Msg := 'ERROR: Failed to create the TCP socket'); Error := TRUE; END_IF ELSE fbN4kLogMsg_gb.AddMessage(Msg := 'ERROR: Invalid port address; port number should be >= 1024'); Error := TRUE; END_IF ELSE fbN4kLogMsg_gb.AddMessage(Msg := 'ERROR: Invalid IP address'); Error := TRUE; END_IF ELSE (* Pump the message queues *) (* Receive pending data *) usiLoopCount := 2*usiMAX_NR_MSGS_PER_CYCLE; (* Try to recv usiMAX_NR_MSGS_PER_CYCLE messages (messages are received in 2 phases; header and data) *) WHILE usiLoopCount > 0 DO (* Check if there is data ready to receive *) stFdRead.fd_count := 1; stFdRead.fd_array[0] := pbySocket; udiResult := CXA_SocketComm.SysSocket.SysSocket_Implementation.SysSockSelect(diWidth := CXA_SocketComm.SysSocket.SysSocket_Interfaces.SOCKET_FD_SETSIZE, pfdRead := ADR(stFdRead), pfdWrite := 0, pfdExcept := 0, ptvTimeout := ADR(stTvTimeout), pdiReady := ADR(diReady)); IF udiResult = CXA_SocketComm.CmpErrors.Errors.ERR_OK THEN IF diReady > 0 THEN IF uiExpectedInputLength = uiInputSize THEN (* Previous message was completely received; claim a new receive buffer. *) uiIndex := uiRecvBufIndex; REPEAT (* Find an empty receive buffer. *) uiRecvBufIndex := (uiRecvBufIndex + 1) MOD uiN4kNumBuffers_gb; UNTIL (arReplyBuffers[uiRecvBufIndex].stHeader.uiLength = 0) OR (uiIndex = uiRecvBufIndex) END_REPEAT; IF uiIndex = uiRecvBufIndex THEN (* There are more than uiN4kNumBuffers_gb messages pending; do not send new requests. *) fbN4kLogMsg_gb.AddMessage(Msg := 'WARNING: No more free receive buffers'); RETURN; END_IF uiExpectedInputLength := SIZEOF(arReplyBuffers[uiRecvBufIndex].stHeader); uiInputSize := 0; END_IF (* Receive the data *) diSize := TO_DINT(CXA_SocketComm.SysSocket.SysSocket_Implementation.SysSockRecv(hSocket := pbySocket, pbyBuffer := ADR(arReplyBuffers[uiRecvBufIndex]) + uiInputSize, diBufferSize := uiExpectedInputLength - uiInputSize, diFlags := 0, ADR(udiResult))); IF udiResult <> CXA_SocketComm.CmpErrors.Errors.ERR_OK OR diSize = 0 THEN fbN4kLogMsg_gb.AddMessage(Msg := 'ERROR: The Cm socket server closed the connection'); Error := TRUE; RETURN; ELSE uiInputSize := uiInputSize + TO_UINT(diSize); IF uiInputSize >= SIZEOF(arReplyBuffers[uiRecvBufIndex].stHeader.uiLength) THEN uiExpectedInputLength := arReplyBuffers[uiRecvBufIndex].stHeader.uiLength; IF uiExpectedInputLength > SIZEOF(arReplyBuffers[uiRecvBufIndex]) THEN fbN4kLogMsg_gb.AddMessage(Msg := 'ERROR: The received reply does not fit in the reply buffer'); Error := TRUE; RETURN; ELSIF uiExpectedInputLength < SIZEOF(arReplyBuffers[uiRecvBufIndex].stHeader) THEN fbN4kLogMsg_gb.AddMessage(Msg := 'ERROR: The reply contains less data than the reply header.'); Error := TRUE; RETURN; END_IF IF uiInputSize = uiExpectedInputLength THEN (*Message is completely received*) IF arReplyBuffers[uiRecvBufIndex].stHeader.uiMsgId = usiALIVE_MSG THEN (*Special handling for this ALIVE message*) (*This is a dummy message that is used as a "pacemaker" for the socket communication*) arReplyBuffers[uiRecvBufIndex].stHeader.uiLength := 0; ELSIF arN4kMessages_gb[arReplyBuffers[uiRecvBufIndex].stHeader.uiMsgId].bWaitForReply THEN arN4kMessages_gb[arReplyBuffers[uiRecvBufIndex].stHeader.uiMsgId].pstRecvBuffer := ADR(arReplyBuffers[uiRecvBufIndex]); uiPendingMessages := uiPendingMessages - 1; ELSE fbN4kLogMsg_gb.AddMessage(Msg := 'ERROR: Received a message that was not expected'); Error := TRUE; RETURN; END_IF END_IF END_IF END_IF usiLoopCount := usiLoopCount - 1; ELSE usiLoopCount := 0; (* There is no data ready to receive; stop the loop *) END_IF ELSE usiLoopCount := 0; (* There is no data ready to receive; stop the loop *) END_IF END_WHILE (* Send pending requests *) usiLoopCount := usiMAX_NR_MSGS_PER_CYCLE; (* Try to send max usiMAX_NR_MSGS_PER_CYCLE messages *) WHILE usiLoopCount > 0 AND arN4kRequestBuffers_gb[uiSendIndex].stHeader.uiLength > 0 DO diSize := TO_DINT(CXA_SocketComm.SysSocket.SysSocket_Implementation.SysSockSend(hSocket := pbySocket, pbyBuffer := ADR(arN4kRequestBuffers_gb[uiSendIndex]), diBufferSize := arN4kRequestBuffers_gb[uiSendIndex].stHeader.uiLength, diFlags := 0, ADR(udiResult))); IF udiResult = CXA_SocketComm.CmpErrors.Errors.ERR_OK THEN IF diSize = arN4kRequestBuffers_gb[uiSendIndex].stHeader.uiLength THEN uiPendingMessages := uiPendingMessages + 1; arN4kRequestBuffers_gb[uiSendIndex].stHeader.uiLength := 0; (* mark send buffer ready for reuse *) uiSendIndex := (uiSendIndex + 1) MOD uiN4kNumBuffers_gb; ELSE fbN4kLogMsg_gb.AddMessage(Msg := 'ERROR: Could not send all required data'); Error := TRUE; RETURN; END_IF ELSE fbN4kLogMsg_gb.AddMessage(Msg := 'ERROR: SysSockSend failed'); Error := TRUE; RETURN; END_IF usiLoopCount := usiLoopCount - 1; END_WHILE END_IF ELSIF NOT Enable THEN Error := FALSE; END_IF IF Error OR NOT Enable THEN bCommAsyncOK := FALSE; iStep := STEP_INITIAL; iRetry := 0; InOperation := FALSE; IF bN4kInitialized_gb THEN bN4kInitialized_gb := FALSE; SysSemDelete(pbyN4kRequestBufferIndexSem_gb); FOR uiIndex := 0 TO 255 DO SysSemDelete(arN4kMessages_gb[uiIndex].pbySem); END_FOR END_IF IF pbySocket <> CXA_SocketComm.SysTypes.RTS_INVALID_HANDLE THEN CXA_SocketComm.SysSocket.SysSocket_Implementation.SysSockShutdown(hSocket := pbySocket, dihow := 2); CXA_SocketComm.SysSocket.SysSocket_Implementation.SysSockClose(hSocket := pbySocket); pbySocket := CXA_SocketComm.SysTypes.RTS_INVALID_HANDLE; END_IF END_IF 124db718-c04f-46bb-aec2-a5aaffc2281b IP Address of the Cm socket server Logging port 0: close UDP socket; 1: create UDP socket; 2: send data packages; 3: log buffer overflow detected; -1: socket creation failed; (* This method closes the UDP logging socket and clears the log buffers. This method is intended to automatically test logging functionality. Note: This could also be used to dynamically switch to another logging Cm socket server. *) Status := 0; usiIn := 0; usiOut := 0; f5a988eb-6c14-4dc1-b72e-d03e34233a0d (* Add a message to the internal log buffer. When there are no internal log buffers free: - The message will be rejected and - Status of N4K_Logger will be set to 3. *) IF ((usiIn + 1) MOD 20) <> usiOut THEN (* don't overwrite old log messages *) arMessages[usiIn].strBuffer := Msg; arMessages[usiIn].iSize := LEN(Msg); usiIn := (usiIn + 1) MOD 20; ELSIF Status = 2 THEN (* logbuffer overflow *) Status := 3; END_IF 6b21efde-46c6-485d-858a-5fdffdba2cef CASE Status OF 0: fbSocket(Enable := FALSE, Server := bServer, Address := IpAddress, Port := Port ); IF NOT fbSocket.InOperation THEN Status := 1; END_IF 1: fbSocket(Enable := TRUE, Server := bServer, Address := IpAddress, Port := Port ); IF fbSocket.InOperation THEN Status := 2; END_IF IF fbSocket.Error THEN Status := -1; END_IF 2..3: fbSendTo(Execute := (usiIn <> usiOut) AND NOT fbSendTo.Done, Socket := fbSocket.Socket, Address := IpAddress, Port := Port, ValueAdr := ADR(arMessages[usiOut].strBuffer), NoOfBytes := INT_TO_UDINT(arMessages[usiOut].iSize) ); IF fbSendTo.Done THEN usiOut := (usiOut + 1) MOD 20; Status := 2; (* Clear the overflow flag *) END_IF END_CASE ca02a5bf-b1b1-4091-aaeb-23b0744c921b Nr of requests that can be handled simultaneously nr of messages to process during 1 communication-cycle max length of a log string Keep this size the same as the define MAX_SOCKET_REQUEST_DATA_SIZE in the sw. Keep this size the same as the define MAX_SOCKET_REPLY_DATA_SIZE in the sw. Index to the next free send buffer := SIZEOF(arN4kRequestBuffers_gb[0]); := SIZEOF(arN4kRequestBuffers_gb) / uiN4kBufferSize_gb; 8f41a7cf-0864-49e5-8520-e084e32596a3 Nr of requests that can be handled simultaneously nr of messages to process during 1 communication-cycle max length of a log string Keep this size the same as the define MAX_SOCKET_REQUEST_DATA_SIZE in the sw. Keep this size the same as the define MAX_SOCKET_REPLY_DATA_SIZE in the sw. Index to the next free send buffer := SIZEOF(arN4kRequestBuffers_gb[0]); := SIZEOF(arN4kRequestBuffers_gb) / uiN4kBufferSize_gb;