unit UDP_Modbus;
{******************************************************************************}
{*  Stellt Funktionen zum Senden und Empfangen von ModBus über UDP bereit.    *}
{******************************************************************************}
interface

uses windows, ExtCtrls, classes, Dialogs, SysUtils, WinSock, MMSystem; //ScktComp; //NMUDP;

CONST
TimerCycle  = 20;   // Zykluszeit in mSec für Read-Timer
ModBus_Port = 502;  // MODBUS Port-Nr.

MAX_F3_REG  = 500;  // Read Multiple:   Standard ModBus: max.125 Register
MAX_F16_REG = 500;  // Write Multiple:  Standard ModBus: max.123 Register


TYPE

TBYTE_2000 = PACKED ARRAY [1..2000] OF CHAR; // für Senden und Empfangen
TREG_700   = PACKED ARRAY [1..700]  OF WORD; // für Senden und Empfangen
TREG_512   = PACKED ARRAY [0..512]  OF WORD; // für Senden und Empfangen

TErrCallBack   = procedure(tr_id  :WORD; errCode:Byte);                 //..callback für Fehler_Antworten
TWriteCallBack = procedure(tr_id  :WORD; adr:WORD; va:WORD);            //..callback für Schreib_Antworten
TReadCallBack  = procedure(tr_id  :WORD; anz:WORD; var werte:TREG_700); //..callback für Lese_Antwort


TMOD_Header = PACKED RECORD  // ModBus Header
  tid :WORD;   // Transaction-Identifier
  pid :WORD;   // Programm-Identifier immer=0 (ungenutzt)
  len :WORD;   // Anzahl folgender Modbus Daten-byte
  uid :BYTE;   // Unit-Identifier ..immer=$FF
  fc  :BYTE;   // Function Code ..03..06..16
END;


TF3_SendData = PACKED RECORD // F3 = Read-Request (multiple)
  head:TMOD_Header; // ModBus Header
  adr :WORD;        // StartReg. Lese-Adr.
  anz :WORD;        // Anzahl zu lesende Register
END;

TF6_SendData = PACKED RECORD // F6 = Write-Request(1 Word)
  head:TMOD_Header; // ModBus Header
  adr :WORD;        // Reg. Ziel-Adr.(schreiben)
  val :WORD;        // zu schreibender Wert
END;

TF16_SendData = PACKED RECORD // F16 = Write-Request(multiple)
  head:TMOD_Header; // ModBus Header
  adr :WORD;        // Reg. Ziel-Adr.(schreiben)
  anz :WORD;        // Anzahl zu schreibender Register
  anz2:BYTE;        // 2*Anzahl zu schreibender Register
  data:TREG_700;    // Array of 130 Register
END;


TTxBuffer = PACKED RECORD case Integer of
  0:(buf:TBYTE_2000);
  1:(F3: TF3_SendData);
  2:(F6: TF6_SendData);
  3:(F16:TF16_SendData);
END;


{-------------------- Rx Data (Empfangs-daten) --------------------------------}

TF3_AnswerData = PACKED RECORD // F3 = Read-Request(multiple) Answer
  head: TMOD_Header; // ModBus Header
  anz2: BYTE;        // 2*Anzahl zu lesender Register ..echo
  data: TREG_700;    // Array of Register , enthält die Antwortdaten
END;

TF6_AnswerData = PACKED RECORD // F6 = Write-(1 Word) Answer
  head: TMOD_Header; // ModBus Header
  adr : WORD;        // Reg. Ziel-Adr.(schreiben)  ..echo
  val : WORD;        // zu schreibender Wert  ..echo
END;

TF16_AnswerData = PACKED RECORD // F16 = Write-Request(multiple) Answer
  head: TMOD_Header; // ModBus Header
  adr : WORD;        // StartReg. Lese-Adr.  ..echo
  anz : WORD;        // Anzahl zu lesender Register ..echo
END;

TFxErr_AnswerData = PACKED RECORD // F3..F6..F16  Error-Answer
  head: TMOD_Header; // ModBus Header
  code: BYTE;        // Error-Code
END;

TRxBuffer = PACKED RECORD case Integer of
  0:(buf:TBYTE_2000);  // groß genug
  1:(F3: TF3_AnswerData);
  2:(F6: TF6_AnswerData);
  3:(F16:TF16_AnswerData);
  4:(err:TFxErr_AnswerData);
END;


