unit Modbus_Demo;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls, ExtCtrls, UDP_ModBus, Grids;


(*  ------- Historie/Änderungen ----------------

 03.07.2013 Steuerung über Verbindungszustände entfernt.
 29.06.2013 von TCP nach UDP(WinApi) umstellen
 29.01.2012 Programm überarbeitet, Version 1.1
 xx.xx.2011 Pre-historisch

---------- Ende Historie/Änderungen ------------- *)


const
 VERSION  = 'V1.10';
 //LAST_REG = 4011;  // 0..511=EEPROM; 512..4011=RAM-Register
 LAST_REG = 32000;  // 0..511=EEPROM; 512..32000=RAM-Register
 DEFAULT_REG_OFFSET   = 1000;
 DEFAULT_END_REGISTER = 1200; //DEFAULT_REG_OFFSET + 300;   // 998 für Net-Gatewa
 COL_ANZ  = 10;    // Spaltenanzahl


type
  TModBusDemo = class(TForm)  // das Formular dieser Anwendung
    Memo1:   TMemo;
    Timer1:  TTimer;
    EXIT_Button: TButton;
    Memo2: TMemo;
    Read_cyclic_Panel: TPanel;
    Grid1: TStringGrid;
    ClrMemoPanel: TPanel;
    IP_Panel: TPanel;
    Read_once_Panel: TPanel;
    Panel7: TPanel;
    Panel8: TPanel;
    ClrGridPanel: TPanel;
    Label3: TLabel;
    Edit1: TEdit;
    Label4: TLabel;
    Edit2: TEdit;
    Label1: TLabel;
    Label2: TLabel;
    BitBox: TGroupBox;
    Bit15: TCheckBox;
    Bit14: TCheckBox;
    Bit13: TCheckBox;
    Bit12: TCheckBox;
    Bit11: TCheckBox;
    Bit10: TCheckBox;
    Bit9: TCheckBox;
    Bit8: TCheckBox;
    Bit7: TCheckBox;
    Bit6: TCheckBox;
    Bit5: TCheckBox;
    Bit4: TCheckBox;
    Bit3: TCheckBox;
    Bit2: TCheckBox;
    Bit1: TCheckBox;
    Bit0: TCheckBox;
    Update_Button: TButton;
    Edit3: TEdit;
    Label5: TLabel;
    Edit4: TEdit;
    Label6: TLabel;
    procedure FormCreate(Sender: TObject);
    procedure Timer1Timer(Sender: TObject);
    procedure Button6Click(Sender: TObject);
    procedure EXIT_ButtonClick(Sender: TObject);
    procedure Read_cyclic_PanelClick(Sender: TObject);
    procedure ClrMemoPanelClick(Sender: TObject);
    procedure IP_PanelClick(Sender: TObject);
    procedure Read_once_PanelClick(Sender: TObject);
    procedure Panel7Click(Sender: TObject);
    procedure Panel8Click(Sender: TObject);
    procedure ClrGridPanelClick(Sender: TObject);
    procedure Grid1KeyPress(Sender: TObject; var Key: Char);
    procedure Grid1MouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
    procedure Edit1KeyPress(Sender: TObject; var Key: Char);
    procedure Edit2KeyPress(Sender: TObject; var Key: Char);
    procedure Edit3KeyPress(Sender: TObject; var Key: Char);
    procedure Update_ButtonClick(Sender: TObject);
    procedure FormClick(Sender: TObject);
    procedure Edit4KeyPress(Sender: TObject; var Key: Char);

  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

TREG_GW   = PACKED ARRAY [0..LAST_REG]  OF WORD; //  für Abbild des Registerfeldes


procedure Meldung(msg:string); // für Testausgaben
procedure FehlerMeldung(msg:string); // für Testausgaben

