AL_MotorLPT

Top  Previous  Next

 

{ TSTMotors      : x,y léptetőmotorokat és megmunkálást az LPTn porton keresztűl

                  vezérlő DELPHI 5.0 komponens.

                  (Plazmavágóhoz és régi vezérláshez)

 

Szerző        :  Agócs László - StellaSOFT

                  2012.

}

 

unit AL_MotorLPT;

 

interface

 

uses

Windows,Classes,SysUtils,Controls,StdCtrls,ExtCtrls,Graphics,Forms,Dialogs,

AL_Paper,IODllUnit,Szamok,NewGeom;

 

Type

 

TLPTPort = (LPT1,LPT2,LPT3);

SLPTPorts = Set of TLPTPort;

 

TMotorMethod    = (mmOld,mmNew);

 

TMoveOption     = (moAuto, moManual);        {Mozgatási mód:auto vagy kézi}

TSebessegOption = (soNone, soQuick, soWork); {Gyors vagy lassú a mozgás}

TStepDirection  = (sdNone, sdPoz, sdNeg);    {A mozgás iránya: + vagy -}

 

   {Gyártási mód:

      Tesztmód   = wmTest : csak szimulálja a gyártást, de a motorok nem mozognak;

      Vágási mód = wmCut  : a pozícionálások kivételével a fejet leengedi és vág;

      Gravir mód = wmGravir : Gravírozás során a fej magassága folyamatosan változtatható;

      Plazma mód = wmPlazma : Plazma vágás esetán bekezdési pontokon átfúvás

   }

TWorkingMode    = (wmTest, wmCut, wmGravir, wmPlazma);

 

TFactoryConfig = record

Demo          : boolean;        {Demó verzió = True}

Belepett      : word;           {Ennyiszer lépett be a programba}

UtolsoBelepes : TDateTime;      {Utolsó belépés dátuma}

Uzemido       : TDateTime;      {Teljes üzemeltetés : GÉP ÖSSZ. MUNKAIDEJE}

MotorMethod   : TMotorMethod;   {mmOldSty=Régi; mmNewStyle=Uj motor vezérlő algoritmus}

globaldir     : String[120];    {Config és catalógus és INI file könyvtára}

localdir      : String[120];    {Sablon könyvtár}

filenev       : String[120];    {Utoljára megnyitott Sablon file}

Paper         : TPoint;         {Rajzlap méretei}

PaperFont     : TFont;

ForeColor     : TColor;         {Rajzlap alapszine}

BackColor     : TColor;         {Rajzlapon kívüli terület alapszine}

 

LPT           : byte;           {LPT port kiválasztás}

MMPerSec      : real;           {Vágási sebesség mm/sec}

LepesX        : real;           {X léptetőmotor mm/1 léptetés}

LepesY        : real;           {Y léptetőmotor mm/1 léptetés}

LepesZ        : real;           {Z léptetőmotor mm/1 léptetés}

WorkSebesseg  : integer;        {Megmunkálási sebesség = 1..50}

PosSebesseg   : integer;        {Pozícionálási sebesség = 1..50}

Precizio      : integer;        {Tizedesek száma}

ActPosition   : TPoint3d;       {Utolsó aktuális pozíció}

Kiemeles      : integer;        {A fej kiemelése [leptetes_szám]}

KesleltetesMIN: longint;        {A léptetőmotorok min. késleltetése}

KesleltetesMINz: longint;       {A Z léptetőmotor min. késleltetése}

WorkingMode   : byte;           {0=teszt,1=Vágás,2=Glavírozáa}

NegativHead   : integer;        {1=pozítív; -1=negatív fejmozgás z-ben}

Correction    : real;           {0=kontúron; <0=belül; >0=kívül;

                                  értéke = a vágóél sugara}

DelayCorrection: real;          // Szorzó a késleltetésekhez

TimeCorrection: Array[1..40] of Double; // Időkorrekciók a sebességekhez

PlazmaMachine : boolean;        // True=Plazmavágó; False=Plasticut

FireTime      : integer;        // Átfúvás ideje bekezdési pontokon

PlazmaIndex   : integer;        // A TimePlazma tömb aktuális indexe

TimePlazma    : Array[0..9,0..1] of Double; // Átfúvási Idők plazma vágókhoz

VegallasEnabled: boolean;       // Vegye-e figyelembe a végállás kapcsolókat

Down          : boolean;        // True=bal alsó sarok, False=Bal felső sarok

                                 //   a kezdőpont

Dummy         : Array[1..128] of byte;

end;

 

TActPositionChangeEvent = procedure(Sender: TObject; ActPosition : TPoint3D) of object;

TWorkOnOffChangeEvent = procedure(Sender: TObject; WorkOn : boolean) of object;

TPillanatAlljChangeEvent = procedure(Sender: TObject; All : boolean) of object;

TWorkingModeChangeEvent = procedure(Sender: TObject; WorkMode : TWorkingMode) of object;

TWorkTimeChangeEvent = procedure(Sender: TObject; WorkTime: double) of object;

TWorkWayChangeEvent = procedure(Sender: TObject; WorkWay: extended) of object;

TSTOPEvent = procedure(Sender: TObject; IsSTOP: boolean) of object;

TOverRunEvent = procedure(Sender: TObject; x0,x1,y0,y1:boolean) of object;

THeadStatusEvent = procedure(Sender: TObject; Down : boolean) of object;

TLineOk = procedure(Sender: TObject; LineTempareture : integer; LineBreak: boolean) of object;

TSzakadasEvent = procedure(Sender: TObject; Break : boolean) of object;

 

  THRTimer = Class(TObject)

    Constructor Create;

    Function StartTimer : Boolean;

    Function ReadTimer : Double;

  public

    Exists    : Boolean;

    StartTime : Double;

    ClockRate : Double;

    PROCEDURE Delay(ms: double);

  End;

 

TSTMotors = class(TComponent)