TSwapWord = PACKED Record case integer OF
  1: (byte:PACKED ARRAY [1..2] OF BYTE);
  2: (word:WORD);
END;



TUDP_ModBus = class(TCOMPONENT)
  Timer    :TTimer;
private
  udpSock  :TSocket;
  destSockAddr :TSockAddrIn;  {dest IP-Addr}
  AddrLen  :Integer;
  TxBuffer:TTxBuffer; // Sendepuffer
  RxBuffer:TRxBuffer; // Empfangspuffer

  callback_error_F3 : TErrCallBack;
  callback_error_F6 : TErrCallBack;
  callback_error_F16: TErrCallBack;
  callback_answer_F3: TReadCallBack;
  callback_answer_F6: TWriteCallBack;
  callback_answer_F16:TWriteCallBack;

  procedure TimeOut(Sender: TObject);
  procedure ReadUdpData(); // mit Timer anstossen!
  procedure SetDestIp(destIP:string);

public
  //oldTime:integer; //..für Zeitmessung
  //newTime:integer;
  valid_ip :boolean;
  Constructor Create(destIP:string);
  function  Send_F3 (tr_id:WORD; RegAdr:WORD; anz :WORD):integer;
  procedure Send_F6 (tr_id:WORD; RegAdr:WORD; wert:WORD);
  function  Send_F16(tr_id:WORD; RegAdr:WORD; anz :WORD; var data:TREG_700):integer;

  procedure registerErrorCallback(call_F3,call_F6,call_F16:TErrCallBack);
  procedure registerWriteCallback(call_F6_answer,call_F16_answer:TWriteCallBack);
  procedure registerReadCallback(call_F3_answer:TReadCallBack);
end;//TUDP_Modbus


implementation { ------------------------------------------------------------- }

uses Modbus_Demo;  // nur für Testausgaben ..Meldung()

(*
procedure Meldung(msg:string);
begin{Meldung}
  ShowMessage(msg);
end;{Meldung}  *)


var  //globale daten
  data:WSAData;


Procedure HandleError(msg:string);
var
 errCode:integer;
 errCodeStr:string;
Begin
   errCode:=Windows.GetLastError;  // GetLastError nur EINMAL !! aufrufen
   errCodeStr:=intToStr(errCode);
   //ShowMessage(msg+': '+errCodeStr+'='+SysErrorMessage(errCode));
   Meldung(msg+': '+errCodeStr+'='+SysErrorMessage(errCode));
End;



procedure TUDP_Modbus.registerErrorCallback(call_F3,call_F6,call_F16 : TErrCallBack);
{*******************************************************************}
{* Registriert die Callback-Fkt. für ein Fehlerereignis            *}
{*******************************************************************}
begin{registerErrorCallback}
  callback_error_F3 := call_F3;
  callback_error_F6 := call_F6;
  callback_error_F16:= call_F16;
end;{registerErrorCallback}



procedure TUDP_Modbus.registerWriteCallback(call_F6_answer,call_F16_answer:TWriteCallBack);
{**********************************************************************}
{* Registriert die Callback-Fkt. für ein Schreib-Antworten            *}
{**********************************************************************}
begin{registerWriteCallback}
  callback_answer_F6 := call_F6_answer;
  callback_answer_F16:= call_F16_answer;
end;{registerWriteCallback}


procedure TUDP_Modbus.registerReadCallback(call_F3_answer :TReadCallBack);
{**********************************************************************}
{* Registriert die Callback-Fkt. für die Lese-Antwort                 *}
{**********************************************************************}
begin{registerWriteCallback}
  callback_answer_F3 := call_F3_answer;
end;{registerWriteCallback}



function SwapWord
  ( inVal: WORD)         {IN : zu wandelnder Wert        }
         : WORD;         {OUT: gedrehter Wert            }
{********************************************************}
{ Hi..lo byte tauschen Big/Little Endian                 }
{********************************************************}
VAR
  converter:TSwapWord;
  temp : BYTE;
begin {SwapCardinal}
  converter.word := inVal;   //laden
  temp := converter.byte[1];
  converter.byte[1] := converter.byte [2];
  converter.byte[2] := temp;
  SwapWord:=converter.word;
end;{SwapCardinal}