var // ----- globale Variable -----
  ModBusDemo:TModBusDemo; // das Formular dieser Anwendung
  ModBus:    TUDP_Modbus; // UDP_Modbus-Klasse 1
  ModBus2:   TUDP_Modbus; // UDP_Modbus-Klasse 2
  dest_ip:   string;      // Ziel IP
  ident:     integer;     // Testvariable für INC(Identifier)
  Reg_GW:    TREG_GW;    // Abbild des Registerfeldes im Gatewy

  spalte,reihe     :integer;
  startRegister    :integer;
  endRegister      :integer;
  actregister      :integer;
  reganzahl        :integer;
  regOffset        :integer;
  startok1,startok2:boolean;
  cyclic           :boolean;   // zyklisches Auslesen

implementation
{$R *.DFM}



procedure Meldung(msg:string); // Für Testausgaben
begin{Meldung}
  if cyclic then exit; // ..Meldungsfenster nicht vollmuellen
  if ModBusDemo=nil then ShowMessage(msg) else
  ModBusDemo.Memo1.lines.add(msg);
end;{Meldung}

procedure FehlerMeldung(msg:string); // Für Testausgaben
begin{FehlerMeldung}
  if ModBusDemo=nil then ShowMessage(msg) else
  ModBusDemo.Memo2.lines.add(msg);
end;{FehlerMeldung}



procedure F3_Answer    // -- wird nach eintreffen einer F3 Antwort aufgerufen --
 (    tr_id:WORD;      // IN: Transaction-Id vom Aufruf
      anz  :WORD;      // IN: Register-Anzahl
  var werte:TREG_700); // IN: die gelesenen Register-Werte
var    i, j, k, sp, r :integer;
       reg :WORD;      // Register-index mit Offset korrigiert
begin{F3_Answer}
   //Meldung('CallBack: F3_Answer');
   reg := tr_id + regOffset;
   for i:=1 to anz do begin
     Reg_GW[reg+i-1]:= werte[i];
     r :=((reg+i-1) div COL_ANZ)+1;
     sp:=((reg+i-1) mod COL_ANZ)+1;
     ModbusDemo.Grid1.cells[sp,r]:=inttoHex(werte[i],4);
   end;

   Meldung('F3 Antwort: tr_id:='+intToStr(tr_id)+'   Anzahl='+intToStr(anz));
   //for i:=1 to anz do Meldung('Wert_'+intToStr(i)+' = '+intToHex(werte[i],4));  // Testausgaben
   Meldung('');
end;{F3_Answer}


procedure F6_Answer // -- wird nach eintreffen einer F6 Antwort(Quittung) aufgerufen --
 ( tr_id  :WORD;    // IN: Transaction-Id vom Aufruf
   adr    :WORD;    // IN: Register-Adr
   wert   :WORD);   // IN: der übertragene Register-Wert
begin{F6_Answer}
   //Meldung('CallBack: F6_Answer');
   // ..hier ggf. code für Quittung einfügen
   Meldung('F6 Antwort: tr_id:='+intToStr(tr_id)+'   Adr='+intToStr(adr)+'   Wert='+intToStr(wert));
   Meldung('');
end;{F6_Answer}



procedure F6_Answer_2 // -- wird nach eintreffen einer F6 Antwort(Quittung) aufgerufen .. für 2. ModBus Instanz--
 ( tr_id  :WORD;    // IN: Transaction-Id vom Aufruf
   adr    :WORD;    // IN: Register-Adr
   wert   :WORD);   // IN: der übertragene Register-Wert
begin{F6_Answer_2}
   //Meldung('CallBack: F6_Answer_2');
   // ..hier ggf. code für Quittung einfügen
   Meldung('F6 Antwort_2: tr_id:='+intToStr(tr_id)+'   Adr='+intToStr(adr)+'   Wert='+intToStr(wert));
   Meldung('');
end;{F6_Answer_2}


procedure F16_Answer // -- wird nach eintreffen einer F16 Antwort(Quittung) aufgerufen --
 ( tr_id  :WORD;     // IN: Transaction-Id vom Aufruf
   adr    :WORD;     // IN: Register-Adr
   anz    :WORD);    // IN: der übertragene Register-Anzahl
