Sending/Receiving Data with SysLibCom Protocol

The following example shows how data is sent/received with the protocol “SysLibCom”.

-> Telegrams of 32 bytes length are to be received and sent.

  1. Declaration part of the program PROGRAM proSysLibCom_Test:

    -

    VAR
    
      strComSettings     : COMSETTINGS;             (* Structure of COM settings *)
      dwHandle           : DWORD;
      byStep             : BYTE;                    (* Step chain *)
      dwRead             : DWORD;                   (* Number of characters received *)
      dwWritten          : DWORD;                   (* Number of characters sent *)
      bEnSend            : BOOL;                    (* Enable sending *)
      byCom              : BYTE := COM2;            (* COM number *)
      dwBaudrate         : DWORD := 19200;          (* Baudrate *)
      wLenRec            : WORD := 32;              (* Number of characters to be received *)
      wLenTele           : WORD := 32;              (* Telegram length, here 32 characters for example *)
      wLenSend           : WORD := 32;              (* Number of characters to be sent, for example 32 characters *)
      dwTimeoutSend      : DWORD := 0;              (* Timeout in [ms] for sending *)
      dwTimeoutRec       : DWORD := 0;              (* Timeout in [ms] for receiving *)
      abyRecBuffer       : ARRAY[0..271] OF BYTE;   (* Receive buffer, 272 bytes min.! *)
      abyTeleBuffer      : ARRAY[0..543] OF BYTE;   (* Telegram buffer, 2 x receive buffer min. *)
      aby SendBuffer     : ARRAY[0..271] OF BYTE;   (* Send buffer, telegram length max.! *)
      strDataRec         : StrucReceiveData;        (* Structure of receive telegram *)
      strDataSend        : StrucSendData            (* Structure of send telegram *)
    
    END_VAR
    
  2. Code part of the program

    -> Processing of a step chain containing the following steps:

    -

    CASE byStep OF
    
    0:  (* Step 0: Open the interface COMx -> SysComOpen -> get handle *)
        strComSettings.Port := byCom;                                                        (* COM_Number *)
        dwHandle := SysComOpen(strComSettings.Port);                                         (* Open COM interface -> get handle *)
        byStep := SEL( dwHandle <> INVALID_HANDLE, 250, 1);                                  (* handle ok -> Step 1, otherwise error step 250 *)
    
    1:  (* Step 1: Transfer of COMx interface parameters *)
        strComSettings.dwBaudRate := dwBaudrate;                                             (* Set baudrate *)
        (* Enter at this point the number of stop bits and parity, if necessary *)
    
        (* set COM settings -> if OK, run step 2, in case of an error step 250 *)
        byStep := SEL( SysComSetSettings(dwHandle, ADR(strComSettings)), 250, 2);
    
    2:  (* Step 2: Initialization completed successfully -> now receiving and/or sending *)
    
        (* Receive data: read all data received since last run, but wLenRec max.! *)
        dwRead := SysComRead (dwHandle, ADR(abyRead),
                              WORD_TO_DWORD(wLenRec), dwTimeoutRec);                          (* READ DATA *)
        IF (dwRead > 0) THEN (* Number of characters received; in bytes *)
                             (* here, ignore for example all characters until valid telegram start detected *)
    
                             (* Number of receiving cycles for the telegram *)
                             dwNumReadPerTele[byCom] := dwNumReadPerTele[byCom] + 1;
                             (* Copy data to buffer *)
                             SysMemCpy      (dwDest := ADR(abySumDataRead[dwSum]DataRead]),
                                            dwSrc := ADR(abyRead[0]),
                                            dwCount := dwRead );
                             (* Sum of read data of a telegram *)
                             dwSumDataRead := dwSumDataRead + dwRead;
                             IF dwSumDataRead >= wLenTele THEN                                 (* Telegram complete ? *)
                                            dwRecCount := dwRecCount +1;                       (* Number of telegrams received *)
                                            (* Copy received telegram to structure strDataRec *)
                                            SysMemCpy( dwDest := ADR(strDataRec,
                                                       dw Src := ADR(abySumDataRead[0]),
                                                       dwCount := wLenTele );
                                            dwNumReadPerTele := 0;                             (* init for following telegram *)
                                            dwSumDataRead := 0;
    
                                           (* here the evaluation of data starts !!! *)
    
                             END_IF;                                                           (* Telegram complete *)
        END_IF;                                                                                (* Data received *)
    
       (* Send data *)
       (* Enabling the sending of data can be done, for example, cyclical or by program control *)
       IF bEnSend THEN                                                                         (* Enable sending *)
                                           (* Copy data to be sent to send buffer *)
                                           SysMemCpy (dwDest := ADR(abyDataSend[0]),
                                                       dwSrc := ADR(strDataSend),
                                                     dwCount := wLenSend);
    
    
    
                                           (* Send data *)
                                           dwWritten := SysComWrite( dwHandle,
                                                                   ADR(abyDataSend[0]),
                                                                   WORD_TO_DWORD(wLenSend),
                                                                   dwTimeoutSend);               SEND DATA !!! *)
                                           IF (dwWritten <> wLenSend THEN
                                                         byStep := 250;                         (* Error when sending *)
    ´                                      END_IF;                                              (* dwWritten *)
                                           bEnSend := FALSE;                                    (* Deactivate enable sending *)
                             END_IF;                                                            (* bEnSend *)
    
    250:  (* Step 250: Error step -> Close COMx and start with step 0 *)
          bResult  := SysComClose(dwHandle);                                                    (* Close COM interface *)
          dwHandle := 0;
            byStep := 0;
    
    END_CASE;                                                                                   (* End of step chain *)