private

   FActPosition: TPoint3D;

   FWorkingMode: TWorkingMode;

   FOnActPosition: TActPositionChangeEvent;

   FPillanatAlljEvent: TPillanatAlljChangeEvent;

   FOnWorkingMode: TWorkingModeChangeEvent;

   FOnWorkOnOff: TWorkOnOffChangeEvent;

   FWorkTime: TWorkTimeChangeEvent;

   FWorkWay: TWorkWayChangeEvent;

   FSablonImage: TALSablon;

   FLPTPort: TLPTPort;

   FMMPerLepesY: extended;

   FMMPerLepesX: extended;

   FMMPerLepesZ: extended;

   fPillanatAllj: boolean;

   FWorkOn: boolean;

   FFolytonosVagas: boolean;

   FHeadStatus: boolean;

   FSTOP: boolean;

   FLapmeretHEIGHT: integer;

   FKiemeles: integer;

   FActPosPrecision: integer;

   FQuickVelocity: integer;

   FNegativHead: integer;

   FLapmeretWIDTH: integer;

   FWorkVelocity: integer;

   FSebesseg: integer;

   FkesleltetesMINz: longint;

   FkesleltetesMIN: longint;

   FActPositionLabel: TLabel;

   FMoveOption: TMoveOption;

   FSebessegOption: TSebessegOption;

   fCorrection: extended;

   fSablonSzinkron: boolean;

   fOverRunEvent: TOverRunEvent;

   fSTOPx0: boolean;

   fSTOPx1: boolean;

   fSTOPy0: boolean;

   fSTOPy1: boolean;

   FWorkingEnable: boolean;

   fSTOPEvent: TSTOPEvent;

   fIsMachine: boolean;

   FDelayCorrection: real;

   FHeadStatusChange: THeadStatusEvent;

   fMotorMethod: TMotorMethod;

   FLineTemperature: integer;

   FLineOk: TLineOk;

   FSzakadas: boolean;

   FSzakadasEvent: TSzakadasEvent;

   FSzakadasVolt: boolean;

   FDownUp: boolean;

   FVegallasEnabled: boolean;

   procedure SetActPosition(const Value: TPoint3D);

   procedure SetWorkingMode(const Value: TWorkingMode);

   procedure SetSablonImage(const Value: TALSablon);

   procedure SetLPTPort(const Value: TLPTPort);

   procedure SetActPositionLabel(const Value: TLabel);

   procedure SetkesleltetesMIN(const Value: longint);

   procedure SetLapmeretHEIGHT(const Value: integer);

   procedure SetLapmeretWIDTH(const Value: integer);

   procedure SetPillanatAllj(const Value: boolean);

   procedure SetQuickVelocity(const Value: integer);

   procedure SetSebesseg(const Value: integer);

   procedure SetSebessegOption(const Value: TSebessegOption);

   procedure SetSTOP(const Value: boolean);

   procedure SetWorkOn(const Value: boolean);

   procedure SetWorkVelocity(const Value: integer);

   procedure SetActPosPrecision(const Value: integer);

   procedure SetMMPerLepesX(const Value: extended);

   procedure SetMMPerLepesY(const Value: extended);

   procedure SetMMPerLepesZ(const Value: extended);

   procedure SetkesleltetesMINz(const Value: longint);

   procedure SetKiemeles(const Value: integer);

   procedure SetNegativHead(const Value: integer);

   procedure SetCorrection(const Value: extended);

   procedure SetSablonSzinkron(const Value: boolean);

   procedure SetOverRun(const Index: Integer; const Value: boolean);

   procedure SetWorkingEnable(const Value: boolean);

   procedure Timer(Sender:TObject);

   procedure setIsMachine(const Value: boolean);

   procedure SetHeadStatus(const Value: boolean);

   procedure SetMotorMethod(const Value: TMotorMethod);

   procedure SetLineTemperature(const Value: integer);

   procedure SetSzakadas(const Value: boolean);

   procedure Heating(LTemp: integer);

   procedure SetSzakadasVolt(const Value: boolean);

   procedure SetDownUp(const Value: boolean);

   procedure SetVegallasEnabled(const Value: boolean);

protected

   alfa : extended;               {Az aktuális mozgás iránya radiánban}

   H_Next,V_Next,Z_Next: integer;        {Vizszintes,függőleges számláló léptetéshez}

   ora : TTimer;

public

   demo            : boolean;            {Demonstrációs program}

   FactoryConfig   : TFactoryConfig;

   _LPT            : Word;               {LPT port fizikai címe}

   HRT             : THRTimer;           // Precíz időzítő

   toll            : boolean;            {Toll lent=True, fent=False}

   oldActPosition  : TPoint3d;           {Régi aktuális pozíció}

   SourcePosition  : TPoint3D;

   DestPosition    : TPoint3D;

   kesleltetes,Quickkesleltetes,Workkesleltetes : double;

   StepDirectionX  : TStepDirection;    {Az X tengely mentén mozgás iránya}

   StepDirectionY  : TStepDirection;    {Az Y tengely mentén mozgás iránya}

   StepDirectionZ  : TStepDirection;    {Az Z tengely mentén mozgás iránya}

   StepX,StepY     : longint;           {x,y irányú lépések száma}

   WorkTime        : double;            {Gyártási idő msec}

   WorkTimePerMM   : double;            {1 mm hossz gyártási ideje}

   constructor Create(AOwner:TComponent);override;

   destructor Destroy;override;

 

   procedure MoutInit;

   Procedure Mout( Out_Val:Byte);

   procedure MoutPlasma(XDir,YDir:integer);

   Procedure Pen_On;

   Procedure Pen_Off;

   Procedure Pen_down;

   Procedure Pen_Up;

   Procedure HeadUp;

   Procedure HeadDown;

   Procedure Up;

   Procedure Down;

   Procedure Left;

   Procedure Right;

   procedure Wait;

   procedure WaitTime(sec:integer);

     {Fej relatív mozgatása: dz>0 felfelé; dz<0 lefelé dz számú lépéssel}

   procedure LoopZ(dz:integer);

     {Fej abszolut mozgatása z[mm] pozícióba}

   procedure GoHead(z:extended);

   procedure VekOut(dx,dy:extended;PENDOWN:boolean);

   Procedure GotoNullPosition;

   Function GotoXYPosition(x,y:extended) : boolean;

   procedure GotoAbsolutNullPosition;

   procedure TotalWorking;

   procedure WorkingFromPoint(ap:longint);

   procedure Working(AObject,AItem:integer);

       {Van-e gép?}

   function GetMachine:boolean;

       {VészSTOP-ot nyomtak-e?}

   function GetSTOP:boolean;

       {Végállások lekérdezése}

   procedure GetOverRun;

   function GetTotalWorkWay:double;

 

   {A STFACTORY32.FAC konf. fileba menti ill. betölti a

    FactoryConfig rekordot}

   procedure ConfigInit;

   Function ConfigLoad(iFileNev:string):boolean;

   Function ConfigSave(iFileNev:string):boolean;

   procedure FactoryDefaultSave;

   procedure FactoryDefaultLoad;

 

   Property IsMachine: boolean read fIsMachine write setIsMachine;

   Property ActPosition : TPoint3D read FActPosition write SetActPosition;

   Property LepesX : extended read FMMPerLepesX ;

   Property LepesY : extended read FMMPerLepesY ;

   Property LepesZ : extended read FMMPerLepesZ ;

   Property STOPx0 : boolean index 1 read fSTOPx0 write SetOverRun;

   Property STOPx1 : boolean index 2 read fSTOPx1 write SetOverRun;

   Property STOPy0 : boolean index 3 read fSTOPy0 write SetOverRun;

   Property STOPy1 : boolean index 4 read fSTOPy1 write SetOverRun;

   {Gyártási úthossz mm}

   Property TotalWorkWay : double read GetTotalWorkWay;

   property Szakadas: boolean read FSzakadas write SetSzakadas default False;

   property SzakadasVolt : boolean read FSzakadasVolt write SetSzakadasVolt;