begin{F6_Answer}
   //Meldung('CallBack: F16_Answer');
   // ..hier ggf. code für Quittung einfügen
   Meldung('F16 Antwort: tr_id:='+intToStr(tr_id)+'   Adr='+intToStr(adr)+'   Anzahl='+intToStr(anz));
   Meldung('');
end;{F6_Answer}


procedure F3_Error_Answer  // -- wird nach eintreffen einer F3 Fehler-Antwort aufgerufen --
 ( tr_id  :WORD;    // IN: Transaction-Id vom Aufruf
   errCode:Byte);   // IN: der Fehlercode
begin{F3_Error_Answer}
   //Meldung('CallBack: F3_Error');
   FehlerMeldung('CallBack: F3_Error: tr_id:='+intToStr(tr_id)+'   errCode='+intToStr(errCode));

   // ..hier ggf. code für Fehler_Antwort einfügen
end;{F3_Error_Answer}

procedure F6_Error_Answer // -- wird nach eintreffen einer F6 Fehler-Antwort aufgerufen --
 ( tr_id  :WORD;    // IN: Transaction-Id vom Aufruf
   errCode:Byte);   // IN: der Fehlercode
begin{F6_Error_Answer}
   //Meldung('CallBack: F6_Error');
   FehlerMeldung('CallBack: F6_Error: tr_id:='+intToStr(tr_id)+'   errCode='+intToStr(errCode));
   // ..hier ggf. code für Fehler_Antwort einfügen
end;{F6_Error_Answer}

procedure F16_Error_Answer  // -- wird nach eintreffen einer F16 Fehler-Antwort aufgerufen --
 ( tr_id  :WORD;    // IN: Transaction-Id vom Aufruf
   errCode:Byte);   // IN: der Fehlercode
begin{F16_Error_Answer}
   //Meldung('CallBack: F16_Error');
   FehlerMeldung('CallBack: F16_Error: tr_id:='+intToStr(tr_id)+'   errCode='+intToStr(errCode));
   // ..hier ggf. code für Fehler_Antwort einfügen
end;{F16_Error_Answer}


procedure TModBusDemo.FormCreate(Sender: TObject); // --- FORM Initialisierung ---
Var i : integer;
begin
  //doublebuffered := true;
  Grid1.DoubleBuffered:=true;
  caption := 'UDP/ModBus Monitor  '+VERSION;
  Memo1.Clear;
  Memo2.Clear;
  grid1.Cells[0,0]:='Regist.';

  Grid1.RowCount := ((LAST_REG+1) DIV COL_ANZ) +2;
  Grid1.ColCount := COL_ANZ+1;

  For i:=1 to Grid1.RowCount do begin
    grid1.cells[0,i]:=' '+inttostr((i-1)*COL_ANZ);
  end;

  For i:=1 to grid1.colCount do begin
    grid1.Cells[i,0]:=' +'  + inttostr(i-1);
  end;


  reihe:= (startRegister div (COL_ANZ))-1;
  if (reihe<0) then reihe :=0;
  //spalte:=0;
  grid1.Enabled:=true;
  grid1.row:=reihe+2;
  grid1.col:=1;
  grid1.TopRow := grid1.Selection.Top;

  Edit1.Text := intToStr(DEFAULT_REG_OFFSET);
  Edit3.Text := intToStr(DEFAULT_END_REGISTER);
  Edit4.Text := intToStr(DEFAULT_REG_OFFSET);
  IP_Panel.Caption:='IP = '+dest_ip;
  Timer1.Interval:=120; // in mSec
  Timer1.Enabled :=False;

  if ModBus.valid_ip then ModBusDemo.IP_Panel.Color:=clLime;
end;


procedure TModBusDemo.Button6Click(Sender: TObject); // zyklisches Senden ein/aus
begin
  Timer1.Enabled := NOT Timer1.Enabled;
end;



procedure TModBusDemo.EXIT_ButtonClick(Sender: TObject);
begin
 close; // Fenster schliessen
end;


procedure TModBusDemo.ClrMemoPanelClick(Sender: TObject);
begin
  Memo1.Clear;
  Memo2.Clear;
end;