procedure TUDP_Modbus.Send_F6(tr_id:WORD; RegAdr:WORD; wert:WORD);  // write 1 Register
var rtc:integer;
begin{Send_F6}
  TxBuffer.F6.head.tid := SwapWord(tr_id); // Transaction Identifier
  TxBuffer.F6.head.pid := 0;           // Protocol Identifier
  TxBuffer.F6.head.len := SwapWord(6); // len(F6) := 6
  TxBuffer.F6.head.uid := $01;         // Unit Identifier; immer $FF
  TxBuffer.F6.head.fc  := 6;           // Function-Code = 06
  TxBuffer.F6.adr := SwapWord(RegAdr); // Ziel-Reg. Adr.
  TxBuffer.F6.val := SwapWord(wert);   // Ziel-Reg. Adr.

  Meldung('Send F6');

  If (WinSock.SendTo(udpSock,TxBuffer.buf,12,0,destSockAddr,AddrLen)=SOCKET_ERROR) then HandleError('Error: Send_F6..');
  Timer.Enabled :=true;  //nach dem Senden darf auch empfangen werden

end;{Send_F6}


function TUDP_Modbus.Send_F3(tr_id:WORD; RegAdr:WORD; anz:WORD):integer;  // read multiple Register
var i:integer;
    s:string;
begin{Send_F3}
  Result:=0; //default ohne Fehler
  if (anz>MAX_F3_REG)then begin Result:=1; exit; end; //Fehler
  TxBuffer.F3.head.tid := SwapWord(tr_id); // Transaction Identifier
  TxBuffer.F3.head.pid := 0;           // Protocol Identifier
  TxBuffer.F3.head.len := SwapWord(6); // len(F6) := 6
  TxBuffer.F3.head.uid := $01;         // Unit Identifier; immer $FF  ??
  TxBuffer.F3.head.fc  := 3;           // Function-Code = 03
  TxBuffer.F3.adr := SwapWord(RegAdr); // Ziel-Reg. Adr.
  TxBuffer.F3.anz := SwapWord(anz);    // Ziel-Reg. Adr.

  s:='';
  for i:=1 to 12 do s:=s+'  '+IntToHex(ORD(TxBuffer.buf[i]),2);
  Meldung('Send F3: '+s);

  If (WinSock.SendTo(udpSock,TxBuffer.buf,12,0,destSockAddr,AddrLen)=SOCKET_ERROR) then HandleError('Error: Send_F3..');
  Timer.Enabled :=true;  //nach dem Senden darf auch empfangen werden

end;{Send_F3}


function TUDP_Modbus.Send_F16(tr_id:WORD; RegAdr:WORD; anz :WORD; var data:TREG_700):integer;  // write multiple Register
var i,rtc:integer;
begin{Send_F16}
  Result:=0; //default ohne Fehler
  if (anz>MAX_F16_REG)then begin Result:=1; exit; end; //Fehler
  TxBuffer.F16.head.tid := SwapWord(tr_id); // Transaction Identifier
  TxBuffer.F16.head.pid := 0;               // Protocol Identifier
  TxBuffer.F16.head.len := SwapWord(2*anz+7); // len(F16) := 7 + 2*Anzahl
  TxBuffer.F16.head.uid := $01;         // Unit Identifier; immer $FF ??
  TxBuffer.F16.head.fc  := 16;          // Function-Code = 16
  TxBuffer.F16.adr := SwapWord(RegAdr); // Ziel-Reg. Adr.
  TxBuffer.F16.anz := SwapWord(anz);    // Ziel-Reg. Anzahl.
  if (anz>123) then TxBuffer.F16.anz2:=0 else TxBuffer.F16.anz2:= 2*anz; // 2 * Ziel-Reg. Anzahl. (=0 wenn kein Standard)
  for i:=1 to anz do TxBuffer.F16.data[i]:=SwapWord(data[i]); // Daten kopieren

  Meldung('Send F16');

  If (WinSock.SendTo(udpSock,TxBuffer.buf,13+2*anz,0,destSockAddr,AddrLen)=SOCKET_ERROR) then HandleError('Error: Send_F16..');
  Timer.Enabled :=true;  //nach dem Senden darf auch empfangen werden
end;{Send_F16}



procedure TUDP_Modbus.ReadUdpData();
{*****************************************************************}
{* ReadUdpData() muss (z.B. über Timer) angestoßen werdern.      *}
{* UDP_Daten Empfangen,  wenn anz=-1 dann ggf. falsche Port_Nr.  *}
{*****************************************************************}
var
  rest:integer; // Anzahl restlicher Daten im Empfangspuffer
  tid :WORD;    // Transaction Identifier
  fc  :BYTE;    // Function-Code
  len :INTEGER; // Anzahl empfangener Daten-Byte
  anzReg:INTEGER;
  i   :INTEGER;
  numberBytes:integer;
  s:string;
  errCode:integer;
  errCodeStr:string;
  AbsenderAdr :TSockAddrIn;
  AbsenderAdr_len :integer;