published

   Property LPTPort : TLPTPort read FLPTPort write SetLPTPort;

   property MotorMethod: TMotorMethod read fMotorMethod write SetMotorMethod;

   Property SablonImage : TALSablon read FSablonImage write SetSablonImage;

   Property ActPositionLabel : TLabel read FActPositionLabel write SetActPositionLabel;

   Property ActPosPrecision : integer read FActPosPrecision write SetActPosPrecision;

   Property FolytonosVagas : boolean read FFolytonosVagas write FFolytonosVagas;

   Property KesleltetesMIN : longint read FkesleltetesMIN write SetkesleltetesMIN;

   Property KesleltetesMINz : longint read FkesleltetesMINz write SetkesleltetesMINz;

   Property LapmeretHEIGHT : integer read FLapmeretHEIGHT write SetLapmeretHEIGHT;

   Property LapmeretWIDTH : integer read FLapmeretWIDTH write SetLapmeretWIDTH;

   Property LineTemperature: integer read FLineTemperature write SetLineTemperature;

   // Szál hőmérséklet: 0=Kikapcsolva; 1: alacsony hőfok 2>=Magas vágási hőfok

   Property MMPerLepesX : extended read FMMPerLepesX write SetMMPerLepesX ;

   Property MMPerLepesY : extended read FMMPerLepesY write SetMMPerLepesY ;

   Property MMPerLepesZ : extended read FMMPerLepesZ write SetMMPerLepesZ ;

   Property QuickVelocity : integer read FQuickVelocity write SetQuickVelocity;

   Property WorkVelocity : integer read FWorkVelocity write SetWorkVelocity;

   Property Sebesseg : integer read FSebesseg write SetSebesseg default 1;

   Property MoveOption : TMoveOption read FMoveOption write FMoveOption;

   Property SebessegOption : TSebessegOption read FSebessegOption

                           write SetSebessegOption;

   Property Kiemeles : integer read FKiemeles write SetKiemeles;

   Property HeadStatus : boolean read FHeadStatus write SetHeadStatus;

   Property NegativHead : integer read FNegativHead write SetNegativHead;

       {VÉSZSTOP : True -> Working, WorkOn = False}

   Property STOP : boolean read FSTOP write SetSTOP;

       {Pillanatállj : True -> Working=True; WorkOn=False}

   Property PillanatAllj : boolean read fPillanatAllj write SetPillanatAllj;

       {Gyártás engedélyezett = True}

   property VegallasEnabled: boolean read FVegallasEnabled write SetVegallasEnabled;

   Property WorkingEnable : boolean read FWorkingEnable write SetWorkingEnable;

       {Gyártás folyamatban = True; WorkigMode<>wmTest esetén}

   Property WorkOn : boolean read FWorkOn write SetWorkOn;

       {Gyártási mód : wmTest, wmCut, wmGravir}

   Property WorkingMode : TWorkingMode read FWorkingMode write SetWorkingMode;

   Property Correction: extended read fCorrection write SetCorrection;

   property SablonSzinkron: boolean read fSablonSzinkron write SetSablonSzinkron;

   property DelayCorrection: real read FDelayCorrection write fDelayCorrection;

   // Kezdési pont alúl vagy fölül

   property DownUp: boolean read FDownUp write SetDownUp default True;

   Property OnActPosition : TActPositionChangeEvent read FOnActPosition write FOnActPosition;

   Property OnWorkOnOff : TWorkOnOffChangeEvent read FOnWorkOnOff write FOnWorkOnOff;

   Property OnWorkingMode : TWorkingModeChangeEvent read FOnWorkingMode write FOnWorkingMode;

   Property OnWorkTimeChangeEvent : TWorkTimeChangeEvent read FWorkTime

            write FWorkTime;

   Property OnWorkWayChangeEvent : TWorkWayChangeEvent read FWorkWay

            write FWorkWay;

   Property OnPillanatAllj : TPillanatAlljChangeEvent read FPillanatAlljEvent

            write FPillanatAlljEvent;

   Property OnOverRun: TOverRunEvent read fOverRunEvent write fOverRunEvent;

   property OnSTOP: TSTOPEvent read fSTOPEvent write fSTOPEvent;

   property OnHeadStatusChange: THeadStatusEvent read FHeadStatusChange write FHeadStatusChange;

   property OnLineOk: TLineOk read FLineOk write FLineOk;

   property OnSzakadasEvent : TSzakadasEvent read FSzakadasEvent write FSzakadasEvent;

end;

 

procedure Register;

 

function Point2D(X, Y : double): TPoint2D;

function Point3D(X, Y, Z: double): TPoint3D;

 

CONST   TLPTPortName : Array[1..3] of String[4]= ('LPT1','LPT2','LPT3');

       MOTTAB:  Array[0..7] of Byte = ($27,$2D,$1C,$0D,$03,$09,$38,$29);

 

Var     MotorConstans : extended;

       LPTBazis : byte absolute $408;

 

implementation

 

procedure Register;

begin

RegisterComponents('AL',[TSTMotors]);

end;

 

function Point2D(X, Y: double): TPoint2D;

begin

Point2D.X := X;

Point2D.Y := Y;

end;

 

function Point3D(X, Y, Z: double): TPoint3D;

begin

Point3D.X := X;

Point3D.Y := Y;

Point3D.Z := Z;

end;

 

// ---- a FactoryConfig rekordot alapértékekkel tölti fel -----

procedure TSTMotors.ConfigInit;

begin

end;

 

Function TSTMotors.ConfigLoad(iFileNev:string):boolean;

var resu: integer;

   f : file;

begin

Try

If FileExists(iFileNev) then begin

   Try

    AssignFile(f,iFileNev);

    Reset(f,1);

    BlockRead(f,FactoryConfig,Sizeof(FactoryConfig),Resu);

    Result:=True;

   finally

    CloseFile(f);

   end;

end else Result:=False;

except

    Result:=False;

end;

end;

 

Function TSTMotors.ConfigSave(iFileNev:string):boolean;

var resu: integer;

   f : file;

   s: string;

begin

Try

    Result:=True;

    {$I-}

    AssignFile(f,iFileNev);

    Rewrite(f,1);

    s:=FactoryConfig.filenev;

    BlockWrite(f,FactoryConfig,Sizeof(FactoryConfig),Resu);

    CloseFile(f);

    {$I+}

except

    Result:=False;

end;

end;

 

//-----------THRTimer-----------------

 

Constructor THRTimer.Create;

Var QW : _Large_Integer;

BEGIN

  Inherited Create;

  Exists := QueryPerformanceFrequency(TLargeInteger(QW));

  ClockRate := QW.QuadPart;

END;

 

Function THRTimer.StartTimer : Boolean;

Var

QW : _Large_Integer;

BEGIN

  Result := QueryPerformanceCounter(TLargeInteger(QW));

  StartTime := QW.QuadPart;

END;

 

Function THRTimer.ReadTimer : Double;

Var

ET : _Large_Integer;

BEGIN

  QueryPerformanceCounter(TLargeInteger(ET));

  Result := 1000.0*(ET.QuadPart - StartTime)/ClockRate;

END;

 

PROCEDURE THRTimer.Delay(ms: double);

Var

QW,ET : _Large_Integer;

Start_Time, dt : double;

BEGIN

  QueryPerformanceCounter(TLargeInteger(QW));

  Start_Time := QW.QuadPart;

  repeat

        QueryPerformanceCounter(TLargeInteger(ET));

        dt := 1000.0*(ET.QuadPart - Start_Time)/ClockRate;

  Until dt>=ms;

END;

 

 

 

{ TSTMotors }

 

constructor TSTMotors.Create(AOwner: TComponent);

begin

inherited;

    DecimalSeparator:='.';

    HRT:=THRTimer.Create;

    ora := TTimer.Create(Self);

    ora.Interval := 100;

    ora.OnTimer := Timer;

    MoutInit;

    demo             := False;

    fMotorMethod     := mmNew;

    FPillanatAllj    := False;

    FkesleltetesMIN  := 5000;

    FkesleltetesMINz := 5000;

 

    FMMPerLepesX     := MotorConstans;

    FMMPerLepesY     := MotorConstans;

    FMMPerLepesZ     := MotorConstans;

 

    FActPosition     := Point3D(0,0,0);

    oldActPosition   := Point3D(-100,-100,0);

 

    FActPosPrecision := 0;

    FWorkingMode     := wmTest;

    FWorkVelocity    := 50;

    FQuickVelocity   := 100;

    Fworkingenable   := True;

    FWorkOn          := False;

    FFolytonosVagas  := False;

    StepX            := 0;

    StepY            := 0;

    H_Next           := 0;

    V_Next           := 0;

    Z_Next           := 0;

    FLPTPort          := LPT1;

    FKiemeles         := 100;

    FHeadStatus       := False;

    FNegativHead      := 1;

    WorkTime         := 0;

    WorkTimePerMM    := 0;

    FCorrection       := 0;

    fSTOPx0          := True;

    fSTOPx1          := True;

    fSTOPy0          := True;

    fSTOPy1          := True;

    pen_off;

    fIsMachine := True;

    fDelayCorrection := 1;

    fSablonSzinkron  := False;

    fDownUp          := True;

    FSzakadasVolt := False;

    FSzakadas := False;

    LineTemperature:=0;       // kikapcsolva

    VegallasEnabled:=True;