procedure TModBusDemo.IP_PanelClick(Sender: TObject); // Change IP
var old_ip:string;
begin{change IP}

  old_ip := dest_ip;
  InputQuery('neue Ziel IP - Adr.', 'bitte eingeben', dest_ip);
  dest_ip:=trim(dest_ip); //blank entfernen
  if (old_ip<>dest_ip) then begin
      IP_Panel.Caption := 'IP = '+dest_ip;
      ModBusDemo.IP_Panel.Color:=clbtnface; //default
      ModBusDemo.Repaint;

      //ModBus.SetDestIp(dest_ip);
      ModBus.free;
      ModBus:=TUDP_ModBus.create({ModBusDemo,}dest_ip); // 1.Instanz
      { --- Modbus-Empfangs-Ereignisse(Events) als 'CallBack' Funktionen registrieren --- }
      ModBus.registerErrorCallback(F3_Error_Answer,F6_Error_Answer,F16_Error_Answer);
      ModBus.registerWriteCallback(F6_Answer,F16_Answer);
      ModBus.registerReadCallback (F3_Answer);
      if ModBus.valid_ip then ModBusDemo.IP_Panel.Color:=clLime
                         else ModBusDemo.IP_Panel.Color:=clbtnface;
    Meldung('neue IP = '+dest_ip);
  end;
end;{change IP}



procedure readNext();
var err   :integer;
    anzahl:integer;
    reg   :integer;
begin{readNext}
  anzahl := endRegister - actRegister +1;
  if anzahl>100 then anzahl := 100;

  reg := actRegister - regOffset;
  err := ModBus.Send_F3(reg, reg, anzahl); // read_Multiple(id, adr, anzahl)
  if (err<>0) then begin FehlerMeldung('readNext: F3 Fehler'); end;

  actRegister:=actRegister+anzahl; // for next read
  if (actRegister>endRegister) then begin // am Register-Ende angekommen
    if cyclic then begin
       actRegister := startRegister; // wieder vorne starten
       ModBusDemo.Timer1.Enabled := TRUE;
    end else begin
       ModBusDemo.Timer1.Enabled := FALSE; // stopp!
    end;
  end else begin//noch nicht am Register-Ende angekommen
    ModBusDemo.Timer1.Enabled := TRUE;
  end;
end;{readNext}


procedure TModBusDemo.Timer1Timer(Sender: TObject);  // TimerEvent
var err:integer;
    anzahl,actregister : integer;
begin{Timer Event}

 if not (startok1 and startok2) then begin
   messagedlg('Erst Start- und End-register eingeben',mtinformation,[mbok],0);
   cyclic := false;
   Read_cyclic_Panel.color:=clbtnface;
   actregister:=startregister;
   Enabled := false;
   exit;
 end;

 readNext();

end;{Timer Event}


procedure TModBusDemo.Read_once_PanelClick(Sender: TObject); // {Send F3 (read once)}
var err:integer;
    anzahl : integer;
begin{Send F3 (read)}
  if (not Modbus.valid_ip) then begin
    Meldung('set valid IP-Addr.');
    exit;
  end;
  if not (startok1 and startok2) then begin
    messagedlg('Erst Start- und End-register eingeben',mtinformation,[mbok],0);
    exit;
  end;

  cyclic := false;

  read_cyclic_Panel.color:=clbtnface;
  actregister:=startregister;
  readNext();
end;// {Send F3 (read) once}


procedure TModBusDemo.Read_cyclic_PanelClick(Sender: TObject); // read cyclic
begin
  if (not Modbus.valid_ip) then begin
    Meldung('set valid IP-Addr.');
    exit;
  end;
  if not (startok1 and startok2) then begin
    messagedlg('Erst Start- und End-register eingeben',mtinformation,[mbok],0);
    exit;
  end;

  if not cyclic then Meldung('Meldungen ausgeschaltet...');
  cyclic := not cyclic;

  if cyclic then begin
     actregister:=startregister;
     read_cyclic_Panel.Color:=cllime;
     readNext();
  end else begin
     read_cyclic_Panel.color:=clbtnface;
  end;
