unit TTischsteuerungskomponente;
interface
uses Controls, StdCtrls, Windows, Graphics, Classes, ComCtrls, SysUtils, Dialogs,
ExtCtrls, ZahlEdit, MouseTrackBar;
// 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
TTischkomponente =
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,
//* Hier sollten noch weiter Anzeigen hinzukommen für reale/ gesetzte Geschwindigkeit
//* sowie Beschleunigung
FLdlEingabe: TLabel;
// Label für EingabeEdit
FEdPositionsEingabe: TZahlEdit;
// Edit das nur Ganze- und
// Gleitkommazahlen annimmt
FTrckBarTischposition: TMouseTrackBar;
// Trackbar das um die OnMouseDown
// OnMouseUp Ereignisse erweitert
// wurde
// Buttons (selbsterklärend)
FButtonEditEingabe, FButtonMoveLeft, FButtonMoveRight: TButton;
// Comboboxen Tischauswahl und Schrittweite
FCombBoxTischauswahl,FComboBoxStepWidth: TComboBox;
// Image für Bilddarstellung
FImageSelectionsBild: TImage;
// Paintbox für Pfeildarstellung
FPaintBoxTischAnzeige: TPaintbox;
// benötigte Variabeln für die Komponente
fdTischposition, fdZielposition: double;
// Double für aktuelle Tischposition
// 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.
//* Es muss eine Variable Enabled hinzugefügt werden, die die Komponente sperrt, wenn
//* ein Problem bei den Tischen auftritt und freigibt, wenn alle Tische verfügbar
//* sind
// 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
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
// Create-Funktion für alle verwendeten Komponenten
function CreateLabel(PosX, PosY, Textgroesse: integer; Text:
string): TLabel;
procedure CreateStatusLabel(PosX, PosY, Textgroesse: integer;
Name, Text:
string);
function CreateTrackBar(PosX,PosY, Width, Height:integer): TMouseTrackBar;
function CreateEdit(PosX, PosY: integer; Caption:
string): TZahlEdit;
function CreateButton(PosX, PosY, Width: integer; Caption:
string): TButton;
function CreateComboBox(PosX, PosY, Width: integer): TComboBox;
function CreateImage(PosX, PosY, Width, Height: integer): TImage;
// Verarbeitungsprozeduren
// 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);
// 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;
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;
//* Hier muss geprüft werden, ob es nicht mehr Sinn macht die Werte aller 3 Tische zu
//* übergeben. Die Frage ist einfach: Wo wird die Kollisionsprüfung durchgeführt?
//* sinnvoll wäre es die Kollisionsprüfung hier in der Komponente zu halten, da das
//* Hauptprogramm damit übersichtlicher bleibt.
//* Wenn die Kollisionskontrolle in der Komponente ausgeführt wird, reicht das ausgeben
//* der aktuellen Position des ausgewählten Tisches.
// 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;
//* Hier muss geprüft werden, ob es nicht mehr Sinn macht die Werte aller 3 Tische zu
//* übergeben. Die Frage ist einfach: Wo wird die Kollisionsprüfung durchgeführt?
//* sinnvoll wäre es die Kollisionsprüfung hier in der Komponente zu halten, da das
//* Hauptprogramm damit übersichtlicher bleibt.
//* Wenn die Kollisionsprüfung in der Komponente ausgeführt wir, dann muss die obere
//* Grenze nur ausgelesen werden. Das Setzen muss dannverhindert werden.
// ObereGrenze des ausgewählten Tisches
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;
end;
procedure Register;
{$R Darstellung.RES}
implementation
procedure Register;
begin
RegisterComponents('
Tischsteuerungskomponente', [TTischkomponente]);
end;
{////////////////////////////////////////////////////////////////////////////////////}
{/ Create-Funktionen /}
{////////////////////////////////////////////////////////////////////////////////////}
constructor TTischkomponente.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;
Color :=
RGB(240,240,250);
width := 650;
height := 700;
for i := 1
to 3
do
begin
if (i
in [1,2])
then
begin
ftTischInfo[i].iSchrittweitenIndex := 4;
ftTischInfo[i].dObereGrenze := 100;
ftTischInfo[i].dUntereGrenze := -100;
end
else
begin
ftTischInfo[i].iSchrittweitenIndex := 0;
ftTischInfo[i].dObereGrenze := 100;
ftTischInfo[i].dUntereGrenze := 0;
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;
//* Umarbeiten der Geschwindigkeit in m/s und m/s^2
//* geprüft muss noch werden, in welcher Variablenform(int oder double) dies an die
//* Maschine gesendet werden darf! Wenn die Eingabe auf m pro ... umgestellt wird
//* ist es trotzdem sinnvoll Double zu haben anstelle von Int um eine bessere Stufung
//* der Geschwindigkeit zu ermöglichen. Die Umrechnung in Int muss dann bei oder
//* nach der Übergabe in Hauptprogramm vorgenommen werden.
ftTischInfo[i].ddefinierteGeschwindigkeit := 1000.0;
// ist noch in Umdrehungen pro sec
ftTischInfo[i].ddefinierteBeschleunigung := 1000.0;
// ist ebenfalls immer noch in Umdrehungen pro sec^2
end;
bTrackBarMouseDown := false;
// Default-Wert setzen
end;
function TTischkomponente.CreateLabel(PosX, PosY, Textgroesse: integer; Text:
string): TLabel;
begin
result := TLabel.Create(Self);
result.Parent := Self;
result.Left := PosX;
result.Top := PosY;
result.Caption := Text;
result.Font.Height := Textgroesse;
end;
procedure TTischkomponente.CreateStatusLabel(PosX: Integer; PosY: Integer; Textgroesse: Integer;
Name:
string; Text:
string);
begin
{TLabel(Findcomponent(Name)) := CreateLabel(PosX, PosY, Textgroesse, Text);
FindComponent(Name+'Anzeige') := CreateLabel(PosX + 105, PosY, Textgroesse, ''); }
end;
function TTischkomponente.CreateTrackBar(PosX,PosY, Width, Height:integer): TMouseTrackBar;
begin
result := TMouseTrackbar.Create(Self);
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 TTischkomponente.CreateEdit(PosX, PosY: integer; Caption:
string): TZahlEdit;
begin
result := TZahlEdit.Create(Self);
result.Parent := Self;
result.Left := PosX;
result.Top := PosY;
result.Height := 20;
result.Width := 100;
result.Text := Caption;
result.OnEnter := Edit_leeren;
end;
function TTischkomponente.CreateButton(PosX, PosY, Width: integer; Caption:
string): TButton;
begin
result := TButton.Create(Self);
result.Parent := Self;
result.Left := PosX;
result.Top := PosY;
result.Caption := Caption;
result.Height := 30;
result.Width := Width;
end;
function TTischkomponente.CreateComboBox(PosX, PosY, Width: integer): TComboBox;
begin
result := TComboBox.Create(Self);
result.Parent := Self;
result.Left := PosX;
result.Top := PosY;
result.Height := 20;
result.Width := Width;
result.Clear;
end;
function TTischkomponente.CreateImage(PosX: Integer; PosY: Integer; Width: Integer; Height: Integer): Timage;
begin
result := TImage.Create(Self);
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;
{////////////////////////////////////////////////////////////////////////////////////}
{/ 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 TTischkomponente.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 TTischkomponente.Trackbarbewegung(Sender: TObject);
var Index, iAdditionsterm: integer;
sErweiterung:
string;
begin
Index := GetIndex;
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 TTischkomponente.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 TTischkomponente.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 TTischkomponente.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 TTischkomponente.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 TTischkomponente.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 TTischkomponente.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 TTischkomponente.SetTischPosition(Value: Double);
begin
fdTischposition := Value;
FTrckBarTischposition.Position := round(fdTischposition*6400);
end;
// Liest die aktuelle Tischposition aus der Variable fdTischposition
function TTischkomponente.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 TTischkomponente.GetIndex: integer;
begin
result := (FCombBoxTischauswahl.ItemIndex+1);
end;
// Ermittelt die benötigte Erweiterung (mm oder µm) für die dementsprechenden Anzeigen
function TTischkomponente.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 TTischkomponente.GetAdditionsterm: integer;
var Index: integer;
begin
Index := GetIndex;
if Index in [1,2]
then result := 50
else result := 0;
end;
function TTischkomponente.GetobereGrenze: double;
var Index: integer;
begin
Index := GetIndex;
result := ftTischInfo[
Index].dobereGrenze;
end;
function TTischkomponente.GetuntereGrenze: double;
var Index: integer;
begin
Index := GetIndex;
result := ftTischInfo[
Index].duntereGrenze;
end;
function TTischkomponente.GetdefinierteGeschwindigkeit;
var Index: integer;
begin
Index := GetIndex;
result := ftTischInfo[
Index].ddefinierteGeschwindigkeit;
end;
function TTischkomponente.GetdefinierteBeschleunigung;
var Index: integer;
begin
Index := GetIndex;
result := ftTischInfo[
Index].ddefinierteBeschleunigung;
end;
procedure TTischkomponente.SetaktuelleGeschwindigkeit(dWert: double);
var Index: integer;
begin
Index := GetIndex;
ftTischInfo[
Index].daktuelleGeschwindigkeit := dWert;
end;
procedure TTischkomponente.SetaktuelleBeschleunigung(dWert: Double);
var Index: integer;
begin
Index := GetIndex;
ftTischInfo[
Index].daktuelleBeschleunigung := dWert;
end;
procedure TTischkomponente.Setverfügbarkeit(bWert: Boolean);
var Index: integer;
begin
for Index :=1
to 3
do ftTischInfo[
Index].bVerfügbarkeit := bWert;
end;
function TTischkomponente.GetZielPosition;
var Index: integer;
begin
Index := GetIndex;
result := ftTischInfo[
Index].dZielPosition;
end;
procedure TTischkomponente.SetOnChangeEvent;
begin
if assigned(OnChange)
then OnChange;
end;
procedure TTischkomponente.SetOnTrackBarMouseDownEvent;
begin
if assigned(OnTrackBarMouseDown)
then OnTrackBarMouseDown;
end;
procedure TTischkomponente.SetOnTrackBarMouseUpEvent;
begin
if assigned(OnTrackBarMouseUp)
then OnTrackBarMouseUp;
end;
{////////////////////////////////////////////////////////////////////////////////////}
{/ Anpassen der Komponenten bei Änderung des ausgewählten Tisches /}
{////////////////////////////////////////////////////////////////////////////////////}
procedure TTischkomponente.DarstellungTischAuswahl(
Index: Integer);
begin
case Index of
1:
begin FImageSelectionsBild.Picture.Bitmap.LoadFromResourceName(HInstance, '
BILD1');
end;
2:
begin FImageSelectionsBild.Picture.Bitmap.LoadFromResourceName(HInstance, '
BILD2');
end;
3:
begin FImageSelectionsBild.Picture.Bitmap.LoadFromResourceName(HInstance, '
Bild3');
end;
end;
end;
procedure TTischkomponente.Komponenten_einstellen(
Index: Integer);
var iAdditionsterm: integer;
begin
iAdditionsterm := GetAdditionsterm;
FTrckBarTischposition.Position := round((ftTischInfo[
Index].dZielPosition +iAdditionsterm) * 6400);
end;
procedure TTischkomponente.Komp_laden(
Index: integer);
begin
SetItemsComboBox(FComboBoxStepWidth);
Status_laden;
Komponenten_einstellen(
Index);
end;
procedure TTischkomponente.Komponentenanpassung(
Index: Integer);
begin
// Bilddarstellung laden
DarstellungTischauswahl(
Index);
// Position auslesen für angezeigten Tisch
// Zielposition für angezeigten Tisch
Komp_laden(
Index);
end;
procedure TTischkomponente.Tischaenderung(Sender: TObject);
begin
case FCombBoxTischauswahl.ItemIndex
of
0: Komponentenanpassung(1);
1: Komponentenanpassung(2);
2: Komponentenanpassung(3);
end;
end;
{////////////////////////////////////////////////////////////////////////////////////}
{/ Anpassen der Combobox FComboBoxStepWidth /}
{////////////////////////////////////////////////////////////////////////////////////}
procedure TTischkomponente.StepWidthAenderung(Sender: TObject);
var Index: integer;
begin
Index := GetIndex;
ftTischInfo[
Index].iSchrittweitenIndex := FComboBoxStepWidth.ItemIndex;
end;
procedure TTischkomponente.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[GetIndex].iSchrittweitenIndex;
end;
{////////////////////////////////////////////////////////////////////////////////////}
{/ Prozeduren für die Statusanzeige /}
{////////////////////////////////////////////////////////////////////////////////////}
procedure TTischkomponente.Status_laden;
var Index, iAdditionsterm: integer;
sErweiterung, sGeschwindigkeitseinheit, sBeschleunigungseinheit:
string;
begin
Index := GetIndex;
sErweiterung := GetErweiterung;
sGeschwindigkeitseinheit := '
U/s';
sBeschleunigungseinheit := '
U/s^2';
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, [ftTischInfo[
Index].daktuelleGeschwindigkeit]);
FLblStatusdefinierteGeschwindigkeitAnzeige.Caption := Format('
%3.3f '+sGeschwindigkeitseinheit, [ftTischInfo[
Index].ddefinierteGeschwindigkeit]);
FLblStatusAktuelleBeschleunigungAnzeige.Caption := Format('
%3.3f '+sBeschleunigungseinheit, [ftTischInfo[
Index].daktuelleBeschleunigung]);
FLblStatusdefinierteBeschleunigungAnzeige.Caption := Format('
%3.3f '+sBeschleunigungseinheit, [ftTischInfo[
Index].ddefinierteBeschleunigung]);
end;
procedure TTischkomponente.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;
end;
{////////////////////////////////////////////////////////////////////////////////////}
{/ Hauptfunktion in dieser Komponente/ Initialisierung sämtlicher Komponenten /}
{////////////////////////////////////////////////////////////////////////////////////}
procedure TTischkomponente.CreateWnd;
begin
inherited createWnd;
// Labelinitialisierungen
FLblContainerCaption := CreateLabel(18,10, 21,'
Tischsteuerung');
FLblStatusCaption := CreateLabel(430, 450, 18, '
Tischstatus');
FLblStatusEinsatzbereitschaft := CreateLabel(450, 470, 14, '
einsatzbereit:');
FLblStatusEinsatzbereitschaftAnzeige := CreateLabel(555, 470, 14, '
');
//CreateStatusLabel(450, 470, 14, 'FLblStatusEinsatzbereitschaft', 'einsatzbereit:');
FLblStatusAktuellePos := CreateLabel(450, 490, 14, '
aktuelle Position:');
FLblStatusAktuellePosAnzeige := CreateLabel(555, 490, 14, '
');
FLblStatusZielPos := CreateLabel(450, 510, 14, '
Zielposition:');
FLblStatusZielPosAnzeige := CreateLabel(555, 510, 14, '
');
FLblStatusBewegung := CreateLabel(450, 530, 14, '
bewegt sich:');
FLblStatusBewegungAnzeige := CreateLabel(555, 530, 14, '
');
FLblStatusAktuelleGeschwindigkeit := CreateLabel(450, 550, 14, '
aktuelle Geschw.:');
FLblStatusAktuelleGeschwindigkeitAnzeige := CreateLabel(555, 550, 14, '
');
FLblStatusdefinierteGeschwindigkeit := CreateLabel(450, 570, 14, '
defin. Geschw.:');
FLblStatusdefinierteGeschwindigkeitAnzeige := CreateLabel(555, 570, 14, '
');
FLblStatusAktuelleBeschleunigung := CreateLabel(450, 590, 14, '
aktuelle Beschl.:');
FLblStatusAktuelleBeschleunigungAnzeige := CreateLabel(555,590, 14, '
');
FLblStatusdefinierteBeschleunigung := CreateLabel(450, 610, 14, '
defin. Beschl.:');
FLblStatusdefinierteBeschleunigungAnzeige := CreateLabel(555, 610, 14, '
');
FLblTrackBar := CreateLabel(68 + round((320000/640000)*310),605,13,'
0,000 mm');
FLdlEingabe := CreateLabel(185, 657, 14, '
in mm');
// Trackbarinitialisierungen
FTrckBarTischposition := CreateTrackBar(68,620,340,20);
// Editinitialisierung
FEdPositionsEingabe := CreateEdit(74,655, '
Wert eingeben');
// Buttoninitialisierung
FButtonEditEingabe := CreateButton(230,650, 120,'
Position ansteuern');
FButtonEditEingabe.OnClick := Position_ansteuern;
FButtonMoveLeft := CreateButton(158, 570, 30, '
<');
FButtonMoveLeft.OnClick := MoveLeftStepWidth;
FButtonMoveRight := CreateButton(298, 570, 30, '
>');
FButtonMoveRight.OnClick := MoveRightStepWidth;
// 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,575,70);
SetItemsComboBox(FComboBoxStepWidth);
FComboBoxStepWidth.OnChange := StepWidthAenderung;
// Bildinitialisierung
FImageSelectionsBild := CreateImage(17,70,600,496);
// Nachbearbeitung, damit die richtigen Werte angezeigt und sichtbar sind
Schrift_in_den_Vordergrund_bringen;
Status_laden;
end;
end.