begin{TUDP_Modbus.ReadUdpData}

    //Meldung('ReadUdpData');

    if (udpSock=0) then exit;

    // Abfrage ob socket leer(IoctlSocket..) nicht mehr notwendig, da socket auf 'nonBlocking' gesetzt ist
    AbsenderAdr_len := sizeOf(AbsenderAdr);
    len:=WinSock.recvfrom(udpSock,RxBuffer,sizeOf(RxBuffer.buf),0,AbsenderAdr,AbsenderAdr_len); //alles lesen
    if (len=SOCKET_ERROR) Then begin
      errCode:=GetLastError;  // GetLastError nur EINMAL !! aufrufen
      if (errCode=WSAEWOULDBLOCK) then exit; // no data in socket
      errCodeStr:=intToStr(errCode);
      FehlerMeldung('..recvFrom: '+errCodeStr+'='+SysErrorMessage(errCode));
      //HandleError('..recvFrom..'); //..darf nicht, weil GetLastError nur EINMAL aufgerufen werden darf
      exit;
    end;

    Meldung('Received: anz='+intToStr(len));
    rest:=0;

    if len<9 then exit;  //Schrott entfernen

    tid := SwapWord(RxBuffer.F3.head.tid);
    fc  := RxBuffer.F3.head.fc;

    s:='';
    for i:=1 to len do s:=s+'  '+IntToHex(ORD(RxBuffer.buf[i]),2);
    Meldung('Empfangen_1: '+s);

    //Meldung('len='+intToStr(len));

    // callbacks auf<>0 abfragen, nicht mit exception.
    try // ..try, falls callback's nicht initialisiert sind
       case fc of
         $83:begin rest:=len-9;  if (rest=0) and (@callback_error_F3<>nil) then callback_error_F3 (tid,RxBuffer.err.code); end; // Fehlerantwort F3
         $86:begin rest:=len-9;  if (rest=0) and (@callback_error_F6<>nil) then callback_error_F6 (tid,RxBuffer.err.code); end; // Fehlerantwort F6
         $90:begin rest:=len-9;  if (rest=0) and (@callback_error_F16<>nil)then callback_error_F16(tid,RxBuffer.err.code); end; // Fehlerantwort F16
         06: begin rest:=len-12; if (rest=0) and (@callback_answer_F6<>nil) then callback_answer_F6 (tid,SwapWord(RxBuffer.F6.adr), SwapWord(RxBuffer.F6.val)); end; //F6-Antwort
         16: begin rest:=len-12; if (rest=0) and (@callback_answer_F16<>nil)then callback_answer_F16(tid,SwapWord(RxBuffer.F16.adr),SwapWord(RxBuffer.F16.anz));end; //F16-Antwort
         03: begin // Read multiple Antwort  F3
               //anzReg:= RxBuffer.F3.anz2 DIV 2;  ..altes Verfahren: anz<=125
               anzReg:= (SwapWord(RxBuffer.F3.head.len)-3) DIV 2;
               Meldung('anzReg='+IntToStr(anzReg));
               if (anzReg>MAX_F3_REG) then begin
                 FehlerMeldung('F3 Antwort mit mehr als '+IntToStr(MAX_F3_REG)+' Register..wird verworfen');
                 exit;
               end;
               rest :=len-9-2*anzReg;
               if (rest<>0) then begin
                 FehlerMeldung('F3 Antwort mit falscher länge,  rest='+IntToStr(rest));
                 exit; // weitere Fehlermeldung unterdrücken
               end else begin
                 for i:=1 to anzReg do RxBuffer.F3.data[i]:=SwapWord(RxBuffer.F3.data[i]);
                 if (@callback_answer_F3=nil) then begin FehlerMeldung('F3 antwort CallBack unInitialisiert !'); exit; end;
                 callback_answer_F3(tid,anzReg,RxBuffer.F3.data);
               end;
             end;//F3 Antwort
         else begin
            FehlerMeldung('Unbekannte UDP/Modbus Antwort, FC='+IntToStr(fc));
            exit;
         end;
       end;{case fc}
    except on E: Exception do FehlerMeldung('Receive Exception: CallBack unInitialisiert ? '+E.Message); end;//except

    if (rest<>0) then begin
      FehlerMeldung('AntwortDaten mit falscher Länge,  rest='+IntToStr(rest));
    end;

    //s:='';
    //for i:=1 to len do s:=s+'  '+IntToHex(ORD(RxBuffer.buf[i]),2);
    //Meldung('Empfangen_2: '+s);