end;




procedure TModBusDemo.Panel7Click(Sender: TObject);
begin
    ModBus.Send_F6(27, 200, $1234);   // write_1_Reg  (id, adr, wert)
end;

procedure TModBusDemo.Panel8Click(Sender: TObject);
var anzahl,i,err:integer;
    writeData:   TREG_700;   // für F16 (write multiple Register)
begin{Send F16}
  if startok1 and startok2 then begin
   for i:=1 to Reganzahl do writeData[i+startregister]:=Reg_GW[i+startregister];  // dummy SendeDaten
   err := ModBus.Send_F16(55, startregister, Reganzahl, writeData);  // write_Multiple(id, adr, anzahl)
   if (err<>0) then begin FehlerMeldung('F16 Fehler'); end;
  end else begin
   messagedlg('Es muß das Startregister und die Registeranzahl eingegeben werden',mtinformation,[mbok],0);
  end;
end;

procedure TModBusDemo.ClrGridPanelClick(Sender: TObject); // Clear Grid
var i,j : integer;
begin
 for j:=1 to grid1.rowcount do begin
    for i:=1 to grid1.ColCount do begin
       grid1.cells[i,j]:='';
    end;
 end;
end;


procedure updateCheckBits(wert:integer);
begin
  ModBusDemo.Bit15.Checked := (wert AND $8000) >0;
  ModBusDemo.Bit14.Checked := (wert AND $4000) >0;
  ModBusDemo.Bit13.Checked := (wert AND $2000) >0;
  ModBusDemo.Bit12.Checked := (wert AND $1000) >0;
  ModBusDemo.Bit11.Checked := (wert AND $0800) >0;
  ModBusDemo.Bit10.Checked := (wert AND $0400) >0;
  ModBusDemo.Bit9.Checked  := (wert AND $0200) >0;
  ModBusDemo.Bit8.Checked  := (wert AND $0100) >0;
  ModBusDemo.Bit7.Checked  := (wert AND $0080) >0;
  ModBusDemo.Bit6.Checked  := (wert AND $0040) >0;
  ModBusDemo.Bit5.Checked  := (wert AND $0020) >0;
  ModBusDemo.Bit4.Checked  := (wert AND $0010) >0;
  ModBusDemo.Bit3.Checked  := (wert AND $0008) >0;
  ModBusDemo.Bit2.Checked  := (wert AND $0004) >0;
  ModBusDemo.Bit1.Checked  := (wert AND $0002) >0;
  ModBusDemo.Bit0.Checked  := (wert AND $0001) >0;
end;

function getCheckedBits():integer;
var
  wert :integer;
begin
  wert:=0;
  if ModBusDemo.Bit15.Checked then wert := wert + $8000;
  if ModBusDemo.Bit14.Checked then wert := wert + $4000;
  if ModBusDemo.Bit13.Checked then wert := wert + $2000;
  if ModBusDemo.Bit12.Checked then wert := wert + $1000;
  if ModBusDemo.Bit11.Checked then wert := wert + $0800;
  if ModBusDemo.Bit10.Checked then wert := wert + $0400;
  if ModBusDemo.Bit9.Checked  then wert := wert + $0200;
  if ModBusDemo.Bit8.Checked  then wert := wert + $0100;
  if ModBusDemo.Bit7.Checked  then wert := wert + $0080;
  if ModBusDemo.Bit6.Checked  then wert := wert + $0040;
  if ModBusDemo.Bit5.Checked  then wert := wert + $0020;
  if ModBusDemo.Bit4.Checked  then wert := wert + $0010;
  if ModBusDemo.Bit3.Checked  then wert := wert + $0008;
  if ModBusDemo.Bit2.Checked  then wert := wert + $0004;
  if ModBusDemo.Bit1.Checked  then wert := wert + $0002;
  if ModBusDemo.Bit0.Checked  then wert := wert + $0001;
  result:= wert;
end;

procedure TModBusDemo.Grid1KeyPress(Sender: TObject; var Key: Char);
var
  regNo,wert:integer;
  s         :string;