end;

 

destructor TSTMotors.Destroy;

begin

ora.Free;

HRT.Free;

inherited;

end;

 

procedure TSTMotors.Timer(Sender:TObject);

begin

   GetOverrun;

   IsMachine:=GetMachine;

end;

 

(*---------- KIEGÉSZITŐ RUTINOK ----------*)

 

procedure TSTMotors.SetLPTPort(const Value: TLPTPort);

begin

    FLPTPort := Value;

    Case Value of

    LPT1: _LPT:=$378;

    LPT2: _LPT:=$379;

    LPT3: _LPT:=$37A;

    end;

    FactoryConfig.LPT := Ord(Value);

end;

 

function TSTMotors.GetMachine:boolean;

Var _STB : word;

    _STA : word;

    statusByte : byte;

    kesz       : byte;

    k          : integer;

begin

_STB := _LPT +2;

_STA := _LPT +1;

PortOut(_STB,4);

k := 0;

PortOut(_STB,8);

repeat

   statusByte := PortIn(_STA);

   kesz       := statusByte AND 8;

   Inc(k);

   Application.ProcessMessages;

Until (kesz=8) or (k=12000);

statusByte := PortIn(_STA);

Result := statusByte<16;

PortOut(_STB,0);

end;

 

procedure TSTMotors.Mout(Out_Val: Byte);

Var _STB : word;

    statusByte : byte;

    kesz       : byte;

    vegallas   : byte;

    veSTOP     : byte;

    k          : integer;

begin

{Demó és Test módban nincs motorvezérlés}

If (not demo) and (WorkingMode<>wmTest) {and not GetSTOP} then begin

   _STB := _LPT +2;

   If IsDriverInstalled then begin

      PortOut(_LPT,Out_Val);

      // hA RELÉ BEHÚZVA AKKOR NEM 2, HANEM 5 (3. bitet billenteni)

      if not HeadStatus then PortOut(_STB,1)

      else PortOut(_STB,5);

      // hA RELÉ BEHÚZVA AKKOR NEM 2, HANEM 4 (3. bitet billenteni)

      if not HeadStatus then PortOut(_STB,0)

      else PortOut(_STB,4);

   end;

(*       {Végállás lekérdezés}

       _STB := _LPT +2;

       _STA := _LPT +1;

      k := 0;

      PortOut(_STB,2);

      Application.ProcessMessages;

      repeat

       Application.ProcessMessages;

       statusByte := PortIn(_STA);

       kesz       := statusByte AND 8;

       Inc(k);

      Until (kesz=8) or (k>32000);

      vegallas := PortIn(_STA);

      {Felső 4 bit jelzi a végállásokat: 11110000 alapesetben

       4. x0; 5. x1; 6. y0; 7. y1 -> bit=0 végállás}

      STOPx0   := (vegallas and 16)<>16;

      STOPx1   := (vegallas and 32)<>32;

      STOPy0   := (vegallas and 64)<>64;

      STOPy1   := (vegallas and 128)<>128;

      PortOut(_STB,0);*)

end;

end;

 

// Motor inicializálás: absolut null pozícióba mozgatás

procedure TSTMotors.MoutInit;

Var _LPT : word;

begin

   If IsDriverInstalled then begin

//       PortOut(_LPT,0);

//       PortOut(_STB+1,0);

//       PortOut(_STB+2,0);

//       GotoAbsolutNullPosition;

   end;

end;

 

// Plazma vágó MSD-70-4.2 meghajtóval

(*

  XDir,YDir : -1,0,+1 értékeket vehet fel;

              Az előjel az irányt jelöli

*)

procedure TSTMotors.MoutPlasma(XDir,YDir:integer);

Var _STB,_STB2 : word;

    pByte: byte;   // PORT alaphelyzetének kiolvasása

    vByte: byte;   // PORT-ra kiküldendő adat

begin

{Demó és Test módban nincs motorvezérlés}

If (not demo) and (WorkingMode<>wmTest) {and not GetSTOP} then begin

   _STB := _LPT;

   _STB2 := _LPT+2;

   If IsDriverInstalled then begin

 

    // Láng begyujtása ill. kioltása

    If HeadStatus then begin

       HRT.Delay(0.01);

       SetPortBit(_STB2,0);

       HRT.Delay(0.1);

    end ELSE begin

       HRT.Delay(0.01);

       ClrPortBit(_STB2,0);

       HRT.Delay(0.01);

    end;

 

    If HeadStatus then begin

       HRT.Delay(0.01);

       SetPortBit(_LPT,3);

       HRT.Delay(0.1);

    end ELSE begin

       HRT.Delay(0.01);

       ClrPortBit(_LPT,3);

       HRT.Delay(0.01);

    end;

 

      // x,y motor engedélyezés

      ClrPortBit(_STB,0);

      ClrPortBit(_STB,4);

      HRT.Delay(0.01);

 

      // X motor lépésiránya + ill. negatív

 

      if (XDir>0) then StepDirectionX:=sdPoz;

      if (XDir<0) then StepDirectionX:=sdNeg;

      if (YDir>0) then StepDirectionY:=sdPoz;

      if (YDir<0) then StepDirectionY:=sdNeg;

 

      Case StepDirectionX of

      sdPoz: begin

             StepDirectionX := sdPoz;

             SetPortBit(_STB,1);

             end;

      sdNeg: begin

             StepDirectionX := sdNeg;

             ClrPortBit(_STB,1);

             end;

      end;

 

      Case StepDirectionY of

      sdPoz: begin

             StepDirectionY := sdPoz;

             SetPortBit(_STB,5);

             end;

      sdNeg: begin

             StepDirectionY := sdNeg;

             ClrPortBit(_STB,5);

             end;

      end;

 

      HRT.Delay(0.01);

 

      // X-Y motor lép

      if XDir<>0 then begin

         SetPortBit(_STB,2);

      end;

      if YDir<>0 then begin

         SetPortBit(_STB,6);

      end;

      HRT.Delay(0.01);

 

      // Törlöm a lépés biteket

      ClrPortBit(_STB,2);

      ClrPortBit(_STB,6);

   end;

end;

end;

 

Procedure TSTMotors.Up;

begin

//  GetOverrun;

If (not fSTOPy1) or (WorkingMode=wmTest) then begin

if fMotorMethod=mmNew then MoutPlasma(0,1)

else begin

V_Next:=V_Next+1;

V_Next:=V_Next mod 8;

Mout(Mottab[V_Next]+64);

end;

ActPosition:=Point3d(ActPosition.x,ActPosition.y+MMPerLepesY,ActPosition.z);

Wait;

end;

end;

 

Procedure TSTMotors.Down;

begin

//   GetOverrun;

If (not fSTOPy0) or (WorkingMode=wmTest) then begin

if fMotorMethod=mmNew then MoutPlasma(0,-1)

else begin

V_Next:=V_Next-1;

If V_Next=-1 then V_Next:=7;

V_Next:=V_Next mod 8;