end;{TUDP_Modbus.ReadUdpData}



procedure TUDP_Modbus.SetDestIp(destIP:string);
VAR data      :WSAData;
    RemoteHost:PHostEnt;
    iMode     :u_long;
    local_addr:TSockAddrIn; // für bind
begin{SetDestIp}

  Timer.Enabled :=false; // wird nach 1. Sendung wieder aktiviert

  CloseSocket(udpSock);
  udpSock :=0;

  udpSock := Socket(AF_Inet, SOCK_DGRAM, IPPROTO_UDP);
  If (udpSock=invalid_socket) then begin
     HandleError('invalid_socket create..');
     udpSock :=0;
     exit;
  end;

  // 'bind' ist nicht nötig, wenn zuerst gesendet und danach erst empfangen wird (..Client).
  // mit bind kann aber festgelegt werden, über welche eigene IP_adresse kommuniziert werden soll. (0.0.0.0)=alle eigenen IP's.
  local_addr.sin_family := AF_INET;
  local_addr.sin_Port := htons(ModBus_Port);
  local_addr.sin_Addr.S_Addr := inet_addr('0.0.0.0'); //0 = alle IP-Adressen dieses Rechners
  //if WinSock.Bind(udpSock, local_addr, sizeOf(local_addr)) = SOCKET_ERROR then HandleError('Bind error..');

  RemoteHost := WinSock.GetHostByName(PChar(destIP));
  if (RemoteHost<>nil) then begin
     FillChar(destSockAddr,SizeOf(destSockAddr),0); // sicher ist sicher
     destSockAddr.sin_addr.s_addr := Longint(PLongint(RemoteHost^.h_addr_list^)^);
     AddrLen := sizeof(destSockAddr); // wird global genutzt
     destSockAddr.sin_family := AF_Inet;
     destSockAddr.sin_port := htons(ModBus_Port); //502
     iMode:=1;  //<>0 => NonBlocking Mode
     WinSock.IoctlSocket(udpSock,FIONBIO,iMode); //set nonBlocking
     valid_ip :=true;
  end else begin
     HandleError('GetHostByName..');
     ShowMessage('Adresse von  "'+destIp+'"  nicht gefunden.');
     udpSock :=0;
     valid_ip :=false;
  end;

end;{SetDestIp}



Constructor TUDP_Modbus.Create({aOwner:TComponent; }destIP:string);
VAR data:WSAData;
begin{Create}
  //Meldung('TUDP_Modbus.Create');

  inherited create(Owner); //(aOwner);

  valid_ip :=false;
  udpSock:=0;

  callback_error_F3 :=nil;  //..noch uninitialisiert
  callback_error_F6 :=nil;
  callback_error_F16:=nil;
  callback_answer_F3:=nil;
  callback_answer_F6:=nil;
  callback_answer_F16:=nil;

  Timer:=TTimer.Create(Self);
  Timer.OnTimer :=TimeOut;
  Timer.Interval:=TimerCycle;
  Timer.Enabled :=false; // wird nach 1. Sendung aktiviert

  SetDestIp(destIP);

end;{Create}


procedure TUDP_Modbus.TimeOut(Sender: TObject); { ------------ TimeOut -------- }
begin{TimeOut}
  //Meldung('Event:TimeOut');

  ReadUdpData(); // Socket auslesen  ..alle 28..35mSec  bei 20mSec Timer-Zyklus

end;{TimeOut}



initialization{ ------- init unit -------------------------------------------- }
  timeBeginPeriod(1);  // ZeitGranularität = 1 mSec
  if WinSock.WSAStartup(MakeWord(1,1),data)=SOCKET_ERROR then HandleERROR('WSAStartup...'); //..braucht windows

finalization { -------- finit unit ------------------------------------------- }
  timeEndPeriod(1);   // ZeitGranularität wieder normalisieren
  WinSock.WSACleanup; //..für Windows sockets


end.{UDP_ModBus}