begin
 if (reihe=0)  then exit;
 if (spalte=0) then exit;
 if key=char(13) then begin
   s:='0x' + grid1.Cells[spalte,reihe];
   regNo:= (reihe-1)*COL_ANZ+(spalte-1);
   if (regNo>LAST_REG) then exit;
   if s='0x' then s:='0x0';
   wert:=strToInt(s);
   Reg_GW[regNo]:=wert;
   Label2.Caption := 'REG. '+IntToStr(regNo)+' = ' +'0x'+IntToHex(wert,4);
   grid1.Cells[spalte,reihe] := IntToHex(wert,4);
   Modbus.Send_F6(27, regNo-regOffset, wert);   // write_1_Reg  (id, adr, wert)
   UpdateCheckBits(wert);
 end;//if
end;


procedure TModBusDemo.Update_ButtonClick(Sender: TObject);
var
  wert,regNo:integer;
begin
 if (reihe=0)  then exit;
 if (spalte=0) then exit;
 regNo:= (reihe-1)*COL_ANZ+(spalte-1);
 if (regNo>LAST_REG) then exit;

 if (regNo>endRegister) or (regNo<startRegister) then begin
     //messagedlg('Register nicht im Bereich '+intToStr(startRegister)+' bis '+IntToStr(endRegister),mtinformation,[mbok],0);
     Meldung('Register nicht im Bereich '+intToStr(startRegister)+' bis '+IntToStr(endRegister));
     exit;
 end;

 wert := getCheckedBits();
 Reg_GW[regNo]:=wert;
 Label2.Caption := 'REG. '+IntToStr(regNo)+' = ' +'0x'+IntToHex(wert,4);
 grid1.Cells[spalte,reihe] := IntToHex(wert,4);
 Modbus.Send_F6(27, regNo-regOffset, wert);  // write_1_Reg  (id, adr, wert)
end;


procedure TModBusDemo.Grid1MouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
var
 regNo,wert:integer;
 s         :string;
begin
  if (not Modbus.valid_ip) then begin
    Meldung('set valid IP-Addr.');;
    exit;
  end;
  if not (startok1 and startok2) then begin
    messagedlg('Erst Start- und End-register eingeben',mtinformation,[mbok],0);
    exit;
  end;

  grid1.MouseToCell(X,Y,spalte,reihe);
  if (reihe=0)  then exit;
  if (spalte=0) then exit;
  regNo:= (reihe-1)*COL_ANZ+(spalte-1);

  //if (regNo>LAST_REG) then exit;
  if (regNo>endRegister) or (regNo<startRegister) then begin
     //messagedlg('Register nicht im Bereich '+intToStr(startRegister)+' bis '+IntToStr(endRegister),mtinformation,[mbok],0);
     Meldung('Register nicht im Bereich '+intToStr(startRegister)+' bis '+IntToStr(endRegister));
     exit;
  end;

  wert := Reg_GW[regNo];
  s:='0x' + IntToHex(wert,4);
  Label2.Caption := 'REG. '+IntToStr(regNo)+' = ' +s;
  grid1.Cells[spalte,reihe] := IntToHex(wert,4);
  UpdateCheckBits(wert);

end;

procedure TModBusDemo.FormClick(Sender: TObject);  // Reset Grid to default
begin
 //reihe:=0;
 reihe:= (startRegister div (COL_ANZ))-1;
 if (reihe<0) then reihe :=0;
 spalte:=0;

 grid1.row:=reihe+2; //+1
 grid1.col:=1;
 grid1.TopRow := grid1.Selection.Top;
Label2.Caption:='Reg. ='
end;



procedure TModBusDemo.Edit1KeyPress(Sender: TObject; var Key: Char);   // StartRegister
var  wert : double;
     fehler : integer;
     s      : string;
begin
 if key=char(13) then begin
   s:=Edit1.Text;
   val(s,wert,fehler);
   if (fehler=0) and (wert>=0) and (wert<=endRegister) and (wert>=regOffset) and (wert<LAST_REG) then begin
     startRegister:=round(wert);
     startok1:=true;
   end else begin
     messagedlg('Eingabe ist ungültig',mtinformation,[mbok],0);
     //Edit1.Text:='';
     //startok1:=false;
     Edit1.Text:=IntToStr(startRegister); // alten Wert restaurieren
   end;
 end;