Mout(Mottab[V_Next]+64);

end;

ActPosition:=Point3d(ActPosition.x,ActPosition.y-MMPerLepesy,ActPosition.z);

Wait;

end;

end;

 

Procedure TSTMotors.Left;

begin

//   GetOverrun;

If (not fSTOPx0) or (WorkingMode=wmTest) then begin

if fMotorMethod=mmNew then MoutPlasma(-1,0)

else begin

H_Next:=H_Next+1;

H_Next:=H_Next mod 8;

Mout(Mottab[H_Next]);

end;

ActPosition:=Point3d(ActPosition.x-MMPerLepesX,ActPosition.y,ActPosition.z);

Wait;

end;

end;

 

Procedure TSTMotors.Right;

begin

//   GetOverrun;

If (not fSTOPx1) or (WorkingMode=wmTest) then begin

if fMotorMethod=mmNew then MoutPlasma(1,0)

else begin

H_Next:=H_Next-1;

If H_Next=-1 then H_Next:=7;

H_Next:=H_Next mod 8;

Mout(Mottab[H_Next]);

end;

ActPosition:=Point3d(ActPosition.x+MMPerLepesX,ActPosition.y,ActPosition.z);

Wait;

end;

end;

 

 

// CutOn = vágóláng megy-e? Ez vegye figyelembe a rutin

// Ha lemászik az asztalról kapcsolja ki a lángot

procedure TSTMotors.GetOverrun;

Var _STB : word;

    _STA : word;

    statusByte : byte;

    kesz       : byte;

    vegallas   : byte;

    veSTOP     : byte;

    k          : integer;

begin

      {Végállás lekérdezés}

       _STB := _LPT +2;

       _STA := _LPT +1;

      k := 0;

      // hA RELÉ BEHÚZVA AKKOR NEM 2, HANEM 6 (3. bitet billenteni)

      PortOut(_STB,2);

      kesz:=8;

      repeat

       statusByte := PortIn(_STA);

       IF WorkingMode<>wmPlazma then

          kesz       := statusByte AND 8;

       Inc(k);

       Application.ProcessMessages;

      Until (kesz=8) or (k>32000);

      vegallas := PortIn(_STA);

      {Felső 4 bit jelzi a végállásokat: 11110000 alapesetben

       4. x0; 5. x1; 6. y0; 7. y1 -> bit=0 végállás}

      IF MotorMethod=mmNew then begin

         vegallas := vegallas xor 112;

         // Szakadás lekérdezése

         Szakadas := (statusByte AND 8)<>8;

      end;

      STOPx0   := (vegallas and 16)<>16;

      STOPx1   := (vegallas and 32)<>32;

      STOPy0   := (vegallas and 64)<>64;

      STOPy1   := (vegallas and 128)<>128;

      // hA RELÉ BEHÚZVA AKKOR NEM 0, HANEM 4 (3. bitet billenteni)

      PortOut(_STB,0);

end;

 

function TSTMotors.GetSTOP:boolean;

Var _STB : word;

    _STA : word;

    statusByte : byte;

    kesz       : byte;

    vegallas   : byte;

    veSTOP     : byte;

    k          : integer;

begin

      {VészSTOP lekérdezés: 4. bit=1 esetén}

      PortOut(_STB,4);

       _STB := _LPT +2;

       _STA := _LPT +1;

      repeat

       statusByte := PortIn(_STA);

       kesz       := statusByte AND 8;

       Application.ProcessMessages;

      Until kesz=8;

      veSTOP := PortIn(_STA);

      Result := (veSTOP and 16)=16;

      If (veSTOP and 16)=16 then WorkOn := False;

      PortOut(_STB,0);

end;

 

procedure TSTMotors.Wait;

var k: longint;

begin

  HRT.Delay(kesleltetes);

end;

 

{Várakozás sec másodpercig}

procedure TSTMotors.WaitTime(sec:integer);

var d1:TDateTime;

   h,m,s,ms: word;

begin

d1:=Now;

repeat

   DecodeTime(Now-d1,h,m,s,ms);

   if (lo(GetAsyncKeyState(VK_RETURN)) = 1)

   then

       Exit;

Until s>=sec;

end;

 

Procedure TSTMotors.Pen_On;

Var Next_Value  : byte;

begin

if fMotorMethod<>mmNew then begin

Next_Value := $87;

Mout( Next_Value );

toll := True;

ActPosition:=Point3d(ActPosition.x,ActPosition.y,ActPosition.z+MMPerLepesZ);

end;

end;

 

Procedure TSTMotors.Pen_Off;

Var Next_Value  : byte;

begin

if fMotorMethod<>mmNew then begin

Next_Value := $9B;

Mout( Next_Value );

toll := False;

ActPosition:=Point3d(ActPosition.x,ActPosition.y,ActPosition.z-MMPerLepesZ);

end;

end;

 

Procedure TSTMotors.Pen_down;

begin

if fMotorMethod<>mmNew then begin

if fWorkingMode=wmPlazma then

      PortOut(_LPT,0);

If not Folytonosvagas then begin

Z_Next:=Z_Next-1;

If Z_Next=-1 then Z_Next:=7;

Z_Next:=Z_Next mod 8;

Mout(Mottab[Z_Next]+128);

end;

ActPosition:=Point3d(ActPosition.x,ActPosition.y,ActPosition.z+MMPerLepesZ);

end;

end;

 

Procedure TSTMotors.Pen_up;

begin

if fMotorMethod<>mmNew then begin

if fWorkingMode=wmPlazma then

      PortOut(_LPT,17);

If not Folytonosvagas then begin

Z_Next:=Z_Next+1;

Z_Next:=Z_Next mod 8;

Mout(Mottab[Z_Next]+128);

ActPosition:=Point3d(ActPosition.x,ActPosition.y,ActPosition.z-MMPerLepesZ);

end;

end;

end;

 

Procedure TSTMotors.HeadUp;

Var ii,k,l: longint;

begin

HeadStatus := False;

if fMotorMethod<>mmNew then begin

If not Folytonosvagas then begin

If (ActPosition.z<>0) then begin

   l := Round(ActPosition.z/lepesZ);

For ii:=1 to l-1 do begin

Z_Next:=Z_Next+1;

Z_Next:=Z_Next mod 8;

Mout(Mottab[Z_Next]+128);

  k:=0;

  Repeat

     Inc(k);

  until k>=kesleltetesMINz;

  ActPosition:=Point3d(ActPosition.x,ActPosition.y,ActPosition.z-MMPerLepesZ);

end;

end;

end;

pen_off;

end;

end;

 

Procedure TSTMotors.HeadDown;

Var ii,k,l: longint;

begin

HeadStatus := True;

if fMotorMethod<>mmNew then begin

If not Folytonosvagas then begin

   l := Round((kiemeles-ActPosition.z)/lepesZ);

For ii:=1 to l do begin

Z_Next:=Z_Next-1;

If Z_Next=-1 then Z_Next:=7;

Z_Next:=Z_Next mod 8;

Mout(Mottab[Z_Next]+128);

ActPosition:=Point3d(ActPosition.x,ActPosition.y,ActPosition.z+MMPerLepesZ);

  k:=0;

  Repeat

     Inc(k);

  until k>=kesleltetesMINz;

end;

end;

HeadStatus := True;

end;

end;

 

{dz lepesszámot lép a z motor, az aktuális poz-hoz képest;

   dz>0 then lefelé, egyébként felfelé viszi a fejet}

procedure TSTMotors.LoopZ(dz:integer);

var i:integer;

begin

If not Folytonosvagas then begin

