Prima versione macchina
This commit is contained in:
andrea.villa
@@ -0,0 +1,4 @@
|
||||
/Tools
|
||||
/Machinings
|
||||
/SetUp
|
||||
/THolders
|
||||
Vendored
+101
@@ -0,0 +1,101 @@
|
||||
{
|
||||
"Lua.diagnostics.globals": [
|
||||
"EmtTcPos",
|
||||
"EgtGetAllTcPosNames",
|
||||
"EgtGetFirstNameInGroup",
|
||||
"EgtSetStatus",
|
||||
"EgtEmptyGroup",
|
||||
"EgtGetFirstRawPart",
|
||||
"EmtLinkRawPartToGroup",
|
||||
"EgtVerifyRawPartPhase",
|
||||
"EgtGetNextRawPart",
|
||||
"EMT",
|
||||
"EgtOutText",
|
||||
"EgtGetFirstPartInRawPart",
|
||||
"EmtSetLastError",
|
||||
"EgtGetToolsInCurrSetupPos",
|
||||
"EgtLoadTool",
|
||||
"EgtSetName",
|
||||
"EgtGroup",
|
||||
"EgtSetLevel",
|
||||
"EgtOutLog",
|
||||
"EmtUnlinkAllRawPartsFromGroups",
|
||||
"EgtSetAxisPos",
|
||||
"EgtGetPhaseCount",
|
||||
"EgtGetCurrMachGroup",
|
||||
"EgtErase",
|
||||
"EgtVolZmapBox",
|
||||
"EgtSetColor",
|
||||
"EgtGetFirstInGroup",
|
||||
"EgtGetNext",
|
||||
"EgtGetFirstOperation",
|
||||
"EgtGetOperationType",
|
||||
"EgtSetOperationStatus",
|
||||
"EgtGetNextOperation",
|
||||
"EgtGetDebugLevel",
|
||||
"EgtGetAxisId",
|
||||
"EgtGetBaseId",
|
||||
"EgtMove",
|
||||
"EgtTdbGetCurrToolParam",
|
||||
"EmtAddCollisionObjEx",
|
||||
"EgtGetNextActiveOperation",
|
||||
"EgtGetFirstActiveOperation",
|
||||
"EgtSetCurrMachining",
|
||||
"EgtGetMachiningParam",
|
||||
"EgtSetMode",
|
||||
"EgtGetHeadId",
|
||||
"EgtPause",
|
||||
"EgtGetAxisPos",
|
||||
"EgtGetOperationName",
|
||||
"EgtGetMachiningGeometry",
|
||||
"EgtVolZmapPartCount",
|
||||
"EgtVolZmapPartVolume",
|
||||
"EgtRemoveVolZmapPart",
|
||||
"EgtDraw",
|
||||
"EgtNumToString",
|
||||
"EgtSplitString",
|
||||
"EmtUnlinkRawPartFromGroup",
|
||||
"EgtRelocate",
|
||||
"EgtVolZmapGetEdges",
|
||||
"EgtGetCurrMachineName",
|
||||
"EgtGetCurrMachineDir",
|
||||
"EgtGetStringFromIni",
|
||||
"EgtGetCurrFilePath",
|
||||
"EgtGetMachGroupName",
|
||||
"EgtSaveObjToFile",
|
||||
"EmtSetOutstrokeInfo",
|
||||
"EgtTdbSetCurrTool",
|
||||
"EgtUiUnitsAreMM",
|
||||
"EgtGetAxisHomePos",
|
||||
"EgtSetInfo",
|
||||
"EgtGetTcPosId",
|
||||
"EgtGetName",
|
||||
"EgtGetCurrMachining",
|
||||
"EgtOutBox",
|
||||
"EgtResetCurrMachining",
|
||||
"EgtGetPhaseDisposition",
|
||||
"EgtExistsFile",
|
||||
"EmtGeneral",
|
||||
"EmtBase",
|
||||
"EmtAxis",
|
||||
"EmtHead",
|
||||
"EmtTable",
|
||||
"EmtModifyExitPosition",
|
||||
"EmtModifyAxisHome",
|
||||
"EgtRemoveInfo",
|
||||
"EmtUnlinkAllFixturesFromGroups",
|
||||
"EMC",
|
||||
"EgtSetCurrPhase",
|
||||
"EgtTdbGetToolFromUUID",
|
||||
"EgtGetPrevActiveOperation",
|
||||
"EgtExistsInfo",
|
||||
"EgtGetLastInGroup",
|
||||
"EmtGetAxesPos",
|
||||
"EgtRemoveOperationHome",
|
||||
"EgtGetPartInRawPartCount",
|
||||
"EgtGetOperationPhase",
|
||||
"EgtSetOperationMode",
|
||||
"EgtSetCalcTool",
|
||||
"EmtModifyAxisStroke"
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
; Commento per evitare BOM con UTF-8
|
||||
;Index = Type, Description
|
||||
; Type : d=double
|
||||
; Description : l=lenght, s=string, b=boolean
|
||||
|
||||
[Drilling]
|
||||
|
||||
[Sawing]
|
||||
|
||||
[Milling]
|
||||
0=d,MaxElev,0
|
||||
1=d,OutRaw,0
|
||||
2=d,SideElev,0
|
||||
|
||||
[Pocketing]
|
||||
0=d,MaxElev,0
|
||||
1=b,Open,0
|
||||
2=d,OpenMinSafe,0
|
||||
3=d,OpenOutRaw,0
|
||||
4=d,MaxOptSize,0
|
||||
|
||||
[Mortising]
|
||||
0=d,MaxElev,0
|
||||
|
||||
[Chiseling]
|
||||
|
||||
[ChainsawCutting]
|
||||
|
||||
[SawRoughing]
|
||||
|
||||
[SawFinishing]
|
||||
|
||||
[GenMachining]
|
||||
|
||||
[SurfRoughing]
|
||||
|
||||
[SurfFinishing]
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,59 @@
|
||||
; Commento per evitare BOM con UTF-8
|
||||
[General]
|
||||
Material=Wood
|
||||
|
||||
[Tools]
|
||||
Drillbit=1
|
||||
Sawblade=1
|
||||
Mill=1
|
||||
Mortise=0
|
||||
Chisel=0
|
||||
DrillMaker=MakeWoodDrill.lua
|
||||
SawbladeMaker=MakeSawblade.lua
|
||||
MillMaker=MakeWoodCylMill.lua
|
||||
MortiseMaker=MakeMortise.lua
|
||||
ChiselMaker=MakeChisel.lua
|
||||
Active=0
|
||||
|
||||
[ToolHolder]
|
||||
H11.1=Standard.nge
|
||||
H21.1=
|
||||
H31.1=
|
||||
H41.1=Standard.nge
|
||||
|
||||
[Machinings]
|
||||
Drilling=1
|
||||
Sawing=0
|
||||
Milling=1
|
||||
Pocketing=1
|
||||
Mortising=0
|
||||
SawRoughing=0
|
||||
SawFinishing=0
|
||||
Chiseling=0
|
||||
|
||||
[Disposition]
|
||||
InitScript=InitDisp.lua
|
||||
|
||||
[Estimations]
|
||||
Enable=1
|
||||
|
||||
[Heads]
|
||||
; Main Vertical head 4ax
|
||||
H11=6601
|
||||
; rotary horizontal head 4-exit
|
||||
H21=6611
|
||||
; fixed horizontal head 2-exit
|
||||
H31=6602
|
||||
; Vertical head
|
||||
H41=6601
|
||||
|
||||
[Estimations]
|
||||
Enable=1
|
||||
WinPlace=0,458,74,669,933
|
||||
|
||||
[VMill]
|
||||
Enable=1
|
||||
Save=0
|
||||
|
||||
[SetUp]
|
||||
Default=Default
|
||||
@@ -0,0 +1,354 @@
|
||||
-- Special Operations macchina Saomad Just3500 by Egalware s.r.l. 15/01/2024
|
||||
-- 2024.01.15 ver 2.6g1 Prima versione
|
||||
|
||||
-- Intestazioni
|
||||
require( 'EmtGenerator')
|
||||
EgtEnableDebug( false)
|
||||
|
||||
PP_VER = '2.6g1'
|
||||
MIN_MACH_VER = '2.6g1'
|
||||
|
||||
EgtOutLog ( '** Saomad-Just3500 '..PP_VER..' (MinMach '.. MIN_MACH_VER ..') **', 1)
|
||||
|
||||
-- Parametri macchina
|
||||
NumericalControl = 'SIEMENS'
|
||||
|
||||
-- posizione assi
|
||||
C1 = Point3d( 0, 0, 100)
|
||||
C2 = Point3d( -10.5, -506, -127.85)
|
||||
-- corse assi
|
||||
MinX1 = -1000
|
||||
MaxX1 = 7000
|
||||
MinY1 = -2400
|
||||
MaxY1 = 5
|
||||
MinZ1 = -700
|
||||
MaxZ1 = 5
|
||||
MinC1 = -360
|
||||
MaxC1 = 360
|
||||
MinC2 = -360
|
||||
MaxC2 = 360
|
||||
-- posizione tavola
|
||||
--#region posizione tavola
|
||||
DeltaTabX = 793.96
|
||||
DeltaTabY = -1820
|
||||
DeltaTabZ = -717.75
|
||||
--#endregion
|
||||
-- testa 1 - testa 4 assi con CU
|
||||
H11 = Vector3d( 0, 0, 0)
|
||||
-- testa 2 - 4 uscite orizzontali rotanti
|
||||
H21_1 = C2 + Vector3d( -80, 0, 0)
|
||||
H21_2 = C2 + Vector3d( 80, 0, 0)
|
||||
H21_3 = C2 + Vector3d( 0, -80, 0)
|
||||
H21_4 = C2 + Vector3d( 0, 80, 0)
|
||||
-- testa 3 - 2 uscite orizzontali fisse
|
||||
H31_1 = Vector3d( 285.5, -699.5, -149.6)
|
||||
H31_2 = Vector3d( 285.5, -310, -149.6)
|
||||
-- testa 4 - testa 3 assi
|
||||
H41 = Vector3d( 432, -935, 33.95)
|
||||
-- morse
|
||||
ClampMaxVert = 170
|
||||
ClampDeltaZDeact = 50
|
||||
ClampRotDeact = 50
|
||||
ClampOnCar = 8
|
||||
ClampCarNumber = 2
|
||||
-- altri parametri
|
||||
CoeffVM = 0.75 -- coefficiente utilizzato per creazione VMILL
|
||||
|
||||
----------------------------------------------------------------------
|
||||
EmtGeneral {
|
||||
File='Saomad-Just3500.nge',
|
||||
Offset = Vector3d( -678.04, -3193, 171.25),
|
||||
AxisMaxAdjust = 10,
|
||||
ExitMaxAdjust = 10,
|
||||
Special = 'Saomad-Just3500.mlse',
|
||||
Processor = 'Saomad-Just3500.mlpe'}
|
||||
EmtBase {
|
||||
Name = 'Base',
|
||||
Geo='BASE/GEO',
|
||||
Aux= {'BASE/SOLID', 'BASE/TC'}}
|
||||
-- Carrelli ----------
|
||||
local X1Id = EmtAxis {
|
||||
Name = 'X1',
|
||||
Parent = 'Base',
|
||||
Token = '**',
|
||||
Type = MCH_AT.LINEAR,
|
||||
Dir = -X_AX(),
|
||||
Pos = Point3d( 2223.5, -1792, -809),
|
||||
Stroke = {MinX1, MaxX1},
|
||||
Home = 0,
|
||||
Geo = 'X1_AXIS/GEO',
|
||||
Aux = {'X1_AXIS/SOLID','X1_AXIS/COLLISION','X1_AXIS/CLAMP_1','X1_AXIS/CLAMP_2','X1_AXIS/CLAMP_3','X1_AXIS/CLAMP_4','X1_AXIS/CLAMP_5','X1_AXIS/CLAMP_6','X1_AXIS/CLAMP_7','X1_AXIS/CLAMP_8'}}
|
||||
local X2Id = EmtAxis {
|
||||
Name = 'X2',
|
||||
Parent = 'Base',
|
||||
Token = '**',
|
||||
Type = MCH_AT.LINEAR,
|
||||
Dir = -X_AX(),
|
||||
Pos = Point3d( 703.5, -3165, -809),
|
||||
Stroke = {MinX1, MaxX1},
|
||||
Home = 0,
|
||||
Geo = 'X2_AXIS/GEO',
|
||||
Aux = {'X2_AXIS/SOLID','X2_AXIS/COLLISION','X2_AXIS/CLAMP_1','X2_AXIS/CLAMP_2','X2_AXIS/CLAMP_3','X2_AXIS/CLAMP_4','X2_AXIS/CLAMP_5','X2_AXIS/CLAMP_6','X2_AXIS/CLAMP_7','X2_AXIS/CLAMP_8'}}
|
||||
-- *** Tavola ***
|
||||
local TId = EmtAxis {
|
||||
Name = 'T',
|
||||
Parent = 'Base',
|
||||
Token = 'X',
|
||||
Type = MCH_AT.LINEAR,
|
||||
Dir = - X_AX(),
|
||||
Pos = Point3d( DeltaTabX, DeltaTabY, DeltaTabZ),
|
||||
Stroke = {-20000, 20000},
|
||||
Home = LoadT,
|
||||
Geo = 'T_AXIS/GEO'}
|
||||
local TabId = EmtTable {
|
||||
Name = 'Tab',
|
||||
Parent = 'T',
|
||||
Type = MCH_TT.FLAT,
|
||||
Ref1 = Point3d( DeltaTabX, DeltaTabY, DeltaTabZ),
|
||||
Coll = 'Tab/SOLID',
|
||||
Geo = 'TABLE/GEO',
|
||||
Aux = 'TABLE/SOLID'}
|
||||
local Tab2Id = EmtTable {
|
||||
Name = 'Tab2',
|
||||
Parent = 'T',
|
||||
Type = MCH_TT.FLAT,
|
||||
Ref1 = Point3d( DeltaTabX, DeltaTabY, DeltaTabZ),
|
||||
Coll = 'Tab2/SOLID',
|
||||
Geo = 'TABLE2/GEO',
|
||||
Aux = 'TABLE2/SOLID'}
|
||||
-- Gruppop teste ----------
|
||||
local Y1Id = EmtAxis {
|
||||
Name = 'Y1',
|
||||
Parent = 'Base',
|
||||
Token = 'Y',
|
||||
Type = MCH_AT.LINEAR,
|
||||
Dir = Y_AX(),
|
||||
Pos = Point3d( -375, -776, 849.75),
|
||||
Stroke = {MinY1, MaxY1},
|
||||
Home = 0,
|
||||
Geo = 'Y1_AXIS/GEO',
|
||||
Aux = 'Y1_AXIS/SOLID'}
|
||||
local Z1Id = EmtAxis {
|
||||
Name = 'Z1',
|
||||
Parent = 'Y1',
|
||||
Token = 'Z',
|
||||
Type = MCH_AT.LINEAR,
|
||||
Dir = Z_AX(),
|
||||
Pos = Point3d( -262, -811, 883.4),
|
||||
Stroke = {MinZ1, MaxZ1},
|
||||
Home = 0,
|
||||
Geo = 'Z1_AXIS/GEO',
|
||||
Aux = {'Z1_AXIS/SOLID','H11_BODY/H11_SOLID','H11_BODY/H11_COLLISION','H21_BODY/H21_SOLID','H21_BODY/H21_COLLISION','H31_BODY/H31_SOLID','H31_BODY/H31_COLLISION','H41_BODY/H41_SOLID','H41_BODY/H41_COLLISION','MANIPOLATORE/SOLID'}}
|
||||
-- testa 1 ( testa verticale con asse rotante per rinvii con CU) ----------
|
||||
local H11Id = EmtHead {
|
||||
Name = 'H11',
|
||||
Parent = 'Z1',
|
||||
HSet = 'H11',
|
||||
Type = MCH_HT.STD,
|
||||
Pos = H11,
|
||||
TDir = Z_AX(),
|
||||
Geo = 'H11_HEAD/GEO',
|
||||
Aux = 'H11_HEAD/SOLID'}
|
||||
-- asse C su testa 1 per aggregati
|
||||
local C1Id = EmtAxis {
|
||||
Name = 'C1',
|
||||
Parent = 'Z1',
|
||||
Token = 'C',
|
||||
Type = MCH_AT.ROTARY,
|
||||
Dir = Z_AX(),
|
||||
Pos = C1,
|
||||
Stroke = {MinC1, MaxC1},
|
||||
Home = 0,
|
||||
Geo = 'C1_AXIS/GEO',
|
||||
Aux = 'C1_AXIS/SOLID'}
|
||||
-- Testa 2 ( 4 uscite orizzontali rotanti) ----------
|
||||
local C2Id = EmtAxis {
|
||||
Name = 'C2',
|
||||
Parent = 'Z1',
|
||||
Token = 'C',
|
||||
Type = MCH_AT.ROTARY,
|
||||
Dir = Z_AX(),
|
||||
Pos = C2,
|
||||
Stroke = {MinC2, MaxC2},
|
||||
Home = 0,
|
||||
Geo = 'C2_AXIS/GEO',
|
||||
Aux = {'C2_AXIS/SOLID','C2_AXIS/COLLISION'}}
|
||||
local H21Id = EmtHead {
|
||||
Name = 'H21',
|
||||
Parent = 'C2',
|
||||
HSet = 'H21',
|
||||
Type = MCH_HT.MULTI,
|
||||
ExitNbr = 4,
|
||||
Pos1 = H21_1,
|
||||
TDir1 = X_AX(),
|
||||
Pos2 = H21_2,
|
||||
TDir2 = -X_AX(),
|
||||
Pos3 = H21_3,
|
||||
TDir3 = Y_AX(),
|
||||
Pos4 = H21_4,
|
||||
TDir4 = -Y_AX(),
|
||||
ADir = Z_AX(),
|
||||
Geo = 'H21_HEAD/GEO',
|
||||
Aux = {'H21_HEAD/SOLID','H21_HEAD/COLLISION'}}
|
||||
-- testa 3 ( 2 uscite orizzontali fisse) ----------
|
||||
local H31Id = EmtHead {
|
||||
Name = 'H31',
|
||||
Parent = 'Z1',
|
||||
HSet = 'H31',
|
||||
Type = MCH_HT.MULTI,
|
||||
ExitNbr = 2,
|
||||
Pos1 = H31_1,
|
||||
TDir1 = Y_AX(),
|
||||
Pos2 = H31_2,
|
||||
TDir2 = -Y_AX(),
|
||||
ADir = Z_AX(),
|
||||
Geo = 'H31_HEAD/GEO',
|
||||
Aux = {'H31_HEAD/SOLID','H31_HEAD/COLLISION'}}
|
||||
-- testa 4 ( testa verticale fissa) ----------
|
||||
local H41Id = EmtHead {
|
||||
Name = 'H41',
|
||||
Parent = 'Z1',
|
||||
HSet = 'H41',
|
||||
Type = MCH_HT.STD,
|
||||
Pos = H41,
|
||||
TDir = Z_AX(),
|
||||
Geo = 'H41_HEAD/GEO'}
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- Salvo ID morse
|
||||
local ClampsInfo = {}
|
||||
for i = 1, ClampCarNumber do
|
||||
local IdCarr = 0
|
||||
if i == 1 then
|
||||
IdCarr = X1Id
|
||||
elseif i == 2 then
|
||||
IdCarr = X2Id
|
||||
end
|
||||
|
||||
for j = 1, ClampOnCar do
|
||||
local sName = 'CLAMP_' .. tostring( j)
|
||||
local ClampId = EgtGetFirstNameInGroup( IdCarr, sName)
|
||||
local sNameTot = 'CLAMP_' .. tostring( i) .. '_' .. tostring( j)
|
||||
table.insert( ClampsInfo, { Id = ClampId, Name = sNameTot})
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- Funzioni richiamate per modificare i dati macchina in casi particolari
|
||||
---------------------------------------------------------------------
|
||||
local function MoveGroup( nGrpId, vtVers, dPos, bLoc)
|
||||
local dVal = EgtGetInfo( nGrpId, 'Val')
|
||||
if not dVal then return end
|
||||
if abs( dPos - dVal) > GEO.EPS_SMALL then
|
||||
local nRT = EgtIf( bLoc, GDB_RT.LOC, GDB_RT.GLOB)
|
||||
EgtMove( nGrpId, ( dPos - dVal) * vtVers, nRT)
|
||||
EgtSetInfo( nGrpId, 'Val', dPos)
|
||||
end
|
||||
end
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
function SetClamp( nNumClamp, nNumCarr, nPos)
|
||||
|
||||
local nClampId = ClampsInfo[( ( nNumCarr - 1) * ClampOnCar) + nNumClamp].Id
|
||||
local nVal = tonumber( EgtGetInfo( nClampId, 'Val'))
|
||||
if not nVal then return end
|
||||
|
||||
-- controllo che la posizione passata sia nei limiti di pinzaggio
|
||||
if nPos > ClampMaxVert or nPos == 0 then
|
||||
nPos = ClampMaxVert
|
||||
end
|
||||
-- se è cambiata la posizione
|
||||
if abs( nPos - nVal) > GEO.EPS_SMALL * 10 then
|
||||
-- asse di rotazione
|
||||
local RotAxId = EgtGetFirstNameInGroup( nClampId, 'RotAx')
|
||||
local ptAx = EgtSP( RotAxId, GDB_ID.ROOT)
|
||||
local vtAx = EgtSV( RotAxId, GDB_ID.ROOT)
|
||||
local nRot = 0
|
||||
local nZMove = 0
|
||||
-- se devo metterla a riposo bassa disattivata. Situazione precedente in presa sul pezzo o tutta aperta
|
||||
if nPos < 0 then
|
||||
nRot = ClampRotDeact
|
||||
nZMove = -( nVal + ClampDeltaZDeact)
|
||||
-- se devo pinzare il pezzo
|
||||
elseif nPos > 0 then
|
||||
-- se era a riposo devo ruotare e muovere alla quota
|
||||
if nVal < 0 then
|
||||
nRot = -ClampRotDeact
|
||||
nZMove = nPos + ClampDeltaZDeact
|
||||
-- se stava pinzando il pezzo o se era tutta aperta, si cambia solo la Z di pinzaggio
|
||||
else
|
||||
nZMove = nPos - nVal
|
||||
end
|
||||
-- se devo aprirla tutta -> dPos == 0
|
||||
else
|
||||
-- se era a riposo devo ruotare e muovere alla quota
|
||||
if nVal < 0 then
|
||||
nRot = -ClampRotDeact
|
||||
nZMove = nPos + ClampDeltaZDeact
|
||||
-- se stava pinzando il pezzo
|
||||
else
|
||||
nZMove = nPos - nVal
|
||||
end
|
||||
end
|
||||
-- rotazione
|
||||
if nRot ~= 0 then EgtRotate( nClampId, ptAx, vtAx, nRot, GDB_RT.GLOB) end
|
||||
-- movimento Z
|
||||
if nZMove ~= 0 then EgtMove( nClampId, Vector3d( 0, 0, nZMove), GDB_RT.LOC) end
|
||||
EgtSetInfo( nClampId, 'Val', nPos)
|
||||
end
|
||||
end
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
function OnSetTable()
|
||||
end
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
function OnSetHead()
|
||||
-- impegno/disimpegno le teste su gruppi pneumatici
|
||||
-- testa 3 assi con CU
|
||||
MoveGroup( EgtGetFirstNameInGroup( Z1Id, 'H11_SOLID'), Z_AX(), EgtIf( EMC.HEAD == 'H11', 0, 450), true)
|
||||
MoveGroup( EgtGetFirstNameInGroup( Z1Id, 'H11_COLLISION'), Z_AX(), EgtIf( EMC.HEAD == 'H11', 0, 450), true)
|
||||
MoveGroup( EgtGetFirstNameInGroup( H11Id, 'T1'), Z_AX(), EgtIf( EMC.HEAD == 'H11', 0, 450), true)
|
||||
-- testa 4 uscite orizzontali rotanti
|
||||
MoveGroup( EgtGetFirstNameInGroup( Z1Id, 'H21_SOLID'), Z_AX(), EgtIf( EMC.HEAD == 'H21', 0, 300), true)
|
||||
MoveGroup( EgtGetFirstNameInGroup( Z1Id, 'H21_COLLISION'), Z_AX(), EgtIf( EMC.HEAD == 'H21', 0, 300), true)
|
||||
MoveGroup( EgtGetFirstNameInGroup( C2Id, 'SOLID'), Z_AX(), EgtIf( EMC.HEAD == 'H21', 0, 300), true)
|
||||
MoveGroup( EgtGetFirstNameInGroup( C2Id, 'COLLISION'), Z_AX(), EgtIf( EMC.HEAD == 'H21', 0, 300), true)
|
||||
MoveGroup( EgtGetFirstNameInGroup( H21Id, 'SOLID'), Z_AX(), EgtIf( EMC.HEAD == 'H21', 0, 300), true)
|
||||
MoveGroup( EgtGetFirstNameInGroup( H21Id, 'COLLISION'), Z_AX(), EgtIf( EMC.HEAD == 'H21', 0, 300), true)
|
||||
MoveGroup( EgtGetFirstNameInGroup( H21Id, 'T1'), Z_AX(), EgtIf( EMC.HEAD == 'H21', 0, 300), true)
|
||||
MoveGroup( EgtGetFirstNameInGroup( H21Id, 'T2'), Z_AX(), EgtIf( EMC.HEAD == 'H21', 0, 300), true)
|
||||
MoveGroup( EgtGetFirstNameInGroup( H21Id, 'T3'), Z_AX(), EgtIf( EMC.HEAD == 'H21', 0, 300), true)
|
||||
MoveGroup( EgtGetFirstNameInGroup( H21Id, 'T4'), Z_AX(), EgtIf( EMC.HEAD == 'H21', 0, 300), true)
|
||||
-- testa 2 uscite orizzontali fisse
|
||||
MoveGroup( EgtGetFirstNameInGroup( Z1Id, 'H31_SOLID'), Z_AX(), EgtIf( EMC.HEAD == 'H31', 0, 350), true)
|
||||
MoveGroup( EgtGetFirstNameInGroup( Z1Id, 'H31_COLLISION'), Z_AX(), EgtIf( EMC.HEAD == 'H31', 0, 350), true)
|
||||
MoveGroup( EgtGetFirstNameInGroup( H31Id, 'SOLID'), Z_AX(), EgtIf( EMC.HEAD == 'H31', 0, 350), true)
|
||||
MoveGroup( EgtGetFirstNameInGroup( H31Id, 'COLLISION'), Z_AX(), EgtIf( EMC.HEAD == 'H31', 0, 350), true)
|
||||
MoveGroup( EgtGetFirstNameInGroup( H31Id, 'T1'), Z_AX(), EgtIf( EMC.HEAD == 'H31', 0, 350), true)
|
||||
MoveGroup( EgtGetFirstNameInGroup( H31Id, 'T2'), Z_AX(), EgtIf( EMC.HEAD == 'H31', 0, 350), true)
|
||||
-- testa 3 assi
|
||||
MoveGroup( EgtGetFirstNameInGroup( Z1Id, 'H41_SOLID'), Z_AX(), EgtIf( EMC.HEAD == 'H41', 0, 300), true)
|
||||
MoveGroup( EgtGetFirstNameInGroup( Z1Id, 'H41_COLLISION'), Z_AX(), EgtIf( EMC.HEAD == 'H41', 0, 300), true)
|
||||
MoveGroup( EgtGetFirstNameInGroup( H41Id, 'T1'), Z_AX(), EgtIf( EMC.HEAD == 'H41', 0, 300), true)
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- Funzione per resettare tutte le attivazioni della macchina
|
||||
function OnResetMachine()
|
||||
EmtUnlinkAllRawPartsFromGroups()
|
||||
EmtUnlinkAllFixturesFromGroups()
|
||||
-- nascondo Vmill
|
||||
local nRawId = EgtGetFirstRawPart()
|
||||
while nRawId do
|
||||
local nVmId = EgtGetFirstNameInGroup( nRawId, 'VMill')
|
||||
local nId = EgtGetFirstInGroup( nRawId)
|
||||
while nId do
|
||||
EgtSetStatus( nId, EgtIf( nId ~= nVmId, GDB_ST.ON, GDB_ST.OFF))
|
||||
nId = EgtGetNext( nId)
|
||||
end
|
||||
nRawId = EgtGetNextRawPart( nRawId)
|
||||
end
|
||||
EgtSetStatus( EgtGetFirstNameInGroup( GDB_ID.ROOT, 'VMill') or GDB_ID.NULL, GDB_ST.OFF)
|
||||
end
|
||||
@@ -0,0 +1,728 @@
|
||||
-- Special Operations macchina Saomad Just3500 by Egalware s.r.l. 15/01/2024
|
||||
|
||||
-- Intestazioni
|
||||
require( 'EmtGenerator')
|
||||
EgtEnableDebug( false)
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- *** GENERATION ***
|
||||
---------------------------------------------------------------------
|
||||
local sBaseDir = EgtGetSourceDir()
|
||||
if NumericalControl == 'SIEMENS' then
|
||||
dofile( sBaseDir .. 'Saomad-Just3500.SIEMENS.mlpe')
|
||||
else
|
||||
EmtSetLastError( 1201, 'Numerical Control error : unkwnown type')
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- *** SIMULATION ***
|
||||
---------------------------------------------------------------------
|
||||
local COLL_SAFE_DIST = 3
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulInit()
|
||||
EgtSetStatus( EgtGetFirstNameInGroup( EgtGetTableId( 'Tab'), 'SOLID'), GDB_ST.OFF)
|
||||
EgtSetStatus( EgtGetFirstNameInGroup( EgtGetTableId( 'Tab2'), 'SOLID'), GDB_ST.OFF)
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulExit()
|
||||
EgtSetStatus( EgtGetFirstNameInGroup( EgtGetTableId( 'Tab'), 'SOLID'), GDB_ST.ON)
|
||||
EgtSetStatus( EgtGetFirstNameInGroup( EgtGetTableId( 'Tab2'), 'SOLID'), GDB_ST.ON)
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulStart()
|
||||
-- Se reset o home, esco
|
||||
if EMT.SIM1ST then return end
|
||||
-- Creo o svuoto gruppo per copia finale degli oggetti virtual milling
|
||||
local nVmGrpId = EgtGetFirstNameInGroup( GDB_ID.ROOT, 'VMill')
|
||||
if nVmGrpId then
|
||||
EgtSetStatus( nVmGrpId, GDB_ST.ON)
|
||||
EgtEmptyGroup( nVmGrpId)
|
||||
else
|
||||
nVmGrpId = EgtGroup( GDB_ID.ROOT)
|
||||
EgtSetName( nVmGrpId, 'VMill')
|
||||
EgtSetLevel( nVmGrpId, GDB_LV.TEMP)
|
||||
end
|
||||
-- Preparo lista oggetti da verificare per collisioni
|
||||
EMT.COLLOBJ = {}
|
||||
AddToCollisionCheck( 'Z1', 'H11_COLLISION', EMT.COLLOBJ)
|
||||
AddToCollisionCheck( 'Z1', 'H21_COLLISION', EMT.COLLOBJ)
|
||||
AddToCollisionCheck( 'Z1', 'H31_COLLISION', EMT.COLLOBJ)
|
||||
AddToCollisionCheck( 'Z1', 'H41_COLLISION', EMT.COLLOBJ)
|
||||
AddToCollisionCheck( 'C2', 'COLLISION', EMT.COLLOBJ)
|
||||
AddToCollisionCheck( 'H21', 'COLLISION', EMT.COLLOBJ)
|
||||
DumpCollisionCheck( EMT.COLLOBJ, 'Collision Objects :', 4)
|
||||
-- Preparo lista solidi macchina con cui possono collidere gli oggetti sopra riportati (in aggiunta a VMill)
|
||||
EMT.MCODET = {}
|
||||
local McdData = { { Grp = 'X1', Sub = 'COLLISION', Name = {'CAR1'}},
|
||||
{ Grp = 'X1', Sub = 'CLAMP_1', Name = { 'COLLISION1', 'COLLISION2'}},
|
||||
{ Grp = 'X1', Sub = 'CLAMP_2', Name = { 'COLLISION1', 'COLLISION2'}},
|
||||
{ Grp = 'X1', Sub = 'CLAMP_3', Name = { 'COLLISION1', 'COLLISION2'}},
|
||||
{ Grp = 'X1', Sub = 'CLAMP_4', Name = { 'COLLISION1', 'COLLISION2'}},
|
||||
{ Grp = 'X1', Sub = 'CLAMP_5', Name = { 'COLLISION1', 'COLLISION2'}},
|
||||
{ Grp = 'X1', Sub = 'CLAMP_6', Name = { 'COLLISION1', 'COLLISION2'}},
|
||||
{ Grp = 'X1', Sub = 'CLAMP_7', Name = { 'COLLISION1', 'COLLISION2'}},
|
||||
{ Grp = 'X1', Sub = 'CLAMP_8', Name = { 'COLLISION1', 'COLLISION2'}},
|
||||
{ Grp = 'X2', Sub = 'COLLISION', Name = {'CAR2'}},
|
||||
{ Grp = 'X2', Sub = 'CLAMP_1', Name = { 'COLLISION1', 'COLLISION2'}},
|
||||
{ Grp = 'X2', Sub = 'CLAMP_2', Name = { 'COLLISION1', 'COLLISION2'}},
|
||||
{ Grp = 'X2', Sub = 'CLAMP_3', Name = { 'COLLISION1', 'COLLISION2'}},
|
||||
{ Grp = 'X2', Sub = 'CLAMP_4', Name = { 'COLLISION1', 'COLLISION2'}},
|
||||
{ Grp = 'X2', Sub = 'CLAMP_5', Name = { 'COLLISION1', 'COLLISION2'}},
|
||||
{ Grp = 'X2', Sub = 'CLAMP_6', Name = { 'COLLISION1', 'COLLISION2'}},
|
||||
{ Grp = 'X2', Sub = 'CLAMP_7', Name = { 'COLLISION1', 'COLLISION2'}},
|
||||
{ Grp = 'X2', Sub = 'CLAMP_8', Name = { 'COLLISION1', 'COLLISION2'}}}
|
||||
EgtOutLog( 'MCODET Objects :', 4)
|
||||
local nMcdNullCnt = 0
|
||||
for i = 1, #McdData do
|
||||
local nGrpId
|
||||
if McdData[i].Grp == 'Base' then
|
||||
nGrpId = EgtGetBaseId( 'Base')
|
||||
else
|
||||
nGrpId = EgtGetAxisId( McdData[i].Grp)
|
||||
end
|
||||
for j = 1, #McdData[i].Name do
|
||||
local nId = EgtGetFirstNameInGroup( EgtGetFirstNameInGroup( nGrpId, McdData[i].Sub), McdData[i].Name[j])
|
||||
if nId then
|
||||
table.insert( EMT.MCODET, nId)
|
||||
EgtOutLog( 'Element ' .. McdData[i].Grp .. '/' .. McdData[i].Sub .. '/' .. McdData[i].Name[j] .. ' (' .. tostring( nId) .. ') is ok', 4)
|
||||
else
|
||||
nMcdNullCnt = nMcdNullCnt + 1
|
||||
EgtOutLog( 'Element ' .. McdData[i].Grp .. '/' .. McdData[i].Sub .. '/' .. McdData[i].Name[j] .. ' is null', 4)
|
||||
end
|
||||
end
|
||||
end
|
||||
if nMcdNullCnt > 0 then
|
||||
EgtOutLog( 'Warning : MCODET with one or more null Element(s) ')
|
||||
end
|
||||
-- Preparo lista collisioni vuota
|
||||
EMT.COLLIDE = {}
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulEnd()
|
||||
ExecMoveToHome()
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulDispositionStarting()
|
||||
if EMT.PHASE == 2 then
|
||||
-- carrelli tornano in parcheggio
|
||||
local dLoadPos = EgtGetAxisHomePos( 'T')
|
||||
SimulMoveAxes( 'T', dLoadPos, MCH_SIM_STEP.RAPID, 'X1', dLoadPos, MCH_SIM_STEP.RAPID, 'X2', dLoadPos - EMT.X2DELTA, MCH_SIM_STEP.RAPID)
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulDispositionStart()
|
||||
EMT.OPEISDISP = true
|
||||
|
||||
-- se non esiste la lista con le info dei pezzi, la creo
|
||||
if not EMT.PIECES or EMT.PHASE > 1 then
|
||||
EMT.PIECES = {}
|
||||
end
|
||||
-- recupero tutte le info dei pezzi, dimensioni e posizione
|
||||
local nPartRawId = EgtGetFirstRawPart()
|
||||
while nPartRawId do
|
||||
local vPiece = {}
|
||||
-- recupero il solido
|
||||
local nSolId = EgtGetFirstNameInGroup( nPartRawId, 'RawSolid')
|
||||
local b3Raw = EgtGetBBoxGlob( nSolId, GDB_BB.STANDARD)
|
||||
vPiece.Id = nPartRawId
|
||||
vPiece.IdPiece = EgtGetFirstPartInRawPart( nPartRawId)
|
||||
vPiece.SolId = nSolId
|
||||
vPiece.Len = b3Raw:getDimX()
|
||||
vPiece.Wid = b3Raw:getDimY()
|
||||
vPiece.Thk = b3Raw:getDimZ()
|
||||
vPiece.Offs = b3Raw:getMin() -- offset rispetto a zero
|
||||
vPiece.OffTab = b3Raw:getMin() - Vector3d( DeltaTabX, DeltaTabY, DeltaTabZ) -- offset rispetto a zero tavola
|
||||
vPiece.Clamp = {}
|
||||
vPiece.Clamp.dPhase1 = EgtGetInfo( vPiece.IdPiece, 'CLAMPV_1', 'd') or vPiece.Thk
|
||||
vPiece.Clamp.dPhase2 = EgtGetInfo( vPiece.IdPiece, 'CLAMPV_2', 'd') or vPiece.Thk
|
||||
vPiece.Area = vPiece.Len * vPiece.Wid + vPiece.Len * vPiece.Thk + vPiece.Wid * vPiece.Thk
|
||||
table.insert( EMT.PIECES, vPiece)
|
||||
nPartRawId = EgtGetNextRawPart( nPartRawId)
|
||||
end
|
||||
|
||||
-- se ho più di un pezzo, devo aprire carrelli (default sono chiusi)
|
||||
local MAXDIMPIECE1CAR = 1500 -- da InitDisp.lua
|
||||
if #EMT.PIECES > 1 or ( #EMT.PIECES == 1 and EMT.PIECES[1].Len <= MAXDIMPIECE1CAR) then
|
||||
EMT.X2DELTA = 380
|
||||
else
|
||||
EMT.X2DELTA = 0
|
||||
end
|
||||
|
||||
-- Se prima disposizione
|
||||
if EMT.PHASE == 1 then
|
||||
-- imposto carro X2 a interasse
|
||||
EgtSetAxisPos( 'X2', -EMT.X2DELTA)
|
||||
-- Carico primo utensile sulla testa 1
|
||||
EMT.LOAD = true
|
||||
-- Se vero inizio e abilitato creo gli Zmap
|
||||
EMT.VMILL = {}
|
||||
if not EMT.SIM1ST and EgtGetInfo( EgtGetCurrMachGroup(), 'Vm', 'b') then
|
||||
for i = 1, #EMT.PIECES do
|
||||
-- elimino eventuale vecchio Zmap
|
||||
EgtErase( EgtGetFirstNameInGroup( EMT.PIECES[i].Id, 'VMill') or GDB_ID.NULL)
|
||||
-- recupero il solido
|
||||
local nSolId = EgtGetFirstNameInGroup( EMT.PIECES[i].Id, 'RawSolid')
|
||||
-- determino la risoluzione dello Zmap
|
||||
local dArea = EMT.PIECES[i].Area
|
||||
local dTol = 3.77
|
||||
if dArea < CoeffVM * 0.07e6 then
|
||||
dTol = 0.49
|
||||
elseif dArea < CoeffVM * 0.15e6 then
|
||||
dTol = 0.71
|
||||
elseif dArea < CoeffVM * 0.3e6 then
|
||||
dTol = 1.01
|
||||
elseif dArea < CoeffVM * 0.6e6 then
|
||||
dTol = 1.51
|
||||
elseif dArea < CoeffVM * 1.2e6 then
|
||||
dTol = 1.97
|
||||
elseif dArea < CoeffVM * 2.4e6 then
|
||||
dTol = 2.81
|
||||
end
|
||||
-- creo lo Zmap
|
||||
local VMillId = EgtVolZmapBox( EMT.PIECES[i].Id, EMT.PIECES[i].Offs, EMT.PIECES[i].Len, EMT.PIECES[i].Wid, EMT.PIECES[i].Thk, dTol, true, GDB_RT.GLOB)
|
||||
if VMillId then
|
||||
EgtSetName( VMillId, 'VMill')
|
||||
EgtSetLevel( VMillId, GDB_LV.TEMP)
|
||||
EgtSetColor( VMillId, EgtGetColor( nSolId), false)
|
||||
-- nascondo le altre geometrie
|
||||
local nId = EgtGetFirstInGroup( EMT.PIECES[i].Id)
|
||||
while nId do
|
||||
if nId ~= VMillId then
|
||||
EgtSetStatus( nId, GDB_ST.OFF)
|
||||
end
|
||||
nId = EgtGetNext( nId)
|
||||
end
|
||||
table.insert( EMT.VMILL, VMillId)
|
||||
end
|
||||
end
|
||||
end
|
||||
-- se vero inizio, assegno solidi per verifica collisione
|
||||
if not EMT.SIM1ST then
|
||||
EMT.CODET = {}
|
||||
for i = 1, #( EMT.MCODET or {}) do
|
||||
EMT.CODET[i] = EMT.MCODET[i]
|
||||
end
|
||||
for i = 1, #( EMT.VMILL or {}) do
|
||||
table.insert( EMT.CODET, EMT.VMILL[i])
|
||||
end
|
||||
end
|
||||
-- se fase 2
|
||||
else
|
||||
ExecMoveToZmax()
|
||||
end
|
||||
|
||||
-- Nascondo tutte le lavorazioni
|
||||
local nMchId = EgtGetFirstOperation()
|
||||
while nMchId do
|
||||
if EgtGetOperationType( nMchId) ~= MCH_OY.DISP then
|
||||
EgtSetOperationStatus( nMchId, false)
|
||||
end
|
||||
nMchId = EgtGetNextOperation( nMchId)
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulDispositionEnd()
|
||||
-- ottengo il grezzo relativo alla fase
|
||||
local bGotRawIdInfo = false
|
||||
|
||||
-- Aggancio grezzi alla tavola
|
||||
local nRawId = EgtGetFirstRawPart()
|
||||
while nRawId do
|
||||
if not bGotRawIdInfo and EgtVerifyRawPartPhase( nRawId, EMT.PHASE) then
|
||||
nRawIGetInfo = nRawId
|
||||
bGotRawIdInfo = true
|
||||
end
|
||||
local nNextRawId = EgtGetNextRawPart( nRawId)
|
||||
EmtLinkRawPartToGroup( nRawId, EMT.TABNAME)
|
||||
nRawId = nNextRawId
|
||||
end
|
||||
|
||||
-- se fase 1 pinzo direttamente
|
||||
if EMT.PHASE == 1 then
|
||||
-- carico pezzo
|
||||
-- se fase 2, sposto il pezzo in nuova posizione (carrelli già in home da 'OnSimulDispositionStarting')
|
||||
elseif EMT.PHASE == 2 then
|
||||
-- manipolatore prende il pezzo
|
||||
-- apro morse
|
||||
-- manipolatore sposta il pezzo in nuova posizione
|
||||
end
|
||||
|
||||
-- alla fine della disposizione pinzo i pezzi
|
||||
ExecClampPieces()
|
||||
|
||||
-- manipolatore in posizione a parcheggio
|
||||
|
||||
EMT.OPEISDISP = false
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulToolSelect()
|
||||
-- se utensile non definito, è disposizione ed esco
|
||||
if EMT.TOOL == '' then return end
|
||||
-- recupero dati utensile
|
||||
EMT.TOOLTYPE = EgtTdbGetCurrToolParam( MCH_TP.TYPE)
|
||||
EMT.TOTLEN = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN)
|
||||
EMT.TOTDIAM = EgtTdbGetCurrToolParam( MCH_TP.TOTDIAM)
|
||||
-- se attivo Vmill
|
||||
SetToolForVmill( EMT.TOOL, EMT.HEAD, EMT.EXIT, EMT.VMILL)
|
||||
-- se attivo Collision Check
|
||||
EMT.SAFEDIST = COLL_SAFE_DIST
|
||||
if EMT.COLLOBJ then
|
||||
for i, Coll in ipairs( EMT.COLLOBJ) do
|
||||
EmtAddCollisionObjEx( i, Coll.Fr, Coll.Ty, Coll.Mv, Coll.P1, Coll.P2, Coll.P3)
|
||||
end
|
||||
AddToolToCollisionObj( EMT.TOOL, EMT.HEAD, EMT.EXIT, 1001)
|
||||
AddToolHolderToCollisionObj( EMT.TOOL, EMT.HEAD, EMT.EXIT, 1002)
|
||||
end
|
||||
-- breve pausa
|
||||
EgtPause( 100)
|
||||
EgtOutText( '')
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulToolDeselect()
|
||||
|
||||
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulMachiningStart()
|
||||
-- recupero alcuni dati della lavorazione
|
||||
EMT.MCHNAME = EgtGetOperationName( EMT.MCHID)
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulMachiningEnd()
|
||||
-- se ultima lavorazione, visualizzo spigoli
|
||||
if not EgtGetNextActiveOperation( EMT.MCHID) then
|
||||
if EMT.VMILL and #EMT.VMILL > 0 then
|
||||
-- setto che voglio vedere gli spigoli
|
||||
for i = 1, #EMT.VMILL do
|
||||
EgtVolZmapSetShowEdges( EMT.VMILL[i], true)
|
||||
end
|
||||
-- aggiorno la visualizzazione
|
||||
EgtDraw()
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulPathStart()
|
||||
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulPathEnd()
|
||||
-- se attivo VMILL, lavorazione ed è richiesto di eliminare gli sfridi
|
||||
if EMT.VMILL and #EMT.VMILL > 0 and not EMT.OPEISDISP and EMT.VMRS then
|
||||
EgtOutLog( 'OnSimulPathEnd', 5)
|
||||
local vMillId = EMT.VMILL[1]
|
||||
local nPart = EgtVolZmapPartCount( vMillId)
|
||||
if nPart > 1 then
|
||||
-- ricerca del pezzo con massimo volume
|
||||
local nPartMax = 0
|
||||
local dVolMax = 0
|
||||
for i = 1, nPart do
|
||||
local dVol = EgtVolZmapPartVolume( vMillId, i - 1)
|
||||
if dVol > dVolMax then
|
||||
dVolMax = dVol
|
||||
nPartMax = i
|
||||
end
|
||||
end
|
||||
-- eliminazione di tutti i pezzi piccoli
|
||||
for i = nPart, 1, -1 do
|
||||
if i ~= nPartMax then
|
||||
local b3Vmill = EgtVolZmapGetPartBBoxGlob( vMillId, i - 1, GDB_BB.STANDARD)
|
||||
if b3Vmill:getDimX() < 1200 then
|
||||
EgtRemoveVolZmapPart( vMillId, i - 1)
|
||||
end
|
||||
end
|
||||
end
|
||||
-- aggiorno visualizzazione
|
||||
EgtDraw()
|
||||
end
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulMoveStart()
|
||||
-- muovo i carrelli assieme al pezzo
|
||||
EMT.AuxAxes = 2
|
||||
EMT.A1n = 'X1'
|
||||
EMT.A1m = 'T'
|
||||
EMT.A1 = EMT.L1
|
||||
EMT.A2n = 'X2'
|
||||
EMT.A2m = 'T'
|
||||
EMT.A2 = EMT.L1 - EMT.X2DELTA
|
||||
|
||||
-- se standard
|
||||
if EMT.FLAG == 0 or EMT.FLAG == 1 or EMT.FLAG == 2 then
|
||||
-- se primo movimento della lavorazione, gestione speciale
|
||||
if EMT.MCHFIRST then
|
||||
if EMT.GROUP == 1 then
|
||||
-- muovo prima i primi due assi lineari
|
||||
if EMT.L1 and EMT.L2 then
|
||||
SimulMoveAxes( EMT.L1n, EMT.L1, MCH_SIM_STEP.RAPID, EMT.L2n, EMT.L2, MCH_SIM_STEP.RAPID)
|
||||
end
|
||||
-- muovo i restanti assi lineari
|
||||
SimulMoveAxes( EMT.L3n, EMT.L3, MCH_SIM_STEP.RAPID, EMT.R1n, EMT.R1, MCH_SIM_STEP.RAPROT, EMT.R2n, EMT.R2, MCH_SIM_STEP.RAPROT)
|
||||
elseif EMT.GROUP == 4 then
|
||||
SimulMoveAxes( EMT.L1n, EMT.L1, MCH_SIM_STEP.RAPID, EMT.L2n, EMT.L2, MCH_SIM_STEP.RAPID, EMT.R1n, EMT.R1, MCH_SIM_STEP.RAPROT, EMT.R2n, EMT.R2, MCH_SIM_STEP.RAPROT)
|
||||
SimulMoveAxes( EMT.L3n, EMT.L3, MCH_SIM_STEP.RAPID)
|
||||
end
|
||||
|
||||
EMT.MCHFIRST = false
|
||||
else -- caso standard
|
||||
;
|
||||
end
|
||||
-- se altrimenti risalita a Z max a fine lavorazione
|
||||
elseif EMT.FLAG == 3 then
|
||||
ExecMoveToZmax()
|
||||
-- se altrimenti movimento in Home (non si muove la X)
|
||||
elseif EMT.FLAG == 4 then
|
||||
ExecMoveToHome()
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulMoveEnd()
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnSimulCollision()
|
||||
-- se prima collisione della lavorazione, la segnalo
|
||||
if EMT.MCHNAME ~= EMT.LAST_MCHNAME_COLLIDE then
|
||||
local Class = ''
|
||||
if EMT.SIMCOBIND == 1001 then
|
||||
Class = 'T_H1'
|
||||
elseif EMT.SIMCOBIND == 1002 then
|
||||
Class = 'TH_H1'
|
||||
else
|
||||
Class = EMT.COLLOBJ[EMT.SIMCOBIND].Cl
|
||||
end
|
||||
table.insert( EMT.COLLIDE, { Mc = EMT.MCHNAME, Cl = Class, Vm = EMT.SIMVMID})
|
||||
EMT.LAST_MCHNAME_COLLIDE = EMT.MCHNAME
|
||||
EMT.ERR = 1
|
||||
local sErr = 'Mach='..EMT.MCHNAME..'; Class='..Class..'; VMill='..EMT.SIMVMID
|
||||
EmtSetLastError( 1221, sErr, true)
|
||||
EgtOutLog( 'Collision : ' .. sErr, 1)
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function VerifyClampWithRawX( vPiece, dPosClamp)
|
||||
local CLAMP_WID = 100
|
||||
if ( vPiece.OffTab:getX() < dPosClamp) and ( ( vPiece.OffTab:getX() + vPiece.Len) > ( dPosClamp + CLAMP_WID)) then
|
||||
return true
|
||||
end
|
||||
return false
|
||||
end
|
||||
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function VerifyClampWithMachining( vPiece, dPosClamp)
|
||||
-- QQQQQ da controllare con lavorazioni
|
||||
-- per il momento ritorna sempre ok
|
||||
return true
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function ExecClampPieces()
|
||||
-- COSTANTI (da mettere in MLDE)
|
||||
local DIM_CAR = 1430
|
||||
local DIST_CARR_CLOSED = 90
|
||||
local DIMTABY = 250
|
||||
local CLAMP_INTERAX = 190
|
||||
local TOT_CLAMPS_ON_CAR = 8
|
||||
local TOT_CARS = 2
|
||||
|
||||
for i = 1, TOT_CARS do
|
||||
local dDeltaCarr = EgtIf( i == 1, 0, DIM_CAR + DIST_CARR_CLOSED + EMT.X2DELTA)
|
||||
for j = 1, TOT_CLAMPS_ON_CAR do
|
||||
local bFront
|
||||
local dPosClamp = ( j - 1) * CLAMP_INTERAX + dDeltaCarr
|
||||
local bClamp = true
|
||||
local bFound = false
|
||||
local dPieceThikness = 0
|
||||
local k = 1
|
||||
while k <= #EMT.PIECES and not bFound do
|
||||
bFront = EMT.PIECES[k].OffTab:getY() < DIMTABY/2
|
||||
bClamp = VerifyClampWithRawX( EMT.PIECES[k], dPosClamp)
|
||||
bClamp = bClamp and VerifyClampWithMachining( EMT.PIECES[k], dPosClamp)
|
||||
-- al primo controllo che dice che posso pinzare, esco
|
||||
if bClamp then
|
||||
if EMT.PHASE == 1 then
|
||||
dPieceThikness = EMT.PIECES[k].Clamp.dPhase1
|
||||
else
|
||||
dPieceThikness = EMT.PIECES[k].Clamp.dPhase2
|
||||
end
|
||||
bFound = true
|
||||
end
|
||||
k = k + 1
|
||||
end
|
||||
if ( bFront and j == 8) or ( not bFront and j == 1) then bClamp = false end
|
||||
SetClamp( j, i, EgtIf( bClamp, dPieceThikness, -1))
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function ExecMoveToZmax()
|
||||
-- posizioni home degli assi testa
|
||||
local HomeZ = EgtGetAxisHomePos( 'Z1')
|
||||
SimulMoveAxis( 'Z1', HomeZ, MCH_SIM_STEP.RAPID)
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function ExecMoveToHome()
|
||||
-- salgo a ZMAX
|
||||
ExecMoveToZmax()
|
||||
-- posizioni home degli assi testa
|
||||
local HomeY = EgtGetAxisHomePos( 'Y1')
|
||||
local HomeC1 = EgtGetAxisHomePos( 'C1')
|
||||
local HomeC2 = EgtGetAxisHomePos( 'C2')
|
||||
SimulMoveAxes( 'Y1', HomeY, MCH_SIM_STEP.RAPID, 'C1', HomeC1, MCH_SIM_STEP.COLLROT, 'C2', HomeC2, MCH_SIM_STEP.COLLROT)
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- *** ESTIMATION T&L ***
|
||||
---------------------------------------------------------------------
|
||||
local RAPID_X_FEED = 50000 -- mm/min
|
||||
local RAPID_Y_FEED = 50000 -- mm/min
|
||||
local RAPID_Z_FEED = 10000 -- mm/min
|
||||
local RAPID_C_FEED = 8000 -- deg/min
|
||||
local RAPID_B_FEED = 8000 -- deg/min
|
||||
local RAPID_MIN_T = 0.4 -- s
|
||||
local TOOL_CHANGE_T = 15 -- s
|
||||
local TOOL_CHANGE_T4 = 5 -- s
|
||||
local TOOL_CHANGE_TSH = 3 -- s
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEstimStart()
|
||||
EMT.INCHES = not EgtUiUnitsAreMM() -- unità di misura mm/inches
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEstimEnd()
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEstimProgramStart()
|
||||
-- imposto inizio movimenti da Home
|
||||
EMT.L1 = EgtGetAxisHomePos( 'X1')
|
||||
EMT.L2 = EgtGetAxisHomePos( 'Y1')
|
||||
EMT.L3 = EgtGetAxisHomePos( 'Z1')
|
||||
EMT.R1 = EgtGetAxisHomePos( 'C1')
|
||||
EMT.R2 = EgtGetAxisHomePos( 'A1')
|
||||
-- aggiorno valori come precedenti
|
||||
EmtUpdatePrev()
|
||||
-- totalizzatori tempi e lunghezze
|
||||
EMT.TOTCUTLEN = 0
|
||||
EMT.TOTCUTTIME = 0
|
||||
EMT.TOTCUTTIMEPR = 0
|
||||
EMT.TOTCUTTIME1 = 0
|
||||
EMT.TOTCUTTIME2 = 0
|
||||
EMT.TOTCUTTIME3 = 0
|
||||
EMT.TOTEXTLEN = 0
|
||||
EMT.TOTEXTTIME = 0
|
||||
EMT.TOTEXTTIME1 = 0
|
||||
EMT.TOTEXTTIME2 = 0
|
||||
EMT.TOTEXTTIME3 = 0
|
||||
-- variabile per lunghezza taglio utensili
|
||||
EMT.TOOLCUTLEN = {}
|
||||
-- intestazioni
|
||||
EmtTleStart( EMT.INFO)
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEstimProgramEnd()
|
||||
-- stampa dei totali delle lavorazioni
|
||||
-- per il tempo utilizzo quello tra i due più lungo
|
||||
-- (è ovvio che è approssimativo ma meglio che sommare il tempo delle lavorazioni di tutti i gruppi)
|
||||
EMT.TOTCUTTIME = EMT.TOTCUTTIME1 + EMT.TOTEXTTIME1 + EMT.TOTCUTTIME2 + EMT.TOTEXTTIME2 + EMT.TOTCUTTIME3 + EMT.TOTEXTTIME3
|
||||
EMT.TOTCUTTIMEPR = max( (EMT.TOTCUTTIME1+EMT.TOTEXTTIME1), (EMT.TOTCUTTIME2+EMT.TOTEXTTIME2), (EMT.TOTCUTTIME3+EMT.TOTEXTTIME3))
|
||||
EmtTleAddTotal( EmtSecToHMS( EMT.TOTCUTTIME), EmtLenToMF( EMT.TOTCUTLEN))
|
||||
-- stampa dei totali degli utensili
|
||||
for i = 1, #EMT.TOOLCUTLEN do
|
||||
local TCL = EMT.TOOLCUTLEN[i]
|
||||
EmtTleAddTool( TCL.Name, EmtLenToMF( TCL.Len))
|
||||
end
|
||||
-- completo il file
|
||||
local _, _, sExt = EgtSplitPath( EMT.FILE)
|
||||
EmtTleEnd( sExt:sub( 2))
|
||||
-- salvo i dati principali nel progetto
|
||||
EgtSetInfo( EgtGetCurrMachGroup(), 'Ttot' , EgtNumToString( EMT.TOTCUTTIME, 0))
|
||||
EgtSetInfo( EgtGetCurrMachGroup(), 'Ttotpr', EgtNumToString( EMT.TOTCUTTIMEPR, 0))
|
||||
EgtSetInfo( EgtGetCurrMachGroup(), 'Ttot1' , EgtNumToString( (EMT.TOTCUTTIME1+EMT.TOTEXTTIME1), 0))
|
||||
EgtSetInfo( EgtGetCurrMachGroup(), 'Ttot2' , EgtNumToString( (EMT.TOTCUTTIME2+EMT.TOTEXTTIME2), 0))
|
||||
EgtSetInfo( EgtGetCurrMachGroup(), 'Ttot3' , EgtNumToString( (EMT.TOTCUTTIME3+EMT.TOTEXTTIME3), 0))
|
||||
EgtSetInfo( EgtGetCurrMachGroup(), 'Ltot' , EgtNumToString( EMT.TOTCUTLEN, 0))
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEstimDispositionStart()
|
||||
-- inizio disposizione
|
||||
EMT.OPEISDISP = true
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEstimDispositionEnd()
|
||||
-- termine disposizione
|
||||
EMT.OPEISDISP = false
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEstimToolSelect()
|
||||
-- reset indice utensile in tabella lunghezze
|
||||
EMT.TCLIND = 0
|
||||
-- verifico che l'utensile sia definito
|
||||
if #EMT.TOOL == 0 then return end
|
||||
-- cerco l'utensile nella tabella
|
||||
for i = 1, #EMT.TOOLCUTLEN do
|
||||
if EMT.TOOLCUTLEN[i].Name == EMT.TOOL then
|
||||
EMT.TCLIND = i
|
||||
break
|
||||
end
|
||||
end
|
||||
-- se non trovato, lo aggiungo
|
||||
if EMT.TCLIND == 0 then
|
||||
table.insert( EMT.TOOLCUTLEN, { Name = EMT.TOOL, Len = 0})
|
||||
EMT.TCLIND = #EMT.TOOLCUTLEN
|
||||
end
|
||||
|
||||
EMT.GROUP = EgtIf( EMT.HEAD == 'H8', 1, tonumber( EMT.HEAD:sub( 2, 2))) -- calcolo il gruppo per il diverso cambio di utensile
|
||||
|
||||
-- aggiungo tempo di cambio utensile
|
||||
if EMT.GROUP == 4 then
|
||||
EMT.TC_T = TOOL_CHANGE_T4
|
||||
elseif EMT.GROUP == 2 or EMT.GROUP == 3 then
|
||||
EMT.TC_T = TOOL_CHANGE_TSH
|
||||
else
|
||||
EMT.TC_T = TOOL_CHANGE_T
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEstimToolDeselect()
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEstimMachiningStart()
|
||||
EMT.MCHNAME = EgtGetMachiningParam( MCH_MP.NAME)
|
||||
EMT.MCHTYPE = EgtGetMachiningParam( MCH_MP.TYPE)
|
||||
-- reset contatori di lavorazione
|
||||
EMT.MCHCUTLEN = 0
|
||||
EMT.MCHCUTTIME = 0
|
||||
EMT.MCHEXTLEN = 0
|
||||
EMT.MCHEXTTIME = ( EMT.TC_T or 0)
|
||||
EMT.TC_T = 0
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEstimMachiningEnd()
|
||||
-- nel caso di foratura devo dimezzare la lunghezza di taglio perchè comprende anche l'uscita
|
||||
if EMT.MCHTYPE == MCH_MY.DRILLING then
|
||||
EMT.MCHCUTLEN = EMT.MCHCUTLEN / 2
|
||||
end
|
||||
local sName = EgtGetName( EMT.MCHID)
|
||||
EmtTleAddMachining( sName, EmtSecToHMS( EMT.MCHCUTTIME + EMT.MCHEXTTIME), EmtLenToMF( EMT.MCHCUTLEN), EMT.TOOL)
|
||||
-- aggiorno totali e utensili
|
||||
EMT.TOTCUTLEN = EMT.TOTCUTLEN + EMT.MCHCUTLEN
|
||||
if EMT.GROUP == 2 then
|
||||
EMT.TOTCUTTIME2 = EMT.TOTCUTTIME2 + EMT.MCHCUTTIME
|
||||
elseif EMT.GROUP == 3 then
|
||||
EMT.TOTCUTTIME3 = EMT.TOTCUTTIME3 + EMT.MCHCUTTIME
|
||||
else
|
||||
EMT.TOTCUTTIME1 = EMT.TOTCUTTIME1 + EMT.MCHCUTTIME
|
||||
end
|
||||
-- EMT.TOTCUTTIME = EMT.TOTCUTTIME + EMT.MCHCUTTIME
|
||||
if EMT.GROUP == 2 then
|
||||
EMT.TOTEXTTIME2 = EMT.TOTEXTTIME2 + EMT.MCHEXTTIME
|
||||
elseif EMT.GROUP == 3 then
|
||||
EMT.TOTEXTTIME3 = EMT.TOTEXTTIME3 + EMT.MCHEXTTIME
|
||||
else
|
||||
EMT.TOTEXTTIME1 = EMT.TOTEXTTIME1 + EMT.MCHEXTTIME
|
||||
end
|
||||
-- EMT.TOTEXTTIME = EMT.TOTEXTTIME + EMT.MCHEXTTIME
|
||||
EMT.TOTEXTLEN = EMT.TOTEXTLEN + EMT.MCHEXTLEN
|
||||
EMT.TOOLCUTLEN[EMT.TCLIND].Len = EMT.TOOLCUTLEN[EMT.TCLIND].Len + EMT.MCHCUTLEN
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEstimPathStart()
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEstimPathEnd()
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEstimRapid()
|
||||
-- dati movimento
|
||||
local dL1 = EMT.L1 - EMT.L1p
|
||||
local dL2 = EMT.L2 - EMT.L2p
|
||||
local dL3 = EMT.L3 - EMT.L3p
|
||||
local dR1 = 0
|
||||
local dR2 = 0
|
||||
if EMT.R1 and EMT.R1p then dR1 = EMT.R1 - EMT.R1p end
|
||||
if EMT.R2 and EMT.R2p then dR2 = EMT.R2 - EMT.R2p end
|
||||
-- calcolo lunghezza
|
||||
local dLen = sqrt( dL1 * dL1 + dL2 * dL2 + dL3 * dL3)
|
||||
EMT.MCHEXTLEN = EMT.MCHEXTLEN + dLen
|
||||
-- calcolo tempo
|
||||
local dTime = RAPID_MIN_T
|
||||
local dT1 = abs( dL1) / RAPID_X_FEED * 60
|
||||
if dT1 > dTime then dTime = dT1 end
|
||||
local dT2 = abs( dL2) / RAPID_Y_FEED * 60
|
||||
if dT2 > dTime then dTime = dT2 end
|
||||
local dT3 = abs( dL3) / RAPID_Z_FEED * 60
|
||||
if dT3 > dTime then dTime = dT3 end
|
||||
local dT4 = abs( dR1) / RAPID_C_FEED * 60
|
||||
if dT4 > dTime then dTime = dT4 end
|
||||
local dT5 = abs( dR2) / RAPID_B_FEED * 60
|
||||
if dT5 > dTime then dTime = dT5 end
|
||||
EMT.MCHEXTTIME = EMT.MCHEXTTIME + dTime
|
||||
-- aggiorno valori come precedenti
|
||||
EmtUpdatePrev()
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEstimLinear()
|
||||
-- dati movimento
|
||||
local dL1 = EMT.L1 - EMT.L1p
|
||||
local dL2 = EMT.L2 - EMT.L2p
|
||||
local dL3 = EMT.L3 - EMT.L3p
|
||||
-- calcolo lunghezza
|
||||
local dLen = sqrt( dL1 * dL1 + dL2 * dL2 + dL3 * dL3)
|
||||
EMT.MCHCUTLEN = EMT.MCHCUTLEN + dLen
|
||||
-- calcolo tempo
|
||||
local dTime = dLen / EMT.F * 60
|
||||
EMT.MCHCUTTIME = EMT.MCHCUTTIME + dTime
|
||||
-- aggiorno valori come precedenti
|
||||
EmtUpdatePrev()
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function OnEstimArc()
|
||||
-- dati movimento
|
||||
local dLxy = EMT.RR * abs( EMT.AC) * pi / 180
|
||||
local dLz = abs( ( Point3d( EMT.L1, EMT.L2, EMT.L3) - Point3d( EMT.L1p, EMT.L2p, EMT.L3p)) * Vector3d( EMT.EXTR))
|
||||
-- calcolo lunghezza
|
||||
local dLen = sqrt( dLxy * dLxy + dLz * dLz)
|
||||
EMT.MCHCUTLEN = EMT.MCHCUTLEN + dLen
|
||||
-- calcolo tempo
|
||||
local dTime = dLen / EMT.F * 60
|
||||
EMT.MCHCUTTIME = EMT.MCHCUTTIME + dTime
|
||||
-- aggiorno valori come precedenti
|
||||
EmtUpdatePrev()
|
||||
end
|
||||
|
||||
@@ -0,0 +1,6 @@
|
||||
-- Special Operations macchina Saomad Just3500 by Egalware s.r.l. 15/01/2024
|
||||
|
||||
-- Intestazioni
|
||||
require( 'EmtGenerator')
|
||||
EgtEnableDebug( false)
|
||||
|
||||
Binary file not shown.
@@ -0,0 +1,250 @@
|
||||
-- Disposition Init for Saomad Just3500 2024/02/07
|
||||
|
||||
-- Intestazioni
|
||||
require( 'EgtBase')
|
||||
_ENV = EgtProtectGlobal()
|
||||
EgtEnableDebug( false)
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
-- Colore del grezzo
|
||||
local ColA = Color3d( 255, 165, 0, 30)
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
-- COSTANTI
|
||||
local DIM_CAR = 1430
|
||||
local DIST_CARR_OPEN = 470
|
||||
local DIMTABY = 250
|
||||
local MAXDIMPIECE1CAR = 1500
|
||||
local TABNAME_1PZ = 'Tab'
|
||||
local TABNAME_2PZ = 'Tab2'
|
||||
|
||||
-- Variabili globali modulo
|
||||
local vPiece = {}
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
-- * Verifica esistenza MachGroup *
|
||||
if not EgtGetCurrMachGroup() then
|
||||
EgtOutLog( 'InitDisp for Saomad-Just3500 : missing CurrMachGroup')
|
||||
DISP.ERR = 1
|
||||
return
|
||||
end
|
||||
|
||||
-------------------------------------------------------------------------------------------------------------
|
||||
-- recupero i pezzi da processare
|
||||
function MyProcessInputData()
|
||||
-- controllo che esista il pezzo
|
||||
local nIdpz = DISP.PARTID
|
||||
if not nIdpz or nIdpz == GDB_ID.NULL then
|
||||
DISP.ERR = 0
|
||||
return false
|
||||
end
|
||||
|
||||
-- Recupero i dati del pezzo
|
||||
local nId = EgtGetFirstNameInGroup( nIdpz, 'Solid')
|
||||
if not nId then
|
||||
EgtOutBox( 'SOLID non definito per pezzo: ' .. EgtGetName( nIdpz), 'Info', 'ERROR')
|
||||
return false
|
||||
end
|
||||
|
||||
-- salvo i pezzi in lista
|
||||
local vsPiece = EgtSplitString( DISP.PARTS)
|
||||
|
||||
for i = 1, #vsPiece do
|
||||
table.insert( vPiece, { Ind = #vPiece + 1, Id = tonumber( vsPiece[i]), Name = ( EgtGetName( vsPiece[i]) or ( 'Id=' .. tonumber( vsPiece[i])))})
|
||||
local Ls = EgtGetFirstNameInGroup( vPiece[i].Id, 'Box')
|
||||
local b3Solid = EgtGetBBoxGlob( Ls or GDB_ID.NULL, GDB_BB.STANDARD)
|
||||
if not b3Solid then
|
||||
EgtOutBox( 'Box non definito per il pezzo ' .. vPiece[i].Name, 'Lavora Pezzi', 'ERROR')
|
||||
return false
|
||||
else
|
||||
vPiece[i].Box = b3Solid
|
||||
vPiece[i].Len = vPiece[i].Box:getDimX()
|
||||
vPiece[i].Wid = vPiece[i].Box:getDimY()
|
||||
end
|
||||
end
|
||||
|
||||
return true
|
||||
end
|
||||
|
||||
-------------------------------------------------------------------------------------------------------------
|
||||
-- operazione sui pezzi
|
||||
function MyProcessPieces()
|
||||
--------------------------------------------------------------------------------
|
||||
-- *** Disposizione ***
|
||||
-- scelta della configurazione tavola in base al numero di pezzi
|
||||
if not vPiece or #vPiece > 2 then
|
||||
EgtOutBox( 'ATTENZIONE : massimo due pezzi per macchinata', 'Lavora Pezzi', 'ERROR')
|
||||
return false
|
||||
-- se ho un pezzo
|
||||
elseif #vPiece == 1 then
|
||||
EgtSetTable( TABNAME_1PZ)
|
||||
-- se ho due pezzi
|
||||
else
|
||||
EgtSetTable( TABNAME_2PZ)
|
||||
end
|
||||
|
||||
-- controllo che le dimensioni siano compatibili
|
||||
if #vPiece == 1 then
|
||||
if vPiece[DISP.IND].Len > ( DIM_CAR + DIST_CARR_OPEN + DIM_CAR) then
|
||||
EgtOutBox( 'ATTENZIONE : pezzo troppo lungo', 'Lavora Pezzi', 'ERROR')
|
||||
return false
|
||||
end
|
||||
else
|
||||
if vPiece[DISP.IND].Len > MAXDIMPIECE1CAR then
|
||||
EgtOutBox( 'ATTENZIONE : pezzo ' .. vPiece[DISP.IND].Name .. ' troppo lungo', 'Lavora Pezzi', 'ERROR')
|
||||
return false
|
||||
end
|
||||
end
|
||||
|
||||
-- dati di default
|
||||
local sHeadSporgF1 = '40'
|
||||
local sHeadSporgF2 = '40'
|
||||
local sSideSporgF1 = '40'
|
||||
local sSideSporgF2 = '40'
|
||||
local sPosZF1 = '0'
|
||||
local sPosZF2 = '0'
|
||||
|
||||
-- cerco se ci sono delle note di offset sul pezzo
|
||||
local dHeadSporgF1 = nil
|
||||
local dHeadSporgF2 = nil
|
||||
local dSideSporgF1 = EgtGetInfo( vPiece[DISP.IND].Id, 'OFFY_1', 'd')
|
||||
local dSideSporgF2 = EgtGetInfo( vPiece[DISP.IND].Id, 'OFFY_2', 'd')
|
||||
local dPosZF1 = EgtGetInfo( vPiece[DISP.IND].Id, 'OFFZ_1', 'd')
|
||||
local dPosZF2 = EgtGetInfo( vPiece[DISP.IND].Id, 'OFFZ_2', 'd')
|
||||
|
||||
local bInsertAllOffs = false
|
||||
-- se non tutti gli offset Y-Z sono settati, avviso e poi chiedo tutti i dati
|
||||
if not( dSideSporgF1 and dSideSporgF2 and dPosZF1 and dPosZF2) then
|
||||
EgtOutBox( 'OFFSET di posizionamento non trovati. Inserire tutti i dati per calcolo posizionamento', 'ATTENZIONE PEZZO : ' .. vPiece[DISP.IND].Name, 'WARNING', 'OK')
|
||||
bInsertAllOffs = true
|
||||
end
|
||||
|
||||
-- assegno alle stringhe i valori letti, in modo che vengano proposti quelli nel dialogo
|
||||
sHeadSporgF1 = EgtIf( dHeadSporgF1, tostring( dHeadSporgF1), '40')
|
||||
sHeadSporgF2 = EgtIf( dHeadSporgF2, tostring( dHeadSporgF2), '40')
|
||||
sSideSporgF1 = EgtIf( dSideSporgF1, tostring( dSideSporgF1), '40')
|
||||
sSideSporgF2 = EgtIf( dSideSporgF2, tostring( dSideSporgF2), '40')
|
||||
sPosZF1 = EgtIf( dPosZF1, tostring( dPosZF1), '0')
|
||||
sPosZF2 = EgtIf( dPosZF2, tostring( dPosZF2), '0')
|
||||
|
||||
-- se devo inserire tutti gli offset
|
||||
if bInsertAllOffs then
|
||||
local vInp = EgtDialogBox( 'Dati di disposizione pezzo: ' .. vPiece[DISP.IND].Name,
|
||||
{'Sporgenza Testa FASE1', sHeadSporgF1}, {'Sporgenza laterale FASE1', sSideSporgF1}, {'Posizione Z FASE1', sPosZF1},
|
||||
{'Sporgenza Testa FASE2', sHeadSporgF2}, {'Sporgenza laterale FASE2', sSideSporgF2}, {'Posizione Z FASE2', sPosZF2})
|
||||
if not vInp or #vInp == 0 then
|
||||
DISP.ERR = 100
|
||||
return
|
||||
end
|
||||
-- salvo input nei valori che utilizzerò dopo
|
||||
dHeadSporgF1 = tonumber( vInp[1])
|
||||
dSideSporgF1 = tonumber( vInp[2])
|
||||
dPosZF1 = tonumber( vInp[3])
|
||||
dHeadSporgF2 = tonumber( vInp[4])
|
||||
dSideSporgF2 = tonumber( vInp[5])
|
||||
dPosZF2 = tonumber( vInp[6])
|
||||
else
|
||||
local vInp = EgtDialogBox( 'Dati di disposizione pezzo: ' .. vPiece[DISP.IND].Name, {'Sporgenza Testa FASE1', sHeadSporgF1}, {'Sporgenza Testa FASE2', sHeadSporgF2})
|
||||
if not vInp or #vInp == 0 then
|
||||
DISP.ERR = 100
|
||||
return
|
||||
end
|
||||
dHeadSporgF1 = tonumber( vInp[1])
|
||||
dHeadSporgF2 = tonumber( vInp[2])
|
||||
end
|
||||
|
||||
local dPosX = 0
|
||||
local dPosY = 0
|
||||
local dPosZ = 0
|
||||
local dOverMat = 0
|
||||
local nRawID
|
||||
local vtOffs = Vector3d( 0, 0, 0)
|
||||
|
||||
-- PRIMA FASE
|
||||
EgtSetCurrPhase( 1)
|
||||
-- Abilito Vmill
|
||||
EgtSetInfo( EgtGetCurrMachGroup(), 'Vm', '1')
|
||||
|
||||
-- posizionamento pezzi prima fase
|
||||
-- setto gli offset iniziali
|
||||
if DISP.IND == 2 then dPosX = DIM_CAR + DIST_CARR_OPEN end
|
||||
dPosX = dPosX - dHeadSporgF1
|
||||
dPosY = dPosY - dSideSporgF1
|
||||
dPosZ = dPosZF1
|
||||
|
||||
vtOffs = Vector3d( dPosX, dPosY, dPosZ)
|
||||
|
||||
-- Definizione e posizionamento del grezzo
|
||||
if vPiece[DISP.IND].Raw then
|
||||
nRawID = EgtAddRawPartWithPart( vPiece[DISP.IND].Id, vPiece[DISP.IND].Raw, 0, ColA)
|
||||
EgtSetStatus( Er, GDB_ST.ON)
|
||||
else
|
||||
nRawID = EgtAddRawPartWithPart( vPiece[DISP.IND].Id, GDB_ID.NULL, dOverMat, ColA)
|
||||
end
|
||||
if not nRawID then
|
||||
EgtOutLog( 'InitDisp for Saomad-Just3500 : error defining raw part')
|
||||
DISP.ERR = 3
|
||||
return false
|
||||
end
|
||||
-- ammetto di uscire dalla tavola dello sbordo calcolato
|
||||
EgtSetTableAreaOffset( 100, 100, 100, 100)
|
||||
if not EgtMoveToCornerRawPart( nRawID, vtOffs, MCH_CR.BL) then
|
||||
EgtOutLog( 'InitDisp for Saomad-Just3500 : error positioning raw part on table')
|
||||
DISP.ERR = 4
|
||||
return false
|
||||
end
|
||||
|
||||
|
||||
-- creo la seconda fase se primo pezzo
|
||||
if DISP.IND == 1 then
|
||||
EgtAddPhase()
|
||||
-- altrimenti setto la due come corrente
|
||||
else
|
||||
EgtSetCurrPhase( 2)
|
||||
end
|
||||
|
||||
-- ammetto di uscire dalla tavola dello sbordo calcolato
|
||||
EgtSetTableAreaOffset( 100, 100, 100, 100)
|
||||
-- posizionamento pezzi seconda fase
|
||||
-- reset offset
|
||||
dPosX = 0 ; dPosY = DIMTABY ;
|
||||
-- se sono al secondo pezzo da inserire, lo metto sul secondo carrello
|
||||
if DISP.IND == 2 then
|
||||
dPosX = DIM_CAR + DIST_CARR_OPEN + DIM_CAR
|
||||
-- se primo pezzo
|
||||
else
|
||||
if vPiece[DISP.IND].Len > MAXDIMPIECE1CAR then
|
||||
dPosX = DIM_CAR + DIST_CARR_OPEN + DIM_CAR
|
||||
else
|
||||
dPosX = DIM_CAR
|
||||
end
|
||||
end
|
||||
|
||||
EgtKeepRawPart( nRawID)
|
||||
dPosX = dPosX - vPiece[DISP.IND].Len + dHeadSporgF2
|
||||
dPosY = dPosY - vPiece[DISP.IND].Wid + dSideSporgF2
|
||||
dPosZ = dPosZF2
|
||||
|
||||
vtOffs = Vector3d( dPosX, dPosY, dPosZ)
|
||||
|
||||
EgtMoveToCornerRawPart( nRawID, vtOffs, MCH_CR.BL)
|
||||
|
||||
DISP.ERR = 0
|
||||
return true
|
||||
end
|
||||
|
||||
-------------------------------------------------------------------------------------------------------------
|
||||
-- operazioni sulle lavorazioni
|
||||
function MyProcessFeatures()
|
||||
-- per il momento non applico lavorazioni
|
||||
return true
|
||||
end
|
||||
|
||||
-------------------------------------------------------------------------------------------------------------
|
||||
-- *** Esecuzione ***
|
||||
-------------------------------------------------------------------------------------------------------------
|
||||
if not MyProcessInputData() then return end
|
||||
|
||||
if not MyProcessPieces() then return end
|
||||
|
||||
if not MyProcessFeatures() then return end
|
||||
@@ -0,0 +1,44 @@
|
||||
-- 2018/11/21 16:30:00
|
||||
-- Machining Init for Essetre-FAST machine
|
||||
|
||||
-- Intestazioni
|
||||
require( 'EgtBase')
|
||||
_ENV = EgtProtectGlobal()
|
||||
EgtEnableDebug( false)
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
-- *** Ingresso in Lavorazioni ***
|
||||
|
||||
-- Rendo visibile il pezzo e le geometrie aggiunte, nascondo il Box
|
||||
local function ProcessPart( PartId)
|
||||
-- nascondo il Box
|
||||
EgtSetStatus( EgtGetFirstNameInGroup( PartId, 'Box') or GDB_ID.NULL, GDB_ST.OFF)
|
||||
end
|
||||
|
||||
-- Disabilito segnalazione modifica progetto
|
||||
local bEnMod = EgtGetEnableModified()
|
||||
EgtDisableModified()
|
||||
|
||||
-- Processo i pezzi nella radice
|
||||
local PartId = EgtGetFirstPart()
|
||||
while PartId do
|
||||
ProcessPart( PartId)
|
||||
PartId = EgtGetNextPart( PartId)
|
||||
end
|
||||
|
||||
-- Processo i pezzi già nei gruppi di lavoro (quando appena lanciata Process)
|
||||
local GhostId = EgtGetFirstGhostPart()
|
||||
while GhostId do
|
||||
local PartId = EgtGetInfo( GhostId, GDB_SI.SOURCE, 'i')
|
||||
if PartId then
|
||||
ProcessPart( PartId)
|
||||
end
|
||||
GhostId = EgtGetNextGhostPart( GhostId)
|
||||
end
|
||||
|
||||
-- Ripristino segnalazione modifica progetto
|
||||
if bEnMod then
|
||||
EgtEnableModified()
|
||||
end
|
||||
|
||||
MACH.ERR = 0
|
||||
@@ -0,0 +1,211 @@
|
||||
-- by Egalware s.r.l. 2024/01/15
|
||||
-- Gestione attrezzaggio
|
||||
|
||||
-- Intestazioni
|
||||
require( 'EgtBase')
|
||||
_ENV = EgtProtectGlobal()
|
||||
EgtEnableDebug( false)
|
||||
|
||||
-- Tavola di passaggio valori
|
||||
local STU = {}
|
||||
STU.TUUID = ""
|
||||
STU.TCPOS = ""
|
||||
STU.HEAD = ""
|
||||
STU.GROUP = ""
|
||||
STU.POS = ""
|
||||
STU.EXIT = 0
|
||||
STU.INDEX = 0
|
||||
STU.HEAD1 = ""
|
||||
STU.HEAD2 = ""
|
||||
STU.ISVALID = false
|
||||
STU.ERR = 0
|
||||
_G.STU = STU
|
||||
|
||||
local INVALIDPOS = ""
|
||||
local POS = "Pos"
|
||||
|
||||
-- Geom Set
|
||||
local GS = {}
|
||||
|
||||
-- Configurazione posizioni
|
||||
local PositionTable={{Pos = "Pos1", TcPos = "T101", Head = "H11", Group = "G1"},
|
||||
{Pos = "Pos2", TcPos = "T102", Head = "H11", Group = "G1"},
|
||||
{Pos = "Pos3", TcPos = "T103", Head = "H11", Group = "G1"},
|
||||
{Pos = "Pos4", TcPos = "T104", Head = "H11", Group = "G1"},
|
||||
{Pos = "Pos5", TcPos = "T105", Head = "H11", Group = "G1"},
|
||||
{Pos = "Pos6", TcPos = "T106", Head = "H11", Group = "G1"},
|
||||
{Pos = "Pos7", TcPos = "T107", Head = "H11", Group = "G1"},
|
||||
{Pos = "Pos8", TcPos = "T108", Head = "H11", Group = "G1"},
|
||||
{Pos = "Pos9", TcPos = "T109", Head = "H11", Group = "G1"},
|
||||
{Pos = "Pos10", TcPos = "T110", Head = "H11", Group = "G1"},
|
||||
{Pos = "Pos11", TcPos = "T111", Head = "H11", Group = "G1"},
|
||||
{Pos = "Pos12", TcPos = "T112", Head = "H11", Group = "G1"},
|
||||
{Pos = "Pos13", TcPos = "T113", Head = "H11", Group = "G1"},
|
||||
{Pos = "Pos14", TcPos = "T114", Head = "H11", Group = "G1"},
|
||||
{Pos = "Pos15", TcPos = "T115", Head = "H11", Group = "G1"},
|
||||
{Pos = "Pos16", TcPos = "T116", Head = "H11", Group = "G1"},
|
||||
{Pos = "Pos17", TcPos = "T117", Head = "H11", Group = "G1"},
|
||||
{Pos = "Pos18", TcPos = "T118", Head = "H11", Group = "G1"},
|
||||
{Pos = "Pos19", TcPos = "T119", Head = "H11", Group = "G1"},
|
||||
{Pos = "Pos20", TcPos = "T120", Head = "H11", Group = "G1"},
|
||||
{Pos = "Pos21", TcPos = "T201", Head = "H21", Group = "G2"},
|
||||
{Pos = "Pos22", TcPos = "T301", Head = "H31", Group = "G3"},
|
||||
{Pos = "Pos23", TcPos = "T401", Head = "H41", Group = "G4"}}
|
||||
|
||||
local UsePositionHead = false
|
||||
|
||||
local function IsInGeomSet( ToolHead, PosHead)
|
||||
for GsIndex = 1, #GS do
|
||||
local bToolHead = false
|
||||
local bPosHead = false
|
||||
for HIndex = 1, #GS[GsIndex] do
|
||||
if GS[GsIndex][HIndex] == ToolHead then
|
||||
bToolHead = true
|
||||
elseif GS[GsIndex][HIndex] == PosHead then
|
||||
bPosHead = true
|
||||
end
|
||||
if bToolHead and bPosHead then
|
||||
return true
|
||||
end
|
||||
end
|
||||
if bToolHead and bPosHead then
|
||||
return true
|
||||
end
|
||||
end
|
||||
return false
|
||||
end
|
||||
|
||||
function STU.IsCompatibleHeads()
|
||||
STU.ISVALID = false
|
||||
if IsInGeomSet(STU.HEAD1, STU.HEAD2) then
|
||||
STU.ISVALID = true
|
||||
else
|
||||
STU.ISVALID = false
|
||||
end
|
||||
end
|
||||
|
||||
function STU.GetValidHeadExitForPos()
|
||||
-- se TUUID non valido restituisco errore
|
||||
local ToolName = EgtTdbGetToolFromUUID( STU.TUUID)
|
||||
if ToolName == nill then
|
||||
STU.ERR = 1
|
||||
return
|
||||
end
|
||||
EgtTdbSetCurrTool( ToolName)
|
||||
local CurrToolHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
|
||||
STU.EXIT = EgtTdbGetCurrToolParam( MCH_TP.EXIT)
|
||||
-- recupero testa predefinita per la posizione corrente
|
||||
local CurrPosHead
|
||||
for i = 1, #PositionTable do
|
||||
if PositionTable[i].TcPos == STU.TCPOS then
|
||||
CurrPosHead = PositionTable[i].Head
|
||||
break
|
||||
end
|
||||
end
|
||||
-- verifico se la testa è quella della posizione predefinita
|
||||
if CurrPosHead == CurrToolHead then
|
||||
STU.HEAD = CurrToolHead
|
||||
STU.ERR = 0
|
||||
return
|
||||
-- verifico se la testa è compatibile con quella della posizione predefinita
|
||||
elseif IsInGeomSet( CurrToolHead, CurrPosHead) then
|
||||
if UsePositionHead then
|
||||
STU.HEAD = CurrPosHead
|
||||
STU.ERR = 0
|
||||
return
|
||||
else
|
||||
STU.HEAD = CurrToolHead
|
||||
STU.ERR = 0
|
||||
return
|
||||
end
|
||||
-- la testa non è compatibile con quella della posizione predefinita
|
||||
else
|
||||
STU.HEAD = INVALIDPOS
|
||||
STU.ERR = 0
|
||||
return
|
||||
end
|
||||
end
|
||||
|
||||
function STU.IsValidTcPosFromHead()
|
||||
STU.ISVALID = false
|
||||
for i = 1, #PositionTable do
|
||||
if PositionTable[i].TcPos == STU.TCPOS then
|
||||
if PositionTable[i].Head == STU.HEAD then
|
||||
STU.ISVALID = true
|
||||
STU.ERR = 0
|
||||
return
|
||||
elseif IsInGeomSet(PositionTable[i].Head, STU.HEAD) then
|
||||
STU.ISVALID = true
|
||||
STU.ERR = 0
|
||||
return
|
||||
end
|
||||
STU.ISVALID = false
|
||||
STU.ERR = 0
|
||||
return
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function STU.GetTcPosHeadGroupFromPos()
|
||||
for i = 1, #PositionTable do
|
||||
if PositionTable[i].Pos == (POS .. tostring(STU.INDEX)) then
|
||||
STU.TCPOS = PositionTable[i].TcPos
|
||||
STU.HEAD = PositionTable[i].Head
|
||||
STU.GROUP = PositionTable[i].Group
|
||||
STU.ERR = 0
|
||||
return
|
||||
end
|
||||
end
|
||||
STU.TCPOS = INVALIDPOS
|
||||
STU.HEAD = INVALIDPOS
|
||||
STU.GROUP = INVALIDPOS
|
||||
STU.ERR = 1
|
||||
end
|
||||
|
||||
function STU.GetPosFromTcPos()
|
||||
for i = 1, #PositionTable do
|
||||
if PositionTable[i].TcPos == STU.TCPOS then
|
||||
STU.POS = PositionTable[i].Pos
|
||||
STU.ERR = 0
|
||||
return
|
||||
end
|
||||
end
|
||||
STU.POS = INVALIDPOS
|
||||
STU.ERR = 1
|
||||
end
|
||||
|
||||
function STU.GetGroupFromTcPos()
|
||||
for i = 1, #PositionTable do
|
||||
if PositionTable[i].TcPos == STU.TCPOS then
|
||||
STU.GROUP = PositionTable[i].Group
|
||||
STU.ERR = 0
|
||||
return
|
||||
end
|
||||
end
|
||||
STU.GROUP = INVALIDPOS
|
||||
STU.ERR = 1
|
||||
end
|
||||
|
||||
function STU.GetHeadFromPos()
|
||||
for i = 1, #PositionTable do
|
||||
if PositionTable[i].Pos == (POS .. tostring(STU.INDEX)) then
|
||||
STU.HEAD = PositionTable[i].Head
|
||||
STU.ERR = 0
|
||||
return
|
||||
end
|
||||
end
|
||||
STU.HEAD = INVALIDPOS
|
||||
STU.ERR = 1
|
||||
end
|
||||
|
||||
function STU.GetTcPosFromPos()
|
||||
for i = 1, #PositionTable do
|
||||
if PositionTable[i].Pos == (POS .. tostring(STU.INDEX)) then
|
||||
STU.TCPOS = PositionTable[i].TcPos
|
||||
STU.ERR = 0
|
||||
return
|
||||
end
|
||||
end
|
||||
STU.TCPOS = INVALIDPOS
|
||||
STU.ERR = 1
|
||||
end
|
||||
@@ -0,0 +1,164 @@
|
||||
-- WinData.lua by Egalware s.r.l. 2024/06/13
|
||||
-- Raccolta dati generali per Serramenti
|
||||
|
||||
EgtOutLog( ' Just3500-WinData started', 1)
|
||||
|
||||
-- Tabella per definizione modulo
|
||||
local WinData = {
|
||||
-- COSTANTI
|
||||
MACH_TYPE = 'LINE',
|
||||
FIRST_PHASE_LOAD = 'PUSH',
|
||||
DIM_CAR = 1430,
|
||||
DIST_CARR_OPEN = 470,
|
||||
DIST_CARR_CLOSE = 90,
|
||||
DIMTABY = 250,
|
||||
MAXDIMPIECE1CAR = 1500,
|
||||
TABNAME_1PZ = 'Tab',
|
||||
TABNAME_2PZ = 'Tab2',
|
||||
PART_ALIGN = Vector3d( 1, 0, 0)
|
||||
}
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- Verifica che i pezzi da processare siano compatibili con la configurazione della macchina
|
||||
---------------------------------------------------------------------
|
||||
local function VerifyPieces( PARTS)
|
||||
if not PARTS or #PARTS > 2 then
|
||||
EgtOutBox( 'ATTENZIONE : massimo due pezzi per macchinata', 'Lavora Pezzi', 'ERROR')
|
||||
return false
|
||||
end
|
||||
|
||||
-- controllo che le dimensioni siano compatibili
|
||||
for i = 1, #PARTS do
|
||||
if #PARTS == 1 then
|
||||
if PARTS[i].dPartLength > ( WinData.DIM_CAR + WinData.DIST_CARR_OPEN + WinData.DIM_CAR) then
|
||||
EgtOutBox( 'ATTENZIONE : pezzo troppo lungo', 'Lavora Pezzi', 'ERROR')
|
||||
return false
|
||||
end
|
||||
else
|
||||
if PARTS[i].dPartLength > WinData.MAXDIMPIECE1CAR then
|
||||
EgtOutBox( 'ATTENZIONE : pezzo ' .. PARTS[i].sName .. ' troppo lungo', 'Lavora Pezzi', 'ERROR')
|
||||
return false
|
||||
end
|
||||
end
|
||||
end
|
||||
return true
|
||||
end
|
||||
WinData.VerifyPieces = VerifyPieces
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- Dispone i pezzi in macchina
|
||||
---------------------------------------------------------------------
|
||||
local function ExecDisposition( PARTS)
|
||||
|
||||
-- si verifica che i pezzi selezionati siano compatibili con la macchina
|
||||
VerifyPieces( PARTS)
|
||||
|
||||
-- se ho un pezzo
|
||||
if #PARTS == 1 then
|
||||
EgtSetTable( WinData.TABNAME_1PZ)
|
||||
-- se ho due pezzi
|
||||
else
|
||||
EgtSetTable( WinData.TABNAME_2PZ)
|
||||
end
|
||||
|
||||
|
||||
-- fase 1 (non serve creare fase 1 perchè già presente alla creazione del machgroup)
|
||||
EgtSetCurrPhase( 1)
|
||||
for i = 1, #PARTS do
|
||||
local dPosX = 0
|
||||
local dPosY = 0
|
||||
local dPosZ = 0
|
||||
-- posizionamento pezzi prima fase
|
||||
-- setto gli offset iniziali
|
||||
if i == 2 then dPosX = WinData.DIM_CAR + WinData.DIST_CARR_OPEN end
|
||||
dPosX = dPosX - PARTS[i].OffsetPartToRaw.X
|
||||
dPosY = - PARTS[i].OffsetPartToRaw.Y - PARTS[i].DispOffsets.Phase1.dOffsetY
|
||||
dPosZ = 0
|
||||
|
||||
local vtOffs = Vector3d( dPosX, dPosY, dPosZ)
|
||||
|
||||
-- ammetto di uscire dalla tavola dello sbordo calcolato
|
||||
EgtSetTableAreaOffset( 100, 100, 100, 100)
|
||||
EgtSetStatus( PARTS[i].idRaw, GDB_ST.ON)
|
||||
|
||||
if not EgtMoveToCornerRawPart( PARTS[i].idRaw, vtOffs, MCH_CR.BL) then
|
||||
EgtOutLog( 'InitDisp for Saomad-Just3500 : error positioning raw part on table')
|
||||
return false
|
||||
end
|
||||
end
|
||||
|
||||
-- fase 2
|
||||
EgtAddPhase()
|
||||
EgtSetCurrPhase( 2)
|
||||
for i = 1, #PARTS do
|
||||
-- ammetto di uscire dalla tavola dello sbordo calcolato
|
||||
EgtSetTableAreaOffset( 100, 100, 100, 100)
|
||||
-- posizionamento pezzi seconda fase
|
||||
-- reset offset
|
||||
local dPosX = 0
|
||||
local dPosY = WinData.DIMTABY
|
||||
local dPosZ = 0
|
||||
-- se sono al secondo pezzo da inserire, lo metto sul secondo carrello
|
||||
if i == 2 then
|
||||
dPosX = WinData.DIM_CAR + WinData.DIST_CARR_OPEN + WinData.DIM_CAR
|
||||
-- se primo pezzo
|
||||
else
|
||||
if PARTS[i].dPartLength > WinData.MAXDIMPIECE1CAR then
|
||||
dPosX = WinData.DIM_CAR + WinData.DIST_CARR_CLOSE + WinData.DIM_CAR
|
||||
else
|
||||
dPosX = WinData.DIM_CAR
|
||||
end
|
||||
end
|
||||
|
||||
EgtKeepRawPart( PARTS[i].idRaw)
|
||||
dPosX = dPosX - PARTS[i].dPartLength - PARTS[i].OffsetPartToRaw.X
|
||||
dPosY = dPosY - PARTS[i].dPartWidth - PARTS[i].OffsetPartToRaw.Y + PARTS[i].DispOffsets.Phase2.dOffsetY
|
||||
dPosZ = PARTS[i].DispOffsets.Phase2.dOffsetZ
|
||||
|
||||
local vtOffs = Vector3d( dPosX, dPosY, dPosZ)
|
||||
|
||||
EgtMoveToCornerRawPart( PARTS[i].idRaw, vtOffs, MCH_CR.BL)
|
||||
end
|
||||
|
||||
return true
|
||||
end
|
||||
WinData.ExecDisposition = ExecDisposition
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- Info che dipendono dal setup dell'utensile e configurazione macchina
|
||||
---------------------------------------------------------------------
|
||||
local function GetSetupInfo( ToolData)
|
||||
local SetupInfo = {}
|
||||
|
||||
-- dati comuni
|
||||
SetupInfo.bToolOnAggregate = false
|
||||
|
||||
-- testa 1 ( testa verticale con asse rotante per rinvii con CU)
|
||||
if ToolData.sHead == 'H11' then
|
||||
SetupInfo.nNumberOfAxis = 4
|
||||
SetupInfo.bIsVerticalHead = true
|
||||
SetupInfo.bIsHorizontalHead = not SetupInfo.bIsVerticalHead
|
||||
-- testa 2 ( 4 uscite orizzontali rotanti)
|
||||
elseif ToolData.sHead == 'H21' then
|
||||
SetupInfo.nNumberOfAxis = 4
|
||||
SetupInfo.nAxisNumber = 4
|
||||
SetupInfo.bIsHorizontalHead = true
|
||||
SetupInfo.bIsVerticalHead = not SetupInfo.bIsHorizontalHead
|
||||
-- testa 3 ( 2 uscite orizzontali fisse)
|
||||
elseif ToolData.sHead == 'H31' then
|
||||
SetupInfo.nNumberOfAxis = 3
|
||||
SetupInfo.bIsHorizontalHead = true
|
||||
SetupInfo.bIsVerticalHead = not SetupInfo.bIsHorizontalHead
|
||||
-- testa 4 ( testa verticale fissa)
|
||||
elseif ToolData.sHead == 'H41' then
|
||||
SetupInfo.nNumberOfAxis = 3
|
||||
SetupInfo.bIsVerticalHead = true
|
||||
SetupInfo.bIsHorizontalHead = not SetupInfo.bIsVerticalHead
|
||||
end
|
||||
|
||||
return SetupInfo
|
||||
end
|
||||
WinData.GetSetupInfo = GetSetupInfo
|
||||
|
||||
---------------------------------------------------------------------
|
||||
return WinData
|
||||
Reference in New Issue
Block a user