end;


procedure TModBusDemo.Edit2KeyPress(Sender: TObject; var Key: Char);  // Reg.Anzahl
 var  wert : double;
     fehler : integer;
     s      : string;
begin
 if key=char(13) then begin
   s:=Edit2.Text;
   val(s,wert,fehler);
   if (fehler=0) and (wert>=0) and (wert<512) then begin
     Reganzahl:=round(wert);
     startok2:=true;
   end else begin
     messagedlg('Eingabe ist ungültig',mtinformation,[mbok],0);
     Edit2.Text:='';
     startok2:=false;
   end;
 end;
end;


procedure TModBusDemo.Edit3KeyPress(Sender: TObject; var Key: Char);  // Endregister
 var wert   :double;
     fehler :integer;
     s      :string;
begin
 if key=char(13) then begin
   s:=Edit3.Text;
   val(s,wert,fehler);
   if (fehler=0) and (wert>=0) and (wert>=startRegister) and (wert<=LAST_REG) then begin
     endRegister:=round(wert);
     startok2:=true;
   end else begin
     messagedlg('Eingabe ist ungültig',mtinformation,[mbok],0);
     //Edit3.Text:='';
     //startok2:=false;
     Edit3.Text:=IntToStr(endRegister); // alten Wert restaurieren
   end;
 end;
end;



procedure TModBusDemo.Edit4KeyPress(Sender: TObject; var Key: Char); // Register Offset
 var wert   :integer;
     s      :string;
begin
  if key=char(13) then begin
    s:=Edit4.Text;
    try
      wert:= StrToInt(s);
      if (wert>startRegister) then begin //Fehler
        messagedlg('Offset muss <= StartRegister sein.',mtinformation,[mbok],0);
        Edit4.Text:=IntToStr(regOffset); // alter Wert
      end else begin //gueltig
        regOffset := wert;
      end;
    except // Fehlerbehandlung
      messagedlg(s+'  ist keine gültige Zahl',mtinformation,[mbok],0);
      Edit4.Text:=IntToStr(regOffset); // alter Wert
    end;//except
  end;//if
end;



initialization;
  //state := UDP_Closed;
  ident :=0;      // Transaction-Identifier für UDP_ModBus Telegramme
  dest_ip := '192.168.2.101';  // default
  //dest_ip := 'localhost'; // = '127.0.0.1'
  startRegister:=DEFAULT_REG_OFFSET;
  endRegister  :=DEFAULT_END_REGISTER;
  regOffset    :=DEFAULT_REG_OFFSET;
  startok1:=true;
  startok2:=true;
  cyclic := false;

  ModBus:=TUDP_ModBus.create({ModBusDemo,}dest_ip); // 1.Instanz
  { --- Modbus-Empfangs-Ereignisse(Events) als 'CallBack' Funktionen registrieren --- }
  ModBus.registerErrorCallback(F3_Error_Answer,F6_Error_Answer,F16_Error_Answer);
  ModBus.registerWriteCallback(F6_Answer,F16_Answer);
  ModBus.registerReadCallback (F3_Answer);
  //ModBus.registerStateCallback (ModBus_Connected, ModBus_Closed);

  (* -------- 2. Instanz .....
  ModBus2:=TUDP_ModBus.create({ModBusDemo,}'10.144.14.67'); // 2.Instanz
  { --- Modbus-Empfangs-Ereignisse(Events) als 'CallBack' Funktionen registrieren --- }
  ModBus2.registerErrorCallback(F3_Error_Answer,F6_Error_Answer,F16_Error_Answer);
  ModBus2.registerWriteCallback(F6_Answer_2,F16_Answer);
  //ModBus2.registerReadCallback (F3_Answer);
  ------------------- *)

finalization
  ModBus.free;
  ModBus2.free;
end.