If dz<>0 then

For i:=1 to Abs(dz) do begin

     If dz<0 then Pen_Up

     else Pen_Down;

end;

end;

end;

 

{z abszolut pozícióba mozgatja a fejet}

procedure TSTMotors.GoHead(z:extended);

var i,dz:integer;

begin

dz := Round((z-ActPosition.z)/MMPerLepesZ);

LoopZ(dz);

end;

 

procedure TSTMotors.SetActPosition(const Value: TPoint3D);

Var xx,yy: integer;

begin

FActPosition := Value;

    If FActPositionLabel<>nil then begin

       ActPositionLabel.Caption :=

               Format('%6.1f',[FActPosition.x])+' : '+

               Format('%6.1f',[FActPosition.y]);

(*                Format('%6.'+IntToStr(ActPosPrecision)+'f',[FActPosition.x])+' : '+

               Format('%6.'+IntToStr(ActPosPrecision)+'f',[FActPosition.y]);*)

//                                    +' ['+Format('%4.'+IntToStr(ActPosPrecision)+'f',[FActPosition.z])+']';

    end;

    If SablonImage<>nil then

    With SablonImage do begin

       DrawWorkPoint(Value.x,Value.y);

    end;

    If Assigned(FOnActPosition) then FOnActPosition(Self,Value);

end;

 

{ A gyártási mód beállítása }

procedure TSTMotors.SetWorkingMode(const Value: TWorkingMode);

var oldWM: TWorkingMode;

begin

If FWorkingMode <> Value then begin

    oldWM:= FWorkingMode;

    FWorkingMode := Value;

    Case Value of

    wmTest   : WorkOn:=False;

    wmCut    : WorkOn:=True;

    wmGravir : WorkOn:=True;

    wmPlazma : WorkOn:=True;

    end;

    FactoryConfig.WorkingMode := Ord(Value);

end;

If Assigned(FOnWorkingMode) then FOnWorkingMode(Self,Value);

end;

 

procedure TSTMotors.SetSablonImage(const Value: TALSablon);

begin

If FSablonImage<>Value then begin

    FSablonImage:=Value;

    If Value<>nil then begin

       LapmeretWIDTH   := Trunc(FSablonImage.Paper.x);

       LapmeretHEIGHT  := Trunc(FSablonImage.Paper.y);

    end;

end;

end;

 

procedure TSTMotors.SetActPositionLabel(const Value: TLabel);

begin

If FActPositionLabel<>Value then begin

    FActPositionLabel:=Value;

    ActPosition := FActPosition;

end;

end;

 

procedure TSTMotors.SetkesleltetesMIN(const Value: longint);

begin

    FkesleltetesMIN := Value;

    Quickkesleltetes := FKesleltetesMIN * (100-QuickVelocity);

    Workkesleltetes  := FKesleltetesMIN * (100-WorkVelocity);

    kesleltetes := Quickkesleltetes;

    FactoryConfig.KesleltetesMIN := Value;

end;

 

procedure TSTMotors.SetLapmeretWIDTH(const Value: integer);

begin

FLapmeretWIDTH := Value;

If SablonImage<>nil then begin

    SablonImage.Paper.x := Value;

    FactoryConfig.Paper.x := Value;

end;

end;

 

procedure TSTMotors.SetLapmeretHEIGHT(const Value: integer);

begin

FLapmeretHEIGHT := Value;

If SablonImage<>nil then begin

    SablonImage.Paper.y := Value;

    FactoryConfig.Paper.y := Value;

end;

end;

 

procedure TSTMotors.SetQuickVelocity(const Value: integer);

var kk: double;

 

    Function GetDelayCorrection(seb:double):double;

    var k1,k2: integer; // Előző,következő egész sebesség indexe

        d1,d2: double;

    begin

      With FactoryConfig do begin

        k1:=Trunc(seb); k2:=Trunc(seb+1);

        d1:=TimeCorrection[k1];

        d2:=TimeCorrection[k2];

        Result := d1+(seb-k1)*(d2-d1);

      end;

    end;

 

begin

If Value<=0 then FQuickVelocity:=1 else

    FQuickVelocity := Value;

    DelayCorrection := GetDelayCorrection(FQuickVelocity);

    Quickkesleltetes := DelayCorrection;

    FactoryConfig.PosSebesseg := FQuickVelocity;

end;

 

procedure TSTMotors.SetSebesseg(const Value: integer);

begin

FSebesseg := Value;

WorkVelocity := Value;

end;

 

procedure TSTMotors.SetSebessegOption(const Value: TSebessegOption);

begin

FSebessegOption := Value;

end;

 

procedure TSTMotors.SetWorkVelocity(const Value: integer);

var kk: double;

 

    Function GetDelayCorrection(seb:double):double;

    var k1,k2: integer; // Előző,következő egész sebesség indexe

        d1,d2: double;

    begin

      With FactoryConfig do begin

        k1:=Trunc(seb); k2:=Trunc(seb+1);

        d1:=TimeCorrection[k1];

        d2:=TimeCorrection[k2];

        Result := d1+(seb-k1)*(d2-d1);

      end;

    end;

 

begin

If Value<=0 then FWorkVelocity:=1 else

    FWorkVelocity := Value;

    DelayCorrection := GetDelayCorrection(FWorkVelocity);

    Workkesleltetes := DelayCorrection;

    FactoryConfig.WorkSebesseg := FWorkVelocity;

end;

 

procedure TSTMotors.SetActPosPrecision(const Value: integer);

begin

FActPosPrecision := Value;

FactoryConfig.Precizio := Value;

end;

 

procedure TSTMotors.SetMMPerLepesX(const Value: extended);

begin

FMMPerLepesX := Value;

FactoryConfig.LepesX := FMMPerLepesX; //MotorConstans;

end;

 

procedure TSTMotors.SetMMPerLepesY(const Value: extended);

begin

FMMPerLepesY := Value;

FactoryConfig.LepesY := FMMPerLepesY; //MotorConstans;

end;

 

procedure TSTMotors.SetMMPerLepesZ(const Value: extended);

begin

FMMPerLepesZ := Value;

FactoryConfig.LepesZ := FMMPerLepesZ; //MotorConstans;

end;

 

procedure TSTMotors.SetkesleltetesMINz(const Value: longint);

begin

FkesleltetesMINz := Value;

FactoryConfig.KesleltetesMINz := Value;

end;

 

procedure TSTMotors.SetKiemeles(const Value: integer);

begin

FKiemeles := Value;

FactoryConfig.Kiemeles := Value;

end;

 

procedure TSTMotors.SetNegativHead(const Value: integer);

begin

FNegativHead := Value;

FactoryConfig.NegativHead := Value;

end;

 

procedure TSTMotors.SetCorrection(const Value: extended);

begin

fCorrection := Value;

FactoryConfig.Correction := Value;

end;

 

procedure TSTMotors.FactoryDefaultLoad;

begin

If FileExists('FACTORY.FAC') then

   ConfigLoad('FACTORY.FAC')

else

   ShowMessage('FACTORY.FAC file betöltése sikertelen')

end;

 

procedure TSTMotors.FactoryDefaultSave;

begin

Try

ConfigSave('FACTORY.FAC');

except

exit;

end;

end;

 

procedure TSTMotors.TotalWorking;

begin

If SablonImage<>nil then begin

//    ActPosition:=Point3d(0,0,0);

   SablonImage.FCurveList.First;

   Working(0,0);

end;

end;

 

procedure TSTMotors.WorkingFromPoint(ap: Integer);

begin

 

end;

 

