unit CompositeControlUnit;
interface
uses Controls, StdCtrls, Windows, Forms, Graphics, Classes, ComCtrls, SysUtils, Dialogs,
ExtCtrls, ZahlEdit, MouseTrackBar, Math;
// Variablenrecord, in dem sämtliche Informationen für die Tische gespeichert werden
// sollen. Dieser Typ wird in der Komponenten-Klasse als Array für 3 Komponenten
// aufgerufen und wird dann über die Tischauswahl-Combobox und Index gesteuert.
Type TTischInfo =
record
daktuellePosition, dZielPosition, daktuelleGeschwindigkeit,
daktuelleBeschleunigung, ddefinierteGeschwindigkeit, ddefinierteBeschleunigung,
dobereGrenze, duntereGrenze: double;
iSchrittweitenIndex: integer;
bBewegtSich, bVerfügbarkeit: boolean;
end;
Type TOnChangeEvent =
procedure of Object;
Type TOnTrackBarMouseDownEvent =
procedure of Object;
Type TOnTrackBarMouseUpEvent =
procedure of Object;
Type TTischsteuerung =
class(TWinControl)
private
// Komponenten auf der Bedienoberfläche
FLblContainerCaption,
// Überschrift Komponente
FLblTrackBar,
// sich bewegendes Label für
// Tischposition am Trackbar
// Statuslabels
FLblStatusCaption, FLblStatusEinsatzbereitschaft,
FLblStatusEinsatzbereitschaftAnzeige, FLblStatusAktuellePos,
FLblStatusAktuellePosAnzeige, FLblStatusZielPos, FLblStatusZielPosAnzeige,
FLblStatusBewegung, FLblStatusBewegungAnzeige, FLblStatusAktuelleGeschwindigkeit,
FLblStatusAktuelleGeschwindigkeitAnzeige,FLblStatusAktuelleBeschleunigung,
FLblStatusAktuelleBeschleunigungAnzeige, FLblStatusDefinierteGeschwindigkeit,
FLblStatusDefinierteGeschwindigkeitAnzeige, FLblStatusDefinierteBeschleunigung,
FLblStatusDefinierteBeschleunigungAnzeige, FLblStatusPotenzLabeldefBeschleunigung,
FLblStatusPotenzLabelaktBeschleunigung,
FLdlEingabe: TLabel;
// Label für EingabeEdit
// Edit das nur Ganze- und Gleitkommazahlen annimmt
FEdPositionsEingabe,
// Edit für Positionseingabe
FEdmanuelleBeschleunigungsEingabe,
// Edit für manuelle Beschl.-Eingabe
FEdmanuelleGeschwindigkeitsEingabe: TZahlEdit;
// Edit für manuelle Geschw.-Eingabe
FTrckBarTischposition: TMouseTrackBar;
// Trackbar das um die OnMouseDown
// OnMouseUp Ereignisse erweitert
// wurde
// Buttons (selbsterklärend)
FButtonEditEingabe, FButtonMoveLeft, FButtonMoveRight,
// Buttons für manuelle Geschwindigkeits- und Beschleunigungseingabe
FButtonmanuelleGeschwEingabe, FButtonmanuelleBeschlEingabe: TButton;
// Comboboxen Tischauswahl und Schrittweite
FCombBoxTischauswahl,FComboBoxStepWidth: TComboBox;
// Image für Bilddarstellung
FImageSelectionsBild: TImage;
// Checkbox für Automatisierung der Beschleunigung und Geschwindigkeit
FCheckBoxAutomatisierung: TCheckBox;
// Variablen
// benötigte Variabeln für die Komponente
fdTischposition, fdZielposition, fdUeberschneidung: double;
// Double für aktuelle Tischpos
// des ausgewählten Tisches
// Variablen für Komunikation Komponente <--> Hauptprogramm
// Das Array für die Tischkomponenten
ftTischInfo:
Array[1..3]
of TTischInfo;
// Variable die speichert, ob die Mouse auf dem Trackbar gedrückt ist oder nicht
bTrackBarMouseDown: boolean;
// zu dieser Variable gibt
// es keinen Getter oder Setter
// sie wird direkt in der
// OnMouseDown und OnMouseUp
// procedure vom Trackbar
// gesetzt.
// Variablen für Events
//OnChange-Variable
FOnChange: TOnChangeEvent;
// Variable für das OnChange-Ereignis
FOnTrackBarMouseDown: TOnTrackBarMouseDownEvent;
// Variable für das OnTrackBarMouseDown-
// Ereignis
FOnTrackBarMouseUp: TOnTrackBarMouseUpEvent;
// Prozeduren und Funktionen
// Setterproceduren und Getterfunktionen
procedure SetContainerCaption(Value:
string);
// Setzt eine Überschrift
procedure SetTischPosition(Value: double);
// Setzt aktuelle Tischpos
function GetTischPosition: double;
// Gibt aktuelle Tischpos zurück
function GetIndex: integer;
// Ermittelt Index des ausgewählten
// Tisches
function GetErweiterung:
string;
// Ermittelt die für den gewählten
// Tisch benötigte Erweiterung
function GetAdditionsterm: integer;
// Ermittelt die für den ausgewählten
// Tisch nötigen Additionstherm
procedure SetItemsComboBox(Box: TComboBox);
// Erstellt die für die ComboBox
// FComboBoxStepWidth nötigen Einträge
function GetobereGrenze: double;
// Ermittelt den Wert für die
// obere Grenze // Wird durch Verfahr-
// weg des 2. Verschiebetisches beschränkt
function GetuntereGrenze: double;
// Ermittelt den Wert für die
// untere Grenze
function GetdefinierteGeschwindigkeit: double;
// Ermittelt die gesetzte Geschwindig-
// keit für den ausgewählten Tisch
function GetdefinierteBeschleunigung: double;
// Ermittelt die gesetzte Beschleunigung
// für den ausgewählten Tisch
procedure SetaktuelleGeschwindigkeit(dWert: double);
// übergibt die aktuelle Geschw. an
// die Komponente
procedure SetaktuelleBeschleunigung(dWert: double);
// übergibt die aktuelle Beschl. an
// die Komponente
procedure Setverfügbarkeit(bWert: boolean);
// Verfügbarkeit der Tische setzen
function GetZielPosition: double;
// Ermittelt die Zielposition des
// ausgewählten Tisches
procedure SetOnChangeEvent;
// Setzt das OnChangeEvent
procedure SetOnTrackBarMouseDownEvent;
// Setzt das OnMouseDownEvent, wenn
// man dies über dem TrackBar setzt
procedure SetOnTrackBarMouseUpEvent;
// Setzt das OnMouseUpEvent, wenn
// man dies über dem TrackBar setzt
procedure SetUeberschneidung(dWert: double);
// Übergibt den im Hauptprogramm eingestellten
// Wert für die Überschneidung der Verschiebetische
// Create-Funktion für alle verwendeten Komponenten
function CreateLabel(PosX, PosY, Textgroesse: integer; Text:
string; Enabled: boolean): TLabel;
function CreateTrackBar(PosX,PosY, Width, Height:integer): TMouseTrackBar;
function CreateEdit(PosX, PosY, Width: integer; Caption:
string; Visible: boolean): TZahlEdit;
function CreateButton(PosX, PosY, Width, Height: integer; Caption:
string; Visible: boolean): TButton;
function CreateComboBox(PosX, PosY, Width: integer): TComboBox;
function CreateImage(PosX, PosY, Width, Height: integer): TImage;
function CreateCheckBox(PosX, PosY, Width, Height: integer; Caption:
string): TCheckbox;
// Verarbeitungsprozeduren
// Funktion zur Anpassung des Potenzlabels (Position)
function LabelPosition_anpassen(ReferenzLabel: TLabel): integer;
// Prozedur, welche bei Aktivierung den ausgewählten Tisch anhalten soll
procedure TrackBarMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
// Procedur welche das mitbewegen des Positionslabels bewerkstellig
procedure TrackBarbewegung(Sender: TObject);
// Prozedur, welche bei Aktivierung das Bewegungssignal aus der Komponente
// ausgeben soll
procedure TrackBarMouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
// Prozeduren zur Positionansteuerung
procedure Position_ansteuern(Sender: TObject);
procedure MoveLeftStepWidth(Sender: TObject);
procedure MoveRightStepWidth(Sender: TObject);
// Prozedur zum leeren des Edits, wenn draufgeklickt wird
procedure Edit_leeren(Sender: TObject);
// Prozedur zum Anpassen der Komponenten bei Änderung des ausgewählten Tisches
procedure Tischaenderung(Sender: TObject);
procedure DarstellungTischAuswahl(
Index: integer);
procedure Komponentenanpassung(
Index: integer);
procedure Komponenten_einstellen(
Index: integer);
procedure Komp_laden(
Index: integer);
// Prozdure zur Änderung des Inhaltes von FComboBoxStepWidth bei Wechsel von
// Verschiebetisch auf Pi-Tisch
procedure StepWidthAenderung(Sender: TObject);
// Procedure, die die Automatisierung der Geschwindigkeit und Beschleunigung
// automatisch steuern soll.
procedure AutomatisierungGeschwBeschl(Sender: TObject);
// Procedure lässt das Label FLblStatusDefinierteBeschleunigungAnzeige verschwinden
// und das dazugehörige Edit FEdmanuelleBeschleunigungsEingabe erscheinen
procedure manuelleBeschleunigungsEingabe_aktivieren(Sender: TObject);
// Procedure lässt das Edit FEdmanuelleBeschleunigungsEingabe verschwinden und
// das dazugehörige Label FLblStatusDefinierteBeschleunigungAnzeige erscheinen
procedure manuelleBeschleunigungsEingabe_verlassen(Sender: TObject;
var Key: Word;
Shift: TShiftState);
// Procedure lässt das Label FLblStatusDefinierteGeschwindigkeitAnzeige verschwinden
// und das dazugehörige Edit FEdmanuelleGeschwindigkeitsEingabe erscheinen
procedure manuelleGeschwindigkeitsEingabe_aktivieren(Sender: TObject);
// Procedure lässt das Edit FEdmanuelleGeschwindigkeitsEingabe verschwinden und
// das dazugehörige Label FLblStatusDefinierteGeschwindigkeitAnzeige erscheinen
procedure manuelleGeschwindigkeitsEingabe_verlassen(Sender: TObject;
var Key: Word;
Shift: TShiftState);
// Prozedur, damit die Schrift einiger Labels vor dem Image und der Paintbox
// liegt
procedure Schrift_in_den_Vordergrund_bringen;
// aktualisiert die Statusanzeige
procedure Status_laden;
// Procedure die die Kollisionsprüfung für die beiden Verschiebetische durchführt
//* procedure Kollisionsprüfung;
// Prozedur zum Erzeugen einer automatischen Geschwindigkeit, Anpassen der
// Geschwindigkeit an Abstand zur Zielposition und anderen Objekten
function automatisches_Setzen_Geschwindigkeit(
Index: integer): double;
// Prozedur zum Setzen der Beschleunigung. Da eine schnelle Reaktionsfähigkeit
// gewollt ist, wird der Wert bei der Automatik immer auf den MaxWert gesetzt
function automatisches_Setzen_Beschleunigung: double;
// Prozedur zum Umrechnen der Microsteps in mm.
function Umrechnung_MicroSteps_in_mm(Wert_in_MicroSteps: double): double;
// Prozedur um die manuelle Eingabe von Geschwindigkeit und Beschleunigung zu
// starten und zu akzeptieren.
procedure Geschw_Beschl_eingeben_und_akzeptieren(Sender: TObject);
// Bereinigungsprozedur für manuelle Eingabe von Geschw. und Beschleunigung
//procedure Geschw_Beschl_Eingabe_verlassen(Sender: TObject);
protected
// Prozedur initialisiert sämtliche Komponenten
procedure createWnd;
override;
published
// OnChange-Event wird ausgelöst, wenn der Zielwert des gewählten Tisches verändert wird
property OnChange: TOnChangeEvent
read FOnChange
write FOnChange;
// Bei der Komponente sind einige Ereignisse wichtig, damit das Hauptprogramm mitbekommt,
// wenn bestimmte Änderungen an der Komponente vorgenommen werden. So wird der aktuelle
// Verschiebetisch z.B. gestoppt, wenn man ein MouseDown-Event auf den TrackBar ausführt.
// Diese Events müssen natürlich nach außen weitergeleitet werden. Dafür sind folgende
// Events nötig.
// OnTrackBarMouseDown-Event, um eine Bremsung des ausgewählten Tisches zu realisieren,
// wenn der die Zielposition geändert wird.
property OnTrackBarMouseDown: TOnTrackBarMouseDownEvent
read FOnTrackBarMouseDown
write FOnTrackBarMouseDown;
// OnTrackBarMouseUp-Event, um Änderungen vorzunehmen die nötig sind, wenn eine Änderung
// der Zielposition erfolgt ist.
property OnTrackBarMouseUp: TOnTrackBarMouseUpEvent
read FOnTrackBarMouseUp
write FOnTrackBarMouseUp;
public
// Prozedur initialisiert sämtliche Variablen und Default-Größen
constructor create(AOwner: TComponent);
// Eigenschaft die Überschrift zu Ändern
property ContainerCaption :
string write SetContainerCaption;
//* Die aktuelle Position muss für alle 3 Verschiebetische hier übergeben werden,
//* damit das automatische Setzen der Geschwindigkeit auch für den nicht aktivierten
//* Tisch greift. Kollisionsprüfung ist hier von getrennt worden.
// Eigenschaft zum Lesen und setzen der aktuellen Tischposition
property Tischposition: double
read GetTischPosition
write SetTischposition;
// Eigenschaft ob ausgewählter Tisch gebremst werden muss
property AenderungZielpositionAktuellerVerschiebetisch: boolean
read bTrackBarMouseDown;
// ObereGrenze des ausgewählten Tisches dies ist die wichtigste Grenzbetrachtung für
// die Verschiebetische, da hier 2 dynamische Komponenten auf einander treffen.
property obereGrenze: double
read GetobereGrenze;
// definierte Geschwindigkeit des ausgewählten Tisches
property definierteGeschwindigkeit: double
read GetdefinierteGeschwindigkeit;
// definierte Beschleunigung des ausgewählten Tisches
property definierteBeschleunigung: double
read GetdefinierteBeschleunigung;
// aktuelle Geschwindigkeit des gewählten Tisches an die Komponente übergeben
property aktuelleGeschwindigkeit: double
write SetaktuelleGeschwindigkeit;
// aktuelle Beschleunigung des gewählten Tisches an die Komponente übergeben
property aktuelleBeschleunigung:double
write SetaktuelleBeschleunigung;
// Verfügbarkeit der Tische setzen
//* Es wird erstmal für alle Tische ein einziger Wert übergeben, der alle Tische
//* freischaltet oder sperrt. Es sollte später versucht werden, dass jeder Tisch
//* für sich freigeschaltet wird.
property Verfügbarkeit: boolean
write SetVerfügbarkeit;
// Zielpostion des ausgewählten Tisches auslesen
property Zielposition: double
read GetZielPosition;
// Überschneidung des Tisches, dieser Wert kommt aus der Einstellung des
// Hauptprogrammes und kann nur von außen gesetzt werden.
property Ueberschneidung: double
write SetUeberschneidung;
end;
{$R Darstellung.RES}
implementation
{////////////////////////////////////////////////////////////////////////////////////}
{/ Create-Funktionen /}
{////////////////////////////////////////////////////////////////////////////////////}
constructor TTischsteuerung.create(AOwner: TComponent);
var i: integer;
begin
inherited create(AOwner);
Controlstyle := Controlstyle - [csAcceptsControls];
// Der Componente wird nicht erlaubt
// andere Componenten aufzunehmen,
// als die, die durch den Programmierer
// hier einprogrammiert werden.
Visible := true;
width := 750;
height := 700;
for i := 1
to 3
do
begin
if (i
in [1,2])
then
case i
of
1 :
begin
ftTischInfo[i].iSchrittweitenIndex := 4;
ftTischInfo[i].dObereGrenze := 100;
ftTischInfo[i].dUntereGrenze := -100;
end;
2 :
begin
ftTischInfo[i].iSchrittweitenIndex := 4;
ftTischInfo[i].dObereGrenze := 100;
ftTischInfo[i].dUntereGrenze := -2;
end;
3 :
begin
ftTischInfo[i].iSchrittweitenIndex := 0;
ftTischInfo[i].dObereGrenze := 100;
ftTischInfo[i].dUntereGrenze := 0;
end;
end;
ftTischInfo[i].dZielPosition := 0.0;
ftTischInfo[i].bBewegtSich := false;
ftTischInfo[i].bVerfügbarkeit := false;
ftTischInfo[i].daktuellePosition := ftTischInfo[i].dZielPosition;
ftTischInfo[i].daktuelleGeschwindigkeit := 0.0;
ftTischInfo[i].daktuelleBeschleunigung := 0.0;
ftTischInfo[i].ddefinierteGeschwindigkeit := 2000.0;
ftTischInfo[i].ddefinierteBeschleunigung := 1000.0;
end;
bTrackBarMouseDown := false;
// Default-Wert setzen
fdUeberschneidung := 68;
// Default-Wert setzen
// CheckBoxinitialisierung
FCheckBoxAutomatisierung := CreateCheckBox(420, 530, 250, 20, '
Automatisierung Geschw. und Beschl.');
FCheckBoxAutomatisierung.OnClick := AutomatisierungGeschwBeschl;
end;
function TTischsteuerung.CreateLabel(PosX, PosY, Textgroesse: integer; Text:
string; Enabled: boolean): TLabel;
begin
result := TLabel.Create(
nil);
result.Parent := Self;
result.Left := PosX;
result.Top := PosY;
result.Caption := Text;
result.Font.Height := Textgroesse;
result.Enabled := Enabled;
end;
function TTischsteuerung.CreateTrackBar(PosX,PosY, Width, Height:integer): TMouseTrackBar;
begin
result := TMouseTrackbar.Create(
nil);
result.Parent := Self;
result.Left := PosX;
result.Top := PosY;
result.Height := Height;
result.Width := Width;
result.Max := 640000;
result.Position := 320000;
result.OnMouseDown := TrackBarMouseDown;
result.OnChange := TrackBarBewegung;
result.OnMouseUp := TrackBarMouseUp;
end;
function TTischsteuerung.CreateEdit(PosX, PosY, Width: integer; Caption:
string; Visible: boolean): TZahlEdit;
begin
result := TZahlEdit.Create(
nil);
result.Parent := Self;
result.Left := PosX;
result.Top := PosY;
result.Height := 20;
result.Width := Width;
result.Text := Caption;
result.Font.Height := 14;
result.Visible := Visible;
end;
function TTischsteuerung.CreateButton(PosX, PosY, Width, Height: integer; Caption:
string; Visible: boolean): TButton;
begin
result := TButton.Create(
nil);
result.Parent := Self;
result.Left := PosX;
result.Top := PosY;
result.Caption := Caption;
result.Height := Height;
result.Width := Width;
result.Visible := Visible;
end;
function TTischsteuerung.CreateComboBox(PosX, PosY, Width: integer): TComboBox;
begin
result := TComboBox.Create(
nil);
result.Parent := Self;
result.Left := PosX;
result.Top := PosY;
result.Height := 20;
result.Width := Width;
result.Clear;
end;
function TTischsteuerung.CreateImage(PosX: Integer; PosY: Integer; Width: Integer; Height: Integer): Timage;
begin
result := TImage.Create(
nil);
result.Parent := Self;
result.Left := PosX;
result.Top := PosY;
result.Width := Width;
result.Height := Height;
result.Picture.Bitmap.LoadFromResourceName(HInstance, '
BILD_KAMERA');
result.Stretch := true;
result.Visible := true;
result.BringToFront;
result.Transparent := true;
result.Repaint;
end;
function TTischsteuerung.CreateCheckBox(PosX: Integer; PosY: Integer; Width: Integer; Height: Integer; Caption:
string): TCheckBox;
begin
result := TCheckBox.Create(
nil);
result.Parent := Self;
result.Left := PosX;
result.Top := PosY;
result.Width := Width;
result.Height := Height;
result.Caption := Caption;
result.Checked := true;
end;
{////////////////////////////////////////////////////////////////////////////////////}
{/ Prozeduren zur Trackbarsteuerung /}
{////////////////////////////////////////////////////////////////////////////////////}
// Die OnMouseDown-Prozedure soll bei Aktivierung den ausgewählten Tisch anhalten.
// Es wird als unnötig angesehen, einen Tisch weiter in eine Richtung oder auf eine
// Positionfahren zu lassen, die man in den nächsten Momenten ändern wird.
procedure TTischsteuerung.TrackBarMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
// Hier muss das StopEvent für den ausgewählten Tisch eingegeben werden
bTrackbarMouseDown := true;
end;
// Die Bewegungsprozedur sorgt dafür, dass das Label welches die Tischposition über
// der Trackbar anzeigt mitgeführt wird.
procedure TTischsteuerung.Trackbarbewegung(Sender: TObject);
var iAdditionsterm: integer;
sErweiterung:
string;
begin
iAdditionsterm := GetAdditionsterm;
sErweiterung := GetErweiterung;
fLblTrackBar.Left :=68 + round((FTrckBarTischposition.Position/640000)*310);
fLblTrackBar.Caption := Format('
%3.3f ' + sErweiterung,[(FTrckBarTischposition.Position/6400)- iAdditionsterm]);
Status_laden;
end;
// Die OnMouseUp-Prozedure löst bei dem ausgewählten Tisch die neue Bewegung aus. Er
// ändert die Zielposition des ausgewählten Tisches und im Hauptprogramm muss darauf
// dann reagiert werden. Hier bedarf es noch einiger Überarbeitungen und Überlegungen,
//*da folgende Daten sich mit ändern können: obere und untere Grenze.
procedure TTischsteuerung.TrackBarMouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
var Index, iAdditionsterm: integer;
begin
Index := GetIndex;
iAdditionsterm := GetAdditionsterm;
ftTischInfo[
Index].dZielPosition := (FTrckBarTischposition.Position/6400) - iAdditionsterm;
bTrackbarMouseDown := false;
SetOnChangeEvent;
Status_laden;
end;
{////////////////////////////////////////////////////////////////////////////////////}
{/ Funktionen für die Trackbar-Positionssteuerung /}
{////////////////////////////////////////////////////////////////////////////////////}
// Leert das Positionseingabe-Edit beim Klicken auf dieses.
procedure TTischsteuerung.Edit_leeren(Sender: TObject);
begin
fEdPositionsEingabe.Clear;
end;
// Prozedure, die den Edittext überprüft und in einen für den Computer verständlichen
// und für die Funktion kompatiblen Wert konvertiert und dann die Zielposition ändert
// sowie den Trackbar neu setzt.
procedure TTischsteuerung.Position_ansteuern(Sender: TObject);
var Index, iAdditionsterm: integer;
dWert: double;
begin
try
if trystrtofloat(FEdPositionsEingabe.Text, dWert)
then
begin
dWert := strtofloat(FEdPositionsEingabe.Text);
Index := GetIndex;
if ((dWert <= ftTischInfo[
Index].dObereGrenze)
and (dWert >= ftTischInfo[
Index].dUntereGrenze))
then
begin
iAdditionsterm := GetAdditionsterm;
ftTischInfo[
Index].dZielPosition := dWert;
FTrckBarTischposition.Position := round((ftTischInfo[
Index].dZielPosition + iAdditionsterm) * 6400);
FEdPositionsEingabe.Text := '
Wert eingeben';
end
else FEdPositionsEingabe.Text := '
Wert eingeben';
end
except
FEdPositionsEingabe.Text := '
Wert eingeben';
end;
Status_laden;
end;
{////////////////////////////////////////////////////////////////////////////////////}
{/ Funktionen für die Button-Positionssteuerung /}
{////////////////////////////////////////////////////////////////////////////////////}
// Mit Klick auf den MoveRightStepWidth-Button führt der Tisch eine Bewegung nach
// rechts aus, die im Rahmen der Genauigkeiten des Tisches, dem Wert der in
// FComboBoxStepWidth-Anzeige entspricht
procedure TTischsteuerung.MoveRightStepWidth(Sender: TObject);
var Index, iAdditionsterm: integer;
sTemp:
string;
begin
Index := GetIndex;
sTemp := FComboBoxStepWidth.Text;
delete(sTemp,Length(sTemp)-2,3);
if (ftTischInfo[
Index].dZielPosition + (strtoint(sTemp))/1000 <= ftTischInfo[
Index].dObereGrenze)
then
begin
iAdditionsterm := GetAdditionsterm;
ftTischInfo[
Index].dZielPosition := ftTischInfo[
Index].dZielPosition + (strtoint(sTemp))/1000;
FTrckBarTischposition.Position := round((ftTischInfo[
Index].dZielPosition + iAdditionsterm) * 6400);
end;
Status_laden;
end;
// Mit Klick auf den MoveLeftStepWidth-Button führt der Tisch eine Bewegung nach
// links aus, die im Rahmen der Genauigkeiten des Tisches, dem Wert der in
// FComboBoxStepWidth-Anzeige entspricht
procedure TTischsteuerung.MoveLeftStepWidth(Sender: TObject);
var Index, iAdditionsterm: integer;
sTemp:
string;
begin
Index := GetIndex;
sTemp := FComboBoxStepWidth.Text;
delete(sTemp,Length(sTemp)-2,3);
if (ftTischInfo[
Index].dZielPosition - (strtoint(sTemp))/1000 >= ftTischInfo[
Index].dUntereGrenze)
then
begin
iAdditionsterm := GetAdditionsterm;
ftTischInfo[
Index].dZielPosition := ftTischInfo[
Index].dZielPosition - (strtoint(sTemp))/1000;
FTrckBarTischposition.Position := round((ftTischInfo[
Index].dZielPosition + iAdditionsterm) * 6400);
end;
Status_laden;
end;
{////////////////////////////////////////////////////////////////////////////////////}
{/ Setter-Prozeduren und Getter-Funktionen /}
{////////////////////////////////////////////////////////////////////////////////////}
// Setzt die Komponentenüberschrift
procedure TTischsteuerung.SetContainerCaption(Value:
string);
begin
FLblContainerCaption.Caption := Value;
end;
// Setzt die aktuelle Tischposition in die Variable fdTischposition. Dies ist nötig, da diese aus dem Verschiebetisch
// ausgelesen wird. Wird für den Tischstatus benötigt
procedure TTischsteuerung.SetTischPosition(Value: Double);
begin
fdTischposition := Value;
FTrckBarTischposition.Position := round(fdTischposition*6400);
end;
// Liest die aktuelle Tischposition aus der Variable fdTischposition
function TTischsteuerung.GetTischPosition: double;
begin
result := fdTischposition;
end;
// Ermittelt den Index für den ausgewählten Tisch anhand der ComboBox FCombBoxTischauswahl
// Hierrüber wird später auch die Identifizierung der Tische im Hauptprogramm laufen
function TTischsteuerung.GetIndex: integer;
begin
result := (FCombBoxTischauswahl.ItemIndex+1);
end;
// Ermittelt die benötigte Erweiterung (mm oder µm) für die dementsprechenden Anzeigen
function TTischsteuerung.GetErweiterung:
string;
var Index: integer;
begin
Index := GetIndex;
if Index in [1,2]
then result := '
mm'
else result := '
µm';
end;
// Ermittelt die nötige Verschiebung für den Trackbar. Dies ist nötig, da die Ver-
// schiebetische unterschiedliche Referenzpositionen haben. Die beiden großen
// Verschiebetische haben ihre Referenzposition in der Mitte und der Piezotisch
// am "rechten" Ende. Damit wird eine gleichbehandlung aller Tische und somit
// eine Verringerung der nötigen Prozeduranzahl erreicht.
function TTischsteuerung.GetAdditionsterm: integer;
var Index: integer;
begin
Index := GetIndex;
if Index in [1,2]
then result := 50
else result := 0;
end;
function TTischsteuerung.GetuntereGrenze: double;
var Index: integer;
begin
Index := GetIndex;
result := ftTischInfo[
Index].duntereGrenze;
end;
function TTischsteuerung.GetdefinierteGeschwindigkeit;
var Index: integer;
begin
Index := GetIndex;
result := ftTischInfo[
Index].ddefinierteGeschwindigkeit;
end;
function TTischsteuerung.GetdefinierteBeschleunigung;
var Index: integer;
begin
Index := GetIndex;
result := ftTischInfo[
Index].ddefinierteBeschleunigung;
end;
procedure TTischsteuerung.SetaktuelleGeschwindigkeit(dWert: double);
var Index: integer;
begin
Index := GetIndex;
ftTischInfo[
Index].daktuelleGeschwindigkeit := dWert;
end;
procedure TTischsteuerung.SetaktuelleBeschleunigung(dWert: Double);
var Index: integer;
begin
Index := GetIndex;
ftTischInfo[
Index].daktuelleBeschleunigung := dWert;
end;
procedure TTischsteuerung.SetVerfügbarkeit(bWert: Boolean);
var Index: integer;
begin
for Index :=1
to 3
do
begin
ftTischInfo[
Index].bVerfügbarkeit := bWert;
if bWert = false
then Enabled := false;
end;
end;
function TTischsteuerung.GetZielPosition;
var Index: integer;
begin
Index := GetIndex;
result := ftTischInfo[
Index].dZielPosition;
end;
procedure TTischsteuerung.SetOnChangeEvent;
begin
if assigned(OnChange)
then OnChange;
end;
procedure TTischsteuerung.SetOnTrackBarMouseDownEvent;
begin
if assigned(OnTrackBarMouseDown)
then OnTrackBarMouseDown;
end;
procedure TTischsteuerung.SetOnTrackBarMouseUpEvent;
begin
if assigned(OnTrackBarMouseUp)
then OnTrackBarMouseUp;
end;
procedure TTischsteuerung.SetUeberschneidung(dWert: Double);
begin
fdUeberschneidung := dWert;
end;
{////////////////////////////////////////////////////////////////////////////////////}
{/ Anpassen der Komponenten bei Änderung des ausgewählten Tisches /}
{////////////////////////////////////////////////////////////////////////////////////}
function TTischsteuerung.LabelPosition_anpassen(ReferenzLabel: TLabel): integer;
begin
result := ReferenzLabel.Left + ReferenzLabel.Width;
end;
{////////////////////////////////////////////////////////////////////////////////////}
{/ Anpassen der Komponenten bei Änderung des ausgewählten Tisches /}
{////////////////////////////////////////////////////////////////////////////////////}
procedure TTischsteuerung.DarstellungTischAuswahl(
Index: Integer);
begin
case Index of
1:
begin FImageSelectionsBild.Picture.Bitmap.LoadFromResourceName(HInstance, '
BILD_KAMERA');
end;
2:
begin FImageSelectionsBild.Picture.Bitmap.LoadFromResourceName(HInstance, '
BILD_Referenz');
end;
3:
begin FImageSelectionsBild.Picture.Bitmap.LoadFromResourceName(HInstance, '
Bild_Piezo');
end;
end;
end;
procedure TTischsteuerung.Komponenten_einstellen(
Index: Integer);
var iAdditionsterm: integer;
begin
iAdditionsterm := GetAdditionsterm;
FTrckBarTischposition.Position := round((ftTischInfo[
Index].dZielPosition +iAdditionsterm) * 6400);
end;
procedure TTischsteuerung.Komp_laden(
Index: integer);
begin
SetItemsComboBox(FComboBoxStepWidth);
Status_laden;
Komponenten_einstellen(
Index);
end;
procedure TTischsteuerung.Komponentenanpassung(
Index: Integer);
begin
// Bilddarstellung laden
DarstellungTischauswahl(
Index);
// Position auslesen für angezeigten Tisch
// Zielposition für angezeigten Tisch
Komp_laden(
Index);
end;
procedure TTischsteuerung.Tischaenderung(Sender: TObject);
begin
case FCombBoxTischauswahl.ItemIndex
of
0: Komponentenanpassung(1);
1: Komponentenanpassung(2);
2: Komponentenanpassung(3);
end;
end;
{////////////////////////////////////////////////////////////////////////////////////}
{/ Automatische Steuerungsfunktion für Geschw. und Beschl. /}
{////////////////////////////////////////////////////////////////////////////////////}
// Automatisierungsfunktion hat die Aufgabe, wenn sie an ist (Checkbox gecheckt)
// die Beschleunigungen und Geschwindigkeiten aller Tische zu steuern. Dafür wird
// wenn die Automatisierung durchgeführt wird die Geschwindigkeit und Beschleunigung
// auf einen konstant vorgegebenen Wert angepasst. Die Beschleunigung ist dabei
// immer sehr hoch (sorgt für eine schnelle Reaktion) und die Geschwindigkeit wird
// abhängig von der Entfernung zum Ziel beziehungsweise von einer der beiden Grenzen
// (obere und unter) gesetzt.
procedure TTischsteuerung.AutomatisierungGeschwBeschl(Sender: TObject);
var Index: integer;
begin
if FCheckBoxAutomatisierung.Checked
then
begin
FEdmanuelleBeschleunigungsEingabe.Visible := false;
FLblStatusDefinierteBeschleunigungAnzeige.Visible := true;
FLblStatusDefinierteBeschleunigungAnzeige.BringToFront;
FEdmanuelleGeschwindigkeitsEingabe.Visible := false;
FLblStatusDefinierteGeschwindigkeitAnzeige.Visible := true;
FLblStatusPotenzLabeldefBeschleunigung.Visible := true;
FLblStatusDefinierteGeschwindigkeitAnzeige.BringToFront;
FLblStatusdefinierteBeschleunigung.Enabled := false;
FLblStatusdefinierteBeschleunigungAnzeige.Enabled := false;
FLblStatusdefinierteGeschwindigkeit.Enabled := false;
FLblStatusdefinierteGeschwindigkeitAnzeige.Enabled := false;
FLblStatusPotenzLabeldefBeschleunigung.Enabled := false;
FButtonmanuelleGeschwEingabe.Visible := false;
FButtonmanuelleBeschlEingabe.Visible := false;
// hier die Funktionen für automatische Geschwindigkeit und Beschleunigung
// einfügen.
for Index := 1
to 2
do ftTischInfo[
Index].ddefinierteGeschwindigkeit := automatisches_Setzen_Geschwindigkeit(
Index);
for Index := 1
to 2
do ftTischInfo[
Index].ddefinierteBeschleunigung := automatisches_Setzen_Beschleunigung;
end
else
begin
FLblStatusdefinierteBeschleunigung.Enabled := true;
FLblStatusdefinierteBeschleunigungAnzeige.Enabled := true;
FLblStatusdefinierteGeschwindigkeit.Enabled := true;
FLblStatusdefinierteGeschwindigkeitAnzeige.Enabled := true;
FLblStatusPotenzLabeldefBeschleunigung.Enabled := true;
FButtonmanuelleGeschwEingabe.Visible := true;
FButtonmanuelleBeschlEingabe.Visible := true;
end;
Status_laden;
end;
function TTischsteuerung.automatisches_Setzen_Geschwindigkeit(
Index: integer): double;
begin
if (abs(ftTischInfo[
Index].daktuellePosition - ftTischInfo[
Index].dZielPosition) > 5)
then result := 5000;
if inRange(abs(ftTischInfo[
Index].daktuellePosition - ftTischInfo[
Index].dZielPosition), 3, 5)
then result := 2500;
if inRange(abs(ftTischInfo[
Index].daktuellePosition - ftTischInfo[
Index].dZielPosition), 1, 3)
then result := 1000;
if (abs(ftTischInfo[
Index].daktuellePosition - ftTischInfo[
Index].dZielPosition) < 1)
then result := 500;
end;
function TTischsteuerung.automatisches_Setzen_Beschleunigung;
begin
result := 5000;
end;
function TTischsteuerung.Umrechnung_MicroSteps_in_mm(Wert_in_MicroSteps: Double): double;
begin
result := Wert_in_MicroSteps/6400;
end;
{////////////////////////////////////////////////////////////////////////////////////}
{/ Anzeigen der Edit-Komponente für manuelle Eingaben /}
{////////////////////////////////////////////////////////////////////////////////////}
procedure TTischsteuerung.Geschw_Beschl_eingeben_und_akzeptieren(Sender: TObject);
var key: Word;
begin
if Sender = FButtonmanuelleGeschwEingabe
then
begin
if FButtonmanuelleGeschwEingabe.Caption = '
eingeben'
then manuelleGeschwindigkeitsEingabe_aktivieren(FButtonmanuelleGeschwEingabe)
else
begin
key := 13;
manuelleGeschwindigkeitsEingabe_verlassen(FButtonmanuelleGeschwEingabe, key, []);
end;
end
else
begin
if FButtonmanuelleBeschlEingabe.Caption = '
eingeben'
then manuelleBeschleunigungsEingabe_aktivieren(FButtonmanuelleBeschlEingabe)
else
begin
key := 13;
manuelleBeschleunigungsEingabe_verlassen(FButtonmanuelleBeschlEingabe, key, []);
end;
end;
end;
procedure TTischsteuerung.manuelleBeschleunigungsEingabe_aktivieren(Sender: TObject);
var sTemp:
string;
key: Word;
begin
key := 13;
manuelleGeschwindigkeitsEingabe_verlassen(FButtonmanuelleGeschwEingabe, key, []);
FEdmanuelleGeschwindigkeitsEingabe.Visible := false;
FLblStatusDefinierteGeschwindigkeitAnzeige.Visible := true;
FLblStatusDefinierteGeschwindigkeitAnzeige.BringToFront;
FLblStatusDefinierteBeschleunigungAnzeige.Visible := false;
FLblStatusPotenzLabeldefBeschleunigung.Visible := false;
FEdmanuelleBeschleunigungsEingabe.BringToFront;
FEdmanuelleBeschleunigungsEingabe.Visible := true;
sTemp := FLblStatusDefinierteBeschleunigungAnzeige.Caption;
delete(sTemp, Length(sTemp)-4,5);
FEdmanuelleBeschleunigungsEingabe.Text := sTemp;
FButtonmanuelleBeschlEingabe.Caption := '
akzeptieren';
end;
procedure TTischsteuerung.manuelleBeschleunigungsEingabe_verlassen(Sender: TObject;
var Key: Word; Shift: TShiftState);
var Index: integer;
dWert: double;
begin
Index := GetIndex;
if (Key = 13)
then
begin
FEdmanuelleBeschleunigungsEingabe.Visible := false;
FLblStatusDefinierteBeschleunigungAnzeige.Visible := true;
FLblStatusDefinierteBeschleunigungAnzeige.BringToFront;
FLblStatusPotenzLabeldefBeschleunigung.Visible := true;
FLblStatusPotenzLabeldefBeschleunigung.BringToFront;
if trystrtofloat(FEdmanuelleBeschleunigungsEingabe.Text, dWert)
then
begin
dWert := strtofloat(FEdmanuelleBeschleunigungsEingabe.Text);
ftTischInfo[
Index].ddefinierteBeschleunigung := dWert*6400;
end;
Status_laden;
FButtonmanuelleBeschlEingabe.Caption := '
eingeben';
end;
end;
procedure TTischsteuerung.manuelleGeschwindigkeitsEingabe_aktivieren(Sender: TObject);
var sTemp:
string;
key: Word;
begin
key := 13;
manuelleBeschleunigungsEingabe_verlassen(FButtonmanuelleBeschlEingabe, key, []);
FEdmanuelleBeschleunigungsEingabe.Visible := false;
FLblStatusDefinierteBeschleunigungAnzeige.Visible := true;
FLblStatusDefinierteBeschleunigungAnzeige.BringToFront;
FLblStatusPotenzLabeldefBeschleunigung.Visible := true;
FLblStatusPotenzLabeldefBeschleunigung.BringToFront;
FLblStatusDefinierteGeschwindigkeitAnzeige.Visible := false;
FEdmanuelleGeschwindigkeitsEingabe.BringToFront;
FEdmanuelleGeschwindigkeitsEingabe.Visible := true;
sTemp := FLblStatusDefinierteGeschwindigkeitAnzeige.Caption;
delete(sTemp, Length(sTemp)-4,5);
FEdmanuelleGeschwindigkeitsEingabe.Text := sTemp;
FButtonmanuelleGeschwEingabe.Caption := '
akzeptieren';
end;
procedure TTischsteuerung.manuelleGeschwindigkeitsEingabe_verlassen(Sender: TObject;
var Key: Word; Shift: TShiftState);
var Index: integer;
dWert: double;
begin
Index := GetIndex;
if (Key = 13)
then
begin
FEdmanuelleGeschwindigkeitsEingabe.Visible := false;
FLblStatusDefinierteGeschwindigkeitAnzeige.Visible := true;
FLblStatusDefinierteGeschwindigkeitAnzeige.BringToFront;
if trystrtofloat(FEdmanuelleGeschwindigkeitsEingabe.Text, dWert)
then
begin
dWert := strtofloat(FEdmanuelleGeschwindigkeitsEingabe.Text);
ftTischInfo[
Index].ddefinierteGeschwindigkeit := dWert*6400;
end;
Status_laden;
FButtonmanuelleGeschwEingabe.Caption := '
eingeben';
end;
end;
{////////////////////////////////////////////////////////////////////////////////////}
{/ Anpassen der Combobox FComboBoxStepWidth /}
{////////////////////////////////////////////////////////////////////////////////////}
procedure TTischsteuerung.StepWidthAenderung(Sender: TObject);
var Index: integer;
begin
Index := GetIndex;
ftTischInfo[
Index].iSchrittweitenIndex := FComboBoxStepWidth.ItemIndex;
end;
procedure TTischsteuerung.SetItemsComboBox(Box: TComboBox);
var sErweiterung:
string;
Index: integer;
begin
Box.Clear;
Index := GetIndex;
if Index in [1,2]
then sErweiterung := '
µm'
else sErweiterung := '
nm';
Box.Items.Add('
5 '+ sErweiterung);
Box.Items.Add('
20 ' + serweiterung);
Box.Items.Add('
100 ' + sErweiterung);
Box.Items.Add('
500 ' + sErweiterung);
Box.Items.Add('
1000 ' + sErweiterung);
Box.Items.Add('
5000 ' + sErweiterung);
Box.ItemIndex := ftTischInfo[
Index].iSchrittweitenIndex;
end;
{////////////////////////////////////////////////////////////////////////////////////}
{/ Prozeduren für die Statusanzeige /}
{////////////////////////////////////////////////////////////////////////////////////}
procedure TTischsteuerung.Status_laden;
var Index: integer;
sErweiterung, sGeschwindigkeitseinheit, sBeschleunigungseinheit:
string;
begin
Index := GetIndex;
sErweiterung := GetErweiterung;
sGeschwindigkeitseinheit := '
mm/s';
sBeschleunigungseinheit := '
mm/s';
if ftTischInfo[
Index].bVerfügbarkeit
then FLblStatusEinsatzbereitschaftAnzeige.Caption := '
ja'
else FLblStatusEinsatzbereitschaftAnzeige.Caption := '
nein';
FLblStatusAktuellePosAnzeige.Caption := Format('
%3.3f '+sErweiterung,[ftTischInfo[
Index].daktuellePosition]);
FLblStatusZielPosAnzeige.Caption := Format('
%3.3f '+sErweiterung,[ftTischInfo[
Index].dZielPosition]);
if ftTischInfo[
Index].bBewegtSich
then FLblStatusBewegungAnzeige.Caption := '
ja'
else FLblStatusBewegungAnzeige.Caption := '
nein';
FLdlEingabe.Caption := '
in ' + sErweiterung;
FLblStatusAktuelleGeschwindigkeitAnzeige.Caption := Format('
%3.3f '+sGeschwindigkeitseinheit, [Umrechnung_MicroSteps_in_mm(ftTischInfo[
Index].daktuelleGeschwindigkeit)]);
FLblStatusdefinierteGeschwindigkeitAnzeige.Caption := Format('
%3.3f '+sGeschwindigkeitseinheit, [Umrechnung_MicroSteps_in_mm(ftTischInfo[
Index].ddefinierteGeschwindigkeit)]);
FLblStatusAktuelleBeschleunigungAnzeige.Caption := Format('
%3.3f '+sBeschleunigungseinheit, [Umrechnung_MicroSteps_in_mm(ftTischInfo[
Index].daktuelleBeschleunigung)]);
FLblStatusdefinierteBeschleunigungAnzeige.Caption := Format('
%3.3f '+sBeschleunigungseinheit, [Umrechnung_MicroSteps_in_mm(ftTischInfo[
Index].ddefinierteBeschleunigung)]);
FLblStatusPotenzLabeldefBeschleunigung.Left := LabelPosition_anpassen(FLblStatusdefinierteBeschleunigungAnzeige);
FLblStatusPotenzLabelaktBeschleunigung.Left := LabelPosition_anpassen(FLblStatusAktuelleBeschleunigungAnzeige);
end;
procedure TTischsteuerung.Schrift_in_den_Vordergrund_bringen;
begin
FLblTrackBar.BringToFront;
FLblStatusCaption.BringToFront;
FLblStatusEinsatzbereitschaft.BringToFront;
FLblStatusEinsatzbereitschaftAnzeige.BringToFront;
FLbLStatusAktuellePos.BringToFront;
FLblStatusAktuellePosAnzeige.BringToFront;
FLblStatusZielPos.BringToFront;
FLblStatusZielPosAnzeige.BringToFront;
FLblStatusBewegung.BringToFront;
FLblStatusBewegungAnzeige.BringToFront;
FLblStatusAktuelleGeschwindigkeit.BringToFront;
FLblStatusAktuelleGeschwindigkeitAnzeige.BringToFront;
FLblStatusdefinierteGeschwindigkeit.BringToFront;
FLblStatusdefinierteGeschwindigkeitAnzeige.BringToFront;
FLblStatusAktuelleBeschleunigung.BringToFront;
FLblStatusAktuelleBeschleunigungAnzeige.BringToFront;
FLblStatusPotenzLabeldefBeschleunigung.BringToFront;
FCheckBoxAutomatisierung.BringToFront;
end;
{////////////////////////////////////////////////////////////////////////////////////}
{/ Kollisionsüberprüfung für die Verscheibetische /}
{////////////////////////////////////////////////////////////////////////////////////}
// Vorüberlegung:
// Die Überschneidung der beiden Tische wird der Komponente vom Hauptprogramm übergeben.
// Für den Piezoverschiebetisch ist der Verfahrweg dermaßen klein, dass davon ausgegangen
// werden kann, das dieser vernachlässigbar ist.
// Für die beiden anderen Verschiebetische muss jetzt festgestellt werden in wie weit,
// in Bezug auf die Zielposition des komplimentären Tisches, der Verfahrweg des aktuellen
// Verschiebetisches Eingeschränkt werden muss.
// Obere Grenze ist eigentlich die komplizierteste Rechnung, die es hier gibt. Es muss
// beachtet werden, dass je nach Bewegung der einzelnen Tische der Komplimentärtisch
// Einschränkungen erfährt. Die StandartWerte, die im Konstruktor gesetzt werden, sind
// als Maximalwerte zu sehen. Man sollte jetzt unterscheiden zwischen sich ändernden
// Werten und denen die im Allgemeinen immer gleich sind. Die obere Grenze beider Tische
// ist dabei ein sich ständig ändernder Wert. Die untere Grenze hingegen ist eine eher
// statische Komponente, welche immer ähnliche Werte behält.
function TTischsteuerung.GetobereGrenze: double;
const MaxWert = 100;
var Index, KomplimentIndex: integer;
dTempWertKomplimentTisch, dTempWertTisch: double;
begin
Index := GetIndex;
case Index of
1 : KomplimentIndex := 2;
2 : KomplimentIndex := 1;
3 : KomplimentIndex := 3;
end;
if KomplimentIndex
in [1..2]
then
begin
dTempWertKomplimentTisch := MaxWert - ftTischInfo[KomplimentIndex].dZielPosition;
dTempWertTisch := fdUeberschneidung - dTempWertKomplimentTisch;
if dTempWertTisch < 0
then result := 100
else result := MaxWert-dTempWertTisch;
end
else result := 100;
end;
// Die untere Grenze muss an sich nicht über eine gesonderte Prozedur oder Funktion gesetzt
// werden, da sie sich relativ statisch verhalten. Es sollte reichen die Werte im
// Konstruktor sinnvoll zu ändern.
{////////////////////////////////////////////////////////////////////////////////////}
{/ Hauptfunktion in dieser Komponente/ Initialisierung sämtlicher Komponenten /}
{////////////////////////////////////////////////////////////////////////////////////}
procedure TTischsteuerung.CreateWnd;
begin
inherited createWnd;
// Bildinitialisierung
FImageSelectionsBild := CreateImage(17,70,600,496);
// Labelinitialisierungen
FLblContainerCaption := CreateLabel(18,10, 21,'
Tischsteuerung', true);
FLblStatusCaption := CreateLabel(430, 350, 18, '
Tischstatus', true);
FLblStatusEinsatzbereitschaft := CreateLabel(450, 370, 14, '
einsatzbereit:', true);
FLblStatusEinsatzbereitschaftAnzeige := CreateLabel(555, 370, 14, '
', true);
FLblStatusAktuellePos := CreateLabel(450, 390, 14, '
aktuelle Position:', true);
FLblStatusAktuellePosAnzeige := CreateLabel(555, 390, 14, '
', true);
FLblStatusZielPos := CreateLabel(450, 410, 14, '
Zielposition:', true);
FLblStatusZielPosAnzeige := CreateLabel(555, 410, 14, '
', true);
FLblStatusBewegung := CreateLabel(450, 430, 14, '
bewegt sich:', true);
FLblStatusBewegungAnzeige := CreateLabel(555, 430, 14, '
', true);
FLblStatusAktuelleGeschwindigkeit := CreateLabel(450, 450, 14, '
aktuelle Geschw.:', true);
FLblStatusAktuelleGeschwindigkeitAnzeige := CreateLabel(555, 450, 14, '
', true);
FLblStatusdefinierteGeschwindigkeit := CreateLabel(450, 470, 14, '
defin. Geschw.:', false);
FLblStatusdefinierteGeschwindigkeitAnzeige := CreateLabel(555, 470, 14, '
', false);
FLblStatusdefinierteGeschwindigkeitAnzeige.OnClick := manuelleGeschwindigkeitsEingabe_aktivieren;
FLblStatusAktuelleBeschleunigung := CreateLabel(450, 490, 14, '
aktuelle Beschl.:', true);
FLblStatusAktuelleBeschleunigungAnzeige := CreateLabel(555,490, 14, '
', true);
FLblStatusdefinierteBeschleunigung := CreateLabel(450, 510, 14, '
defin. Beschl.:', false);
FLblStatusdefinierteBeschleunigungAnzeige := CreateLabel(555, 510, 14, '
', false);
FLblStatusdefinierteBeschleunigungAnzeige.OnClick := manuelleBeschleunigungsEingabe_aktivieren;
FLblStatusPotenzLabeldefBeschleunigung := CreateLabel(555, 510, 10, '
2', false);
FLblStatusPotenzLabelaktBeschleunigung := CreateLabel(450, 490, 10, '
2', true);
FLblTrackBar := CreateLabel(68 + round((320000/640000)*310),535,13,'
0,000 mm', true);
FLdlEingabe := CreateLabel(185, 602, 14, '
in mm', true);
// Trackbarinitialisierungen
FTrckBarTischposition := CreateTrackBar(68,555,340,20);
// Editinitialisierung
FEdPositionsEingabe := CreateEdit(74,600, 90, '
Wert eingeben', true);
FEdPositionsEingabe.OnEnter := Edit_leeren;
FEdmanuelleBeschleunigungsEingabe := CreateEdit(552, 507, 60, '
', false);
FEdmanuelleBeschleunigungsEingabe.OnKeyDown := manuelleBeschleunigungsEingabe_verlassen;
FEdmanuelleGeschwindigkeitsEingabe := CreateEdit(552, 467, 60, '
', false);
FEdmanuelleGeschwindigkeitsEingabe.OnKeyDown := manuelleGeschwindigkeitsEingabe_verlassen;
// Buttoninitialisierung
FButtonEditEingabe := CreateButton(230,595, 120, 30,'
Position ansteuern', true);
FButtonEditEingabe.OnClick := Position_ansteuern;
FButtonMoveLeft := CreateButton(158, 500, 30, 30, '
<', true);
FButtonMoveLeft.OnClick := MoveLeftStepWidth;
FButtonMoveRight := CreateButton(298, 500, 30, 30, '
>', true);
FButtonMoveRight.OnClick := MoveRightStepWidth;
FButtonmanuelleGeschwEingabe := CreateButton(650, 470, 80, 20, '
eingeben', false);
FButtonmanuelleGeschwEingabe.OnClick := Geschw_Beschl_eingeben_und_akzeptieren;
FButtonmanuelleBeschlEingabe := CreateButton(650, 510, 80, 20, '
eingeben', false);
FButtonmanuelleBeschlEingabe.OnClick := Geschw_Beschl_eingeben_und_akzeptieren;
// Comboboxinitialisierung
FCombBoxTischauswahl := CreateComboBox(17,35, 200);
FCombBoxTischauswahl.Items.Add('
Verschiebetisch Kamera/ Spleißgerät');
FCombBoxTischauswahl.Items.Add('
Verschiebetisch Referenzfaser');
FCombBoxTischauswahl.Items.Add('
Piezoverschiebetisch');
FCombBoxTischauswahl.ItemIndex := 0;
FCombBoxTischauswahl.OnChange := Tischaenderung;
FComboBoxStepWidth := CreateComboBox(210,505,70);
SetItemsComboBox(FComboBoxStepWidth);
FComboBoxStepWidth.OnChange := StepWidthAenderung;
// Nachbearbeitung, damit die richtigen Werte angezeigt und sichtbar sind
Schrift_in_den_Vordergrund_bringen;
Status_laden;
end;
end.