procedure TSTMotors.VekOut(dx,dy:extended;PENDOWN:boolean);

var i,x,y,lepesszam: integer;

   d,xr,yr,s,c,lepeskoz : extended;

   alfa : double;

   okesleltetes,correction: double;

   DestPosition : TPoint3D;

begin

DestPosition.x := ActPosition.x+dx;

DestPosition.y := ActPosition.y+dy;

 

WorkOn:=True;

d := sqrt((dx*dx)+(dy*dy));

If MMPerLepesX<MMPerLepesY then begin

    lepeskoz  := MMPerLepesX;

end else begin

    lepeskoz  := MMPerLepesY;

end;

HeadStatus := PenDown;

If PENDOWN then begin

    Kesleltetes:=WorkKesleltetes;

{     If WorkingMode=wmCut then HeadDown;}

end else begin

    Kesleltetes:=QuickKesleltetes;

{     If WorkingMode=wmCut then HeadUp;}

end;

lepesszam := Round(d/lepeskoz);

alfa := SzakaszSzog(0,0,dx,dy);

xr := 0;

yr := 0;

s := lepeskoz*sin(alfa); c := lepeskoz*cos(alfa);

 

okesleltetes:=Kesleltetes;

if (lepesszam<>0) and ((Abs(dx)>lepeskoz) and (Abs(dy)>lepeskoz)) then begin

    correction:=Abs(lepesszam/(Abs(dx/lepeskoz)+Abs(dy/lepeskoz)));

    Kesleltetes:= Kesleltetes*(correction);

end;

 

For i:=1 to lepesszam do begin

//  Repeat

     x:=Round(xr/MMPerLepesX); y:=Round(yr/MMPerLepesY);

     xr := xr+c;

     yr := yr+s;

     If x<>Round(xr/MMPerLepesX) then begin

        If dx>0 then Right;

        If dx<0 then Left;

     end;

     If y<>Round(yr/MMPerLepesY) then begin

        If dy>0 then Up;

        If dy<0 then Down;

     end;

     If SablonImage<>nil then

     With SablonImage do begin

       if fSablonSzinkron then

           MoveCentrum(ActPosition.x,ActPosition.y);

     end;

//      If PENDOWN then Kesleltetes:=WorkKesleltetes

//      else Kesleltetes:=QuickKesleltetes;

 

     WorkTime := HRT.ReadTimer;

     If Assigned(fWorkTime) then fWorkTime(Self,WorkTime);

 

(*      if (lo(GetAsyncKeyState(VK_ESCAPE)) > 0)

     then begin

          STOP := True;

     end;

 

     if (lo(GetAsyncKeyState(VK_SPACE)) > 0)

     then begin

          STOP := False;

          PillanatAllj := True;

     end;*)

 

     Application.ProcessMessages;

     if STOP then begin

        Kesleltetes:=okesleltetes;

        WorkOn := False;

        exit;

     end;

end;

//  Until (Abs(DestPosition.x-ActPosition.x)<=lepeskoz) and (Abs(DestPosition.y-ActPosition.y)<=lepeskoz);

Kesleltetes:=okesleltetes;

end;

 

procedure TSTMotors.GotoNullPosition;

begin

if (not szakadas) and (WorkingMode<>wmTest) then LineTemperature := 2;

If DownUp then begin

    If (actPosition.z<>0) then

       HeadUp;

    If (actPosition.x<>0) or (actPosition.y<>0) then

       VekOut(-actPosition.x,-ActPosition.y,True);

end else begin

    If (actPosition.z<>0) then

       HeadUp;

    If (actPosition.x<>0) or (actPosition.y<>Factoryconfig.Paper.y) then

       VekOut(-actPosition.x,Factoryconfig.Paper.y-ActPosition.y,True);

end;

if (not szakadas) and (WorkingMode<>wmTest) then LineTemperature := 1;

end;

 

function TSTMotors.GotoXYPosition(x, y: extended): boolean;

var dx,dy: extended;

begin

if (not szakadas) and (WorkingMode<>wmTest) then LineTemperature := 2;

SourcePosition := actPosition;

DestPosition := Point3D(x,y,actPosition.z);

dx:=DestPosition.x - SourcePosition.x;

dy:=DestPosition.y - SourcePosition.y;

HeadStatus := False;

VekOut(dx,dy,FolytonosVagas);

if (not szakadas) and (WorkingMode<>wmTest) then LineTemperature := 1;

end;

 

{Megmunkálás az Aobject AItem sorszámú pontjától}

procedure TSTMotors.Working(AObject,AItem:integer);

var Cuv : TCurve;

   i,j,j0 : integer;

   x,y : double;

   elso: boolean;

   p : TPoint2d;

begin

If not STOP then begin

If SablonImage<>nil then

With SablonImage do begin

Try

   elso := True;

   ShowPoints := False;

   CentralCross := True;

   SablonImage.Working := True;

   WorkPosition.CuvNumber := AObject;

   WorkPosition.PointNumber := AItem;

   Paint;

//    If WorkingMode<>wmTest then

   WorkOn:=True;

   HRT.StartTimer;

   For i:=AObject to FCurveList.Count-1 do begin

       Cuv := FCurveList.Items[i];

       If Cuv.Enabled then begin

       WorkPosition.CuvNumber := i;

 

       If elso then begin j0:=AItem; elso:=False;

       end else j0 := 0;

 

       HeadStatus := False;

 

       // Ha nincs 2 alakzat között összekötés akkor gyors közelítés

          Cuv.GetPoint(j0,x,y);

          if (Abs(x-ActPosition.x)>0.1) and (Abs(y-ActPosition.y)>0.1)

          and (not FolytonosVagas) then

              VekOut(x-ActPosition.x,y-ActPosition.y,False);

 

       For j:=j0 to Cuv.FPoints.Count-1 do begin

           Cuv.GetPoint(j,x,y);

           WorkPosition.PointNumber := j;

           If FactoryConfig.PlazmaMachine and (j=0) then begin

              { Zárt alakzatoknál fej státusza : láng begyujtás, kioltás }

              if Cuv.Closed then

                 WaitTime(Trunc(FactoryConfig.TimePlazma[FactoryConfig.PlazmaIndex,1]));

              HeadStatus := Cuv.Closed;

           end;

           if FolytonosVagas then

              VekOut(x-ActPosition.x,y-ActPosition.y,True)

           else

              VekOut(x-ActPosition.x,y-ActPosition.y,Cuv.Closed);

           if STOP then Break;

           if fSablonSzinkron then MoveCentrum(x,y);

       end;

       if STOP then Break;

       // Closed curve back to 0. point if points count>2

       If Cuv.Closed and (Cuv.FPoints.Count>2) then begin

           Cuv.GetPoint(0,x,y);

           WorkPosition.PointNumber := j;

           VekOut(x-ActPosition.x,y-ActPosition.y,True);

           if STOP then exit;

           if fSablonSzinkron then MoveCentrum(x,y);

       end;

       end;

       HeadStatus := False;

       if assigned(fWorkTime) then

          fWorkTime(Self,HRT.ReadTimer);

   end

   finally

       SablonImage.Working := False;

       WorkOn := False;

       HeadStatus := False;

   end;

end;

end;

end;

 

function TSTMotors.GetTotalWorkWay:double;

// A teljes sablon hossza mm-ben

var i,j : integer;

   x,y,ox,oy : TFloat;

   Cuv : TCurve;

begin

If ComponentState=[] then begin

Result := 0;

ox:=ActPosition.x; oy:=ActPosition.Y;

If SablonImage<>nil then

With SablonImage do

For i:=0 to FCurveList.Count-1 do begin

      Cuv := FCurveList.Items[i];

       For j:=0 to Cuv.FPoints.Count-1 do begin

           Cuv.GetPoint(j,x,y);

           Result := Result + sqrt(sqr(x-ox)+sqr(y-oy));

           ox:=x; oy:=y;

       end;

       If Cuv.Closed then begin

           Cuv.GetPoint(0,x,y);

           Result := Result + sqrt(sqr(x-ox)+sqr(y-oy));

           ox:=x; oy:=y;

       end;

end;

end;

end;

 

procedure TSTMotors.SetSablonSzinkron(const Value: boolean);

begin

fSablonSzinkron := Value;

end;

 

procedure TSTMotors.SetOverRun(const Index: Integer; const Value: boolean);

begin

IF VegallasEnabled then

Case Index of

1: fSTOPx0 := Value;

2: fSTOPx1 := Value;

3: fSTOPy0 := Value;

4: fSTOPy1 := Value;

end

else

//  If not GetMachine then begin

   fSTOPx0:=False;fSTOPx1:=False;fSTOPy0:=False;fSTOPy1:=False;

//  end;

//  If WorkOn then Pillanatallj := Value;

If Assigned(fOverRunEvent) then

   fOverRunEvent(Self,fSTOPx0,fSTOPx1,fSTOPy0,fSTOPy1);

end;

 

procedure TSTMotors.SetSTOP(const Value: boolean);

begin

{VÉSZSTOP esetén minden letiltva}

FSTOP := Value;

WorkingEnable := not Value;

WorkOn := not Value;

HeadUp;

If Assigned(fSTOPEvent) then fSTOPEvent(Self,Value);

end;

 

procedure TSTMotors.SetWorkingEnable(const Value: boolean);

begin

{Gyártás engedélyezés: False esetben a folyamatban lévő gyártás

   letiltása}

FWorkingEnable := Value;

If fWorkOn then fWorkOn := Value;

end;

 

procedure TSTMotors.SetWorkOn(const Value: boolean);

begin

{Valódi gyártási folyamat jelzése = True esetben}

FWorkOn := Value;

If Value then Pen_Down else Pen_Up;

If Assigned(FOnWorkOnOff) then FOnWorkOnOff(Self,Value);

end;

 

procedure TSTMotors.SetPillanatAllj(const Value: boolean);

begin

//  If FPillanatAllj<>Value then begin

If ComponentState <> [csDestroying] then begin

 

    FPillanatAllj := Value;

    HeadStatus    := not Value;

    If Assigned(FPillanatAlljEvent) then FPillanatAlljEvent(Self,Value);

 

    if (WorkingMode<>wmTest) then

    begin

         If Value then begin

            if not SzakadasVolt then

               Heating(1);

         end

         else

            Heating(2);

    end

      else

      if not SzakadasVolt then

         LineTemperature := 1;

 

    Repeat

      Application.ProcessMessages;

    Until ((not FPillanatAllj) or STOP) and (not SzakadasVolt);

 

end;

 

end;

 

procedure TSTMotors.GotoAbsolutNullPosition;

var szele: boolean;

begin

{Fej elmozgatása x irányban végállásig}

if (not szakadas) and (WorkingMode<>wmTest) then LineTemperature := 2;

While not fSTOPx0 do begin

   Left;

   kesleltetes := Workkesleltetes;

   wait;

   Application.ProcessMessages;

   If STOP then exit;

end;

{Fej elmozgatása y irányban végállásig}

   if DownUp then szele:=fSTOPy0 else szele:=fSTOPy1;

 

While not szele do begin

   if DownUp then Down else Up;

   kesleltetes := Workkesleltetes;

   wait;

   Application.ProcessMessages;

   if DownUp then szele:=fSTOPy0 else szele:=fSTOPy1;

   If STOP then exit;

end;

if DownUp then

    ActPosition:=Point3d(0,0,0)

else

    ActPosition:=Point3d(0,FactoryConfig.Paper.y,0);

if (not szakadas) and (WorkingMode<>wmTest) then LineTemperature := 1;

end;

 

procedure TSTMotors.setIsMachine(const Value: boolean);

begin

If fIsMachine <> Value then begin

   fIsMachine := Value;

//    If not Value then ShowMessage('GÉP NEM MŰKÖDŐKÉPES!');

end;

end;

 

procedure TSTMotors.SetHeadStatus(const Value: boolean);

begin

FHeadStatus := Value;

   If IsDriverInstalled and (HRT<>nil) then

    If HeadStatus then begin

       HRT.Delay(0.01);

       SetPortBit(_LPT+2,0);

       HRT.Delay(0.1);

    end ELSE begin

       HRT.Delay(0.01);

       ClrPortBit(_LPT+2,0);

       HRT.Delay(0.01);

    end;

If Assigned(FHeadStatusChange) then FHeadStatusChange(Self,Value);

end;

 

procedure TSTMotors.SetMotorMethod(const Value: TMotorMethod);

begin

fMotorMethod := Value;

//  DownUp := Value=mmOld;

end;

 

 

// Szál hőfokának beállítása

procedure TSTMotors.SetLineTemperature(const Value: integer);

begin

//  If FLineTemperature <> Value then begin

    FLineTemperature := Value;

         if not Szakadas then begin

            Heating(Value);

         end else

            Pillanatallj := True;

    if Assigned(FLineOk) then FLineOk(Self,LineTemperature,Szakadas);

//  end;

end;

 

procedure TSTMotors.Heating(LTemp: integer);

begin

    FLineTemperature := LTemp;

            Case LTemp of

            0:                           // Fűtés kikapcs.

            begin

               ClrPortBit(_LPT,3);

               ClrPortBit(_LPT,7);

            end;

            1:                           // Fűtés alacsony

            begin

               SetPortBit(_LPT,3);

               ClrPortBit(_LPT,7);

            end;

            2:                           // Fűtés magas

            begin

               ClrPortBit(_LPT,3);

               SetPortBit(_LPT,7);

            end;

            end;

end;

 

procedure TSTMotors.SetSzakadas(const Value: boolean);

begin

if FSzakadas <> Value then begin

    FSzakadas := Value;

    if Assigned(FLineOk) then FLineOk(Self,LineTemperature,FSzakadas);

    if Value then begin

       SzakadasVolt := True;

    end;

    PillanatAllj:=Value;

end;

end;

 

 

procedure TSTMotors.SetSzakadasVolt(const Value: boolean);

VAR statusByte : byte;

begin

if not Value then begin

   statusByte := PortIn(_LPT+1);

   if (statusByte AND 8)<>8 then // fizikálisan fenáll a szakadás

      FSzakadasVolt := True

   else begin                     // nincs fiz. szakadás

     Heating(2);                  // fűtés teljes gőz

     WaitTime(3);                 // várakozás 3 sec-ig

     ora.Enabled := True;         // vizsgálatok engedélyezése

     FSzakadasVolt := False;

   end;

end else begin

FSzakadasVolt := Value;

ora.Enabled := False;

Heating(0);

end;

end;

 

procedure TSTMotors.SetDownUp(const Value: boolean);

begin

FDownUp := Value;

inherited;

end;

 

procedure TSTMotors.SetVegallasEnabled(const Value: boolean);

begin

FVegallasEnabled := Value;

end;

 

initialization

 

  // mm/lépés állandó az adott motorra, csak itt kell beállítani !!!!

//   MotorConstans := 0.039;

  MotorConstans := 0.052;

//   MotorConstans := 0.0375;

 

end.