Dario Sassi
2967 lines
137 KiB
Lua
2967 lines
137 KiB
Lua
--
|
|
-- EEEEEEEEEE GGGGGG wwww wwww
|
|
-- EEEEEEEEEE GGGGGGGGGG wwww wwww
|
|
-- EEEE GGGG GGGG wwww wwww wwww
|
|
-- EEEE GGGG wwww wwww wwww
|
|
-- EEEEEEE GGGG GGGGGGG wwww wwwwww wwww
|
|
-- EEEEEEE GGGG GGGGGGG wwww wwwwww wwww
|
|
-- EEEE GGGG GGGG wwww wwwwwwww wwww
|
|
-- EEEE GGGG GGGG wwww wwww wwww wwww
|
|
-- EEEEEEEEEE GGGGGGGGGG wwwwwwww wwwwwwww
|
|
-- EEEEEEEEEE GGGGGG wwwwwww wwwwwww
|
|
--
|
|
-- Machining_2.lua by EgalWare s.r.l. 2016/23/05
|
|
-- Autore: Dario Sassi
|
|
-- Machining generation for Doors program machine Multiax N1216
|
|
-- 2017.06.01 V1.011 FM Manage machining optimization
|
|
-- 2017.06.13 V1.012 FM Fix bug on calculate box and row piece
|
|
-- 2017.06.30 V1.013 FM Manage optimization and assignement of more paths to one machining
|
|
-- 2017.11.17 V1.014 FM Add manage parameter dExtraThruDepth from CurrCamInfo for functions AdjustThrouIsle and AdjustVertHole
|
|
-- 2017.12.08 V1.015 FM Manage two new probe pointposition , before and after the hinge/pivot to probe always on left of hinge
|
|
-- (according to MDC door dispostion on table)
|
|
-- 2017.12.28 V1.016 FM Set note about hinge side machining
|
|
-- 2017.12.28 V1.016 FM Set note about hinge side profile
|
|
-- 2017.12.28 V1.016 FM Set note about door shift on Y with hinge not machined profile on reference
|
|
-- 2017.12.28 V1.016 FM Set note about door probe error on hinge not machined profile on reference
|
|
-- 2017.12.28 V1.016 FM Set note about lock side machining
|
|
-- 2018.02.22 V1.017 FM Fix rename offsetted probe geometry to leave enabled always the left probe geometry
|
|
-- (according to MDC door dispostion on table)
|
|
-- 2018.02.26 V1.0b1 FM Manage door dimension checking
|
|
-- 2018.05.17 V1.0b2 FM Calculate the solid box without extra surfaces
|
|
-- 2018.10.18 V1.0b3 FM Manage better setting the disposition parameter on Inactive door with opposite bevel profiles
|
|
-- 2018.10.19 V1.0b4 FM Make sure that use only enabled shuttle ( give nForceUseShuttle into AdjustHead)
|
|
-- 2018.10.23 V1.0b5 FM Manage rough machining
|
|
-- 2018.11.05 V1.0b6 FM Change the percentage of shuttle assignement to variable dPercentDoorLength (by Mark requests)
|
|
-- 2019.01.14 V1.0b7 FM Manage new CurrCamInfo parameter (nGenCncAsDdfName) to set
|
|
-- which name generate the cnc file (by default as parameter sDoorCode or as ddf file name)
|
|
-- 2019.01.23 V1.0b8 FM Not generate machining on Group 0 (of MTable ordered table) and print warning message into repot files.
|
|
-- 2019.01.24 V1.0b9 FM Extend cases to machine with AdjustHeadChisel operation,
|
|
-- use new settings to use with this extended operation: NO_WORK_UPSQUARE, CHISEL_ONLY_HORIZONTAL
|
|
-- 2019.03.27 V1.0c1 FM Manage check door/jamb dimension by function CheckPieceDimension
|
|
-- 2019.03.27 V1.0c2 FM Fix error on calculation bar disposition and menage better into CheckPieceDimension by shift door values
|
|
-- 2019.03.27 V1.0c2 FM Modify error messages format into CheckPieceDimension
|
|
-- 2019.03.27 V1.0c3 FM Manage estimate time
|
|
-- 2019.03.29 V1.0c4 FM Manage Edge break (EB) and Bevel Edge break (BVEB) profiles
|
|
-- 2019.04.08 V1.0c5 FM Manage Blade groove machinings with lead-in lead-out to reduce MTABLE lines
|
|
-- Now it uses 1 line for antisplint blade and 1 line for normal blade
|
|
-- 2019.04.08 V1.0c5 FM Manage Blade groove function AdjustBladeVertCurve
|
|
-- 2019.04.30 v1.0c6 FM Manage function AdjustASplintWithBlade to manage anti-splint paths when machine groove by blade
|
|
-- 2019.04.30 v1.0c6 FM Manage function AdjustHeadOnASplint to manage hinge anti-splint paths when machine groove by blade
|
|
-- 2019.05.28 v1.0c7 FM Fix problem on update all machining after reorder, now use EgtApplyAllMachinings instead of EgtUpdateAllMachinings
|
|
-- 2019.07.22 V1.0c8 FM Manage better the updoor/underdoor machinings counter that generate flags values
|
|
-- 2019.08.27 V1.0c9 FM Manage underneath machining checking (by machining note 'UD_CHECK') to disable vacuums
|
|
-- (use new underneath distance by variable dDistInterferUnder)
|
|
-- 2020.03.19 V1.0d0 FM Fix error on check door dimension into CheckPieceDimension (when door is shifted by Bullnose profile on hinge side)
|
|
-- 2021.05.06 V1.0d1 FM Change the percentage of shuttle assignement to variable dPercentDoorLength if door length is more than 2700mm (long door limit)
|
|
-- 2021.05.28 V1.0d2 FM Add managing new one special code p6
|
|
-- 2021.06.01 v1.0d3 FM Fix error on calculate piece box
|
|
-- 2021.10.28 V1.0d4 FM Fix internal error when calculate Box with STANDARD parameter, now it uses EXACT parameter
|
|
-- 2022.07.27 V1.0d5 FM Modification to use compiled code
|
|
-- 2023.03.29 V1.0d6 FM Fix error on calculate rough paths on Convex profile
|
|
-- 2023.03.31 V1.0d7 FM Manage offsetted path ( by path note) to extra path of Convex profile
|
|
-- 2023.12.01 V1.0d8 FM Manage small planes on Convex profile
|
|
|
|
|
|
-- Intestazioni
|
|
require( 'EgtBase')
|
|
_ENV = EgtProtectGlobal()
|
|
EgtEnableDebug( false)
|
|
|
|
local MachiningLoc = {}
|
|
|
|
-- Librerie particolari
|
|
local sBaseDir = DGD.BASEDIR -- EgtGetSourceDir()
|
|
EgtAddToPackagePath( sBaseDir .. 'LuaLibs\\?.lua')
|
|
require( 'EgtDoorsBase')
|
|
require( 'EgtDoorsData')
|
|
local EgtDoorsMsg = require( 'EgtDoorsMsg')
|
|
local MB = require( 'MachiningBase')
|
|
|
|
-- Impostazioni Cam per consentire forature con utensile più piccolo
|
|
EgtMdbSetGeneralParam( MCH_GP.HOLEDIAMTOLER, -50)
|
|
EgtMdbSave()
|
|
-- Definizione disposizione porta ( a sinistra : 1, a destra : -1)
|
|
local DISPMODE = -1
|
|
-- Definizione possibilità di lavorare sottosquadra nei profili bevel ( true: non lavora sottosquadra, false: possibile lavorare sottosquadra)
|
|
local NO_WORK_UNDERSQUARE = false
|
|
-- Definizione possibilità di lavorare soprasquadra nei profili bevel ( true: non lavora soprasquadra, false: possibile lavorare soprasquadra)
|
|
local NO_WORK_UPSQUARE = false
|
|
-- Definizione possibilità di lavorare testa chisel rimanendo solo orizzontale o seguendo il bevel ( per teste non shuttle)
|
|
local CHISEL_ONLY_HORIZONTAL = false
|
|
-- variabili generazione lavorazioni
|
|
local GEN_MACH = false
|
|
local NOT_GEN_MACH = true
|
|
-- Variabile distanza minima tra pezzo finito e ventosa (in X)
|
|
local DIST_MIN_VAC_L = 5
|
|
local DIST_MIN_VAC_R = 7.5
|
|
-- variabile per applicare sempre la lavorazione degli anti-scheggia fatti con gli shuttle ( >= 4 inserisce solo quelle necessarie, < 4 inserisce tutte)
|
|
-- in caso il groove sia fatto con lama
|
|
local MAXMACH = 4
|
|
-- variabile che indica se sono state inserite lavorazioni da sotto
|
|
local bMachUnder
|
|
-- variabile dimensione porta considerata lunga che segna il diverso parcheggio dello shuttle 1 come è settata nella macro P5INIT
|
|
local Big_Dorr_Height
|
|
-----------------------------------------------------------------
|
|
-- *** Error write file ***
|
|
-----------------------------------------------------------------
|
|
local function WriteErrFile( sFileErr, sDispMsg)
|
|
local nIdFile = io.open( sFileErr, 'w')
|
|
if nIdFile then
|
|
if DGD.ERR == 0 then
|
|
if DGD.ERM and #DGD.ERM > 0 then
|
|
nIdFile:write( 'Err=' .. tostring( DGD.ERR) .. '\n' .. DGD.ERM)
|
|
else
|
|
nIdFile:write( 'Err=' .. tostring( DGD.ERR))
|
|
end
|
|
else
|
|
if DGD.EMC and #DGD.EMC > 0 then
|
|
nIdFile:write( 'Err=' .. tostring( DGD.ERR) .. '\n' .. DGD.EMC)
|
|
else
|
|
nIdFile:write( 'Err=' .. tostring( DGD.ERR))
|
|
end
|
|
end
|
|
if sDispMsg and #sDispMsg > 0 then
|
|
nIdFile:write('\n' .. sDispMsg)
|
|
end
|
|
nIdFile:close()
|
|
end
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
-- *** Add machining combine in table for second part ***
|
|
-----------------------------------------------------------------
|
|
local function AddMachIntable( MTMachLine, tSecMcng, nIndexTab)
|
|
|
|
if tSecMcng then
|
|
|
|
if #tSecMcng > 0 then
|
|
|
|
local bFound = false
|
|
MTMachLine.Row = nIndexTab
|
|
|
|
for k = 1, #tSecMcng do
|
|
if MTMachLine == tSecMcng[k] then
|
|
bFound = true
|
|
end
|
|
end
|
|
|
|
-- se non trovato lo inserisco
|
|
if not bFound then
|
|
table.insert( tSecMcng,MTMachLine)
|
|
end
|
|
else
|
|
MTMachLine.Row = nIndexTab
|
|
table.insert( tSecMcng,MTMachLine)
|
|
end
|
|
end
|
|
|
|
return tSecMcng
|
|
|
|
end
|
|
|
|
local function SetInfoTable( tListEnt, sNameInfo, nValInfo)
|
|
|
|
for j = 1, #tListEnt do
|
|
if tListEnt[j] then
|
|
EgtSetInfo( tListEnt[j], sNameInfo, nValInfo)
|
|
end
|
|
end
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
-- *** Apply Machining by Mach number ***
|
|
-----------------------------------------------------------------
|
|
local function InsertMachiningByMachNum ( tEndId, nMach, sLocName, nNumGroup, sMach,
|
|
sMachUp, sMachDw, bOk, nNumMach, bModifyMacNote,
|
|
bNotGenMachining, tMachining, dBladePerpLeadIn, dPercRedFeed )
|
|
|
|
local dOverL = EgtGetInfo( tEndId[1], 'OL')
|
|
local dOverR = EgtGetInfo( tEndId[1], 'OFFSTOPATH', 'd')
|
|
local nOffsetDel = EgtIf( bNotGenMachining, 20, 0)
|
|
local nOffsetDelFail = EgtIf( bNotGenMachining, 30, 0)
|
|
|
|
if nMach == 1 then
|
|
local nRes, nMachId, sToolName, sNotesMach = MB.AddAndDelMachining( sLocName .. '_G' .. EgtNumToString(nNumGroup,0), sMach, tEndId, dOverL, sLocName,
|
|
bNotGenMachining, nil, dBladePerpLeadIn, dPercRedFeed, nil,
|
|
nil, nil, dOverR)
|
|
if nRes < 0 then -- se la lavorazione ha fallito
|
|
bOk = false
|
|
if bModifyMacNote then
|
|
-- setto nota per non lavorarla di nuovo nemmeno nella generazione reale
|
|
SetInfoTable( tEndId, 'Mach', 11+ nOffsetDelFail)
|
|
end
|
|
if bNotGenMachining then
|
|
-- setto nota per non lavorarla di nuovo nemmeno nella generazione reale
|
|
SetInfoTable( tEndId, 'Mach', 11+ nOffsetDelFail)
|
|
end
|
|
elseif nRes == 0 then -- se lavorazione mancante
|
|
if bModifyMacNote then
|
|
-- setto nota per non lavorarla di nuovo
|
|
SetInfoTable( tEndId, 'Mach', 11+ nOffsetDelFail)
|
|
end
|
|
if bNotGenMachining then
|
|
-- setto nota per non lavorarla di nuovo nemmeno nella generazione reale
|
|
SetInfoTable( tEndId, 'Mach', 11+ nOffsetDelFail)
|
|
end
|
|
else -- lavorazione ok
|
|
if bModifyMacNote then
|
|
-- setto nota per non lavorarla di nuovo
|
|
SetInfoTable( tEndId, 'Mach', 11+ nOffsetDel)
|
|
end
|
|
if bNotGenMachining then
|
|
nNumMach = nNumMach + 1
|
|
-- setto nota per non lavorarla di nuovo
|
|
SetInfoTable( tEndId, 'Mach', 11+ nOffsetDel)
|
|
SetInfoTable( tEndId, 'Machining', sMach)
|
|
else
|
|
if tMachining then
|
|
table.insert( tMachining,{nMachId,sToolName})
|
|
end
|
|
-- cerco se nelle note ho quella per l'aggregato da sotto
|
|
if sNotesMach and #sNotesMach > 0 then -- se la nota non è vuota
|
|
local nPosFind, _ = sNotesMach:find( 'UD_CHECK', 1, true)
|
|
if nPosFind then -- se trovata nota aggiungo nota alle geometrie per indicare che è lavorata da sotto
|
|
SetInfoTable( tEndId, 'UnderneathMach', true)
|
|
bMachUnder = true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
elseif nMach == 2 then
|
|
local nRes, nMachId, sToolName, sNotesMach = MB.AddAndDelMachining( sLocName .. '_G' .. EgtNumToString(nNumGroup,0), sMachUp, tEndId, dOverL, sLocName,
|
|
bNotGenMachining, nil, dBladePerpLeadIn, dPercRedFeed, nil,
|
|
nil, nil, dOverR)
|
|
if nRes < 0 then -- se la lavorazione ha fallito
|
|
bOk = false
|
|
if bModifyMacNote then
|
|
-- setto nota per non lavorarla di nuovo
|
|
SetInfoTable( tEndId, 'Mach', 12+ nOffsetDelFail)
|
|
end
|
|
if bNotGenMachining then
|
|
-- setto nota per non lavorarla di nuovo nemmeno nella generazione reale
|
|
SetInfoTable( tEndId, 'Mach', 12+ nOffsetDelFail)
|
|
end
|
|
elseif nRes == 0 then -- se lavorazione mancante
|
|
if bModifyMacNote then
|
|
-- setto nota per non lavorarla di nuovo
|
|
SetInfoTable( tEndId, 'Mach', 12+ nOffsetDelFail)
|
|
end
|
|
if bNotGenMachining then
|
|
-- setto nota per non lavorarla di nuovo nemmeno nella generazione reale
|
|
SetInfoTable( tEndId, 'Mach', 12+ nOffsetDelFail)
|
|
end
|
|
else -- lavorazione ok
|
|
if bModifyMacNote then
|
|
-- setto nota per non lavorarla di nuovo
|
|
SetInfoTable( tEndId, 'Mach', 12+ nOffsetDel)
|
|
end
|
|
if bNotGenMachining then
|
|
nNumMach = nNumMach + 1
|
|
-- setto nota per non lavorarla di nuovo
|
|
SetInfoTable( tEndId, 'Mach', 12+ nOffsetDel)
|
|
SetInfoTable( tEndId, 'Machining', sMachUp)
|
|
else
|
|
if tMachining then
|
|
table.insert( tMachining,{nMachId,sToolName})
|
|
end
|
|
-- cerco se nelle note ho quella per l'aggregato da sotto
|
|
if sNotesMach and #sNotesMach > 0 then -- se la nota non è vuota
|
|
local nPosFind, _ = sNotesMach:find( 'UD_CHECK', 1, true)
|
|
if nPosFind then -- se trovata nota aggiungo nota alle geometrie per indicare che è lavorata da sotto
|
|
SetInfoTable( tEndId, 'UnderneathMach', true)
|
|
bMachUnder = true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
elseif nMach == 3 then
|
|
local nRes, nMachId, sToolName, sNotesMach = MB.AddAndDelMachining( sLocName .. '_G' .. EgtNumToString(nNumGroup,0), sMachDw, tEndId, dOverL, sLocName,
|
|
bNotGenMachining, nil, dBladePerpLeadIn, dPercRedFeed, nil,
|
|
nil, nil, dOverR)
|
|
if nRes < 0 then -- se la lavorazione ha fallito
|
|
bOk = false
|
|
if bModifyMacNote then
|
|
-- setto nota per non lavorarla di nuovo
|
|
SetInfoTable( tEndId, 'Mach', 13+ nOffsetDelFail)
|
|
end
|
|
if bNotGenMachining then
|
|
-- setto nota per non lavorarla di nuovo nemmeno nella generazione reale
|
|
SetInfoTable( tEndId, 'Mach', 13+ nOffsetDelFail)
|
|
end
|
|
elseif nRes == 0 then -- se lavorazione mancante
|
|
if bModifyMacNote then
|
|
-- setto nota per non lavorarla di nuovo
|
|
SetInfoTable( tEndId, 'Mach', 13+ nOffsetDelFail)
|
|
end
|
|
if bNotGenMachining then
|
|
-- setto nota per non lavorarla di nuovo nemmeno nella generazione reale
|
|
SetInfoTable( tEndId, 'Mach', 13+ nOffsetDelFail)
|
|
end
|
|
else -- lavorazione ok
|
|
if bModifyMacNote then
|
|
-- setto nota per non lavorarla di nuovo
|
|
SetInfoTable( tEndId, 'Mach', 13+ nOffsetDel)
|
|
end
|
|
if bNotGenMachining then
|
|
nNumMach = nNumMach + 1
|
|
-- setto nota per non lavorarla di nuovo
|
|
SetInfoTable( tEndId, 'Mach', 13+ nOffsetDel)
|
|
SetInfoTable( tEndId, 'Machining', sMachDw)
|
|
else
|
|
if tMachining then
|
|
table.insert( tMachining,{nMachId,sToolName})
|
|
end
|
|
-- cerco se nelle note ho quella per l'aggregato da sotto
|
|
if sNotesMach and #sNotesMach > 0 then -- se la nota non è vuota
|
|
local nPosFind, _ = sNotesMach:find( 'UD_CHECK', 1, true)
|
|
if nPosFind then -- se trovata nota aggiungo nota alle geometrie per indicare che è lavorata da sotto
|
|
SetInfoTable( tEndId, 'UnderneathMach', true)
|
|
bMachUnder = true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
return bOk, nNumMach, tMachining
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
-- *** Calc Machining for same group ***
|
|
-----------------------------------------------------------------
|
|
local function FindAndCalcGroupMachining( nEndId, nEndIdGhost, tLocTable, nNumMachFromTable, nMach,
|
|
nNumGroup, nNumMach, bOk, dBladePerpLeadIn, dPercRedFeed )
|
|
|
|
local nParendId = EgtGetParent(nEndId)
|
|
local EntListMain = MB.FindEntities( nParendId) -- ricavo tutte le entità che sono nello stesso gruppo
|
|
local sLocMachId
|
|
local bNotGenMachining = true
|
|
|
|
-- ordinare lavorazioni navette come scritto su foglio nella documentazione
|
|
|
|
for i = 1, #tLocTable do
|
|
|
|
if tLocTable[i].On ~= 0 then
|
|
|
|
sLocMachId = tLocTable[i].MachId
|
|
if not sLocMachId then sLocMachId = 1 end
|
|
|
|
if sLocMachId == nNumMachFromTable then
|
|
|
|
-- Recupero le entità
|
|
local EntList = MB.FindEntitiesWithNameFromTab( EntListMain, tLocTable[i].Name)
|
|
|
|
-- Applico le lavorazioni
|
|
for j = 1, #EntList do
|
|
|
|
local nMachCk = EgtGetInfo( EntList[j], 'MachCk', 'i') or 1
|
|
|
|
if ( tLocTable[i].Oper == 'AdjustHead' or tLocTable[i].Oper == 'AdjustHeadOnASplint') and nMachCk > 0 and nMachCk < 10 then
|
|
|
|
-- assegno la stessa nota nMach dell'entità del gruppo
|
|
EgtSetInfo( EntList[j], 'Mach', nMach)
|
|
-- duplico entià
|
|
local nNewEntId = MB.MakeGhostCopy( EntList[j])
|
|
-- carico id entità in una tabella
|
|
local tListSameMach = {}
|
|
table.insert( tListSameMach, nNewEntId)
|
|
|
|
bOk, nNumMach = InsertMachiningByMachNum( tListSameMach, nMach, tLocTable[i].Name, nNumGroup, tLocTable[i].Mach,
|
|
tLocTable[i].MachUp, tLocTable[i].MachDw, bOk, nNumMach, true,
|
|
bNotGenMachining, nil, dBladePerpLeadIn, dPercRedFeed)
|
|
|
|
local nNewMach = EgtGetInfo( tListSameMach[1], 'Mach', 'i') or 1
|
|
if nNewMach > 30 and nNewMach < 40 then
|
|
EgtSetInfo( EntList[j], 'Mach', nNewMach-20) -- assegno nota per non lavorarla di nuovo
|
|
elseif nNewMach > 40 and nNewMach < 50 then
|
|
EgtSetInfo( EntList[j], 'Mach', nNewMach-30) -- assegno nota per non lavorarla di nuovo
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
return bOk, nNumMach
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
-- *** Add Machining for same group ***
|
|
-----------------------------------------------------------------
|
|
local function MakeGroupMachining( nEndId, nParendId, tLocTable, nMach, nNumGroup,
|
|
nNumMach, bOk, sGhostName, dMaxDistToChain, EndLastMach,
|
|
dBladePerpLeadIn, dPercRedFeed)
|
|
|
|
local EntListMain = MB.FindEntities( nParendId) -- ricavo tutte le entità che sono nello stesso gruppo
|
|
|
|
-- ordinare lavorazioni navette come scritto su foglio nella documentazione
|
|
|
|
for i = 1, #tLocTable do
|
|
|
|
-- Recupero le entità
|
|
local EntList = MB.FindEntitiesWithNameFromTab( EntListMain, tLocTable[i].Name..sGhostName)
|
|
|
|
-- Applico le lavorazioni
|
|
for j = 1, #EntList do
|
|
|
|
local nMachCk = EgtGetInfo( EntList[j], 'Mach', 'i') or 1
|
|
nMachCk = nMachCk - 30 -- se lavorazione corretta ottengo 1
|
|
local nMach2nd = EgtGetInfo( EntList[j], 'Mach2nd', 'i') or 0
|
|
if nMachCk > 0 and nMachCk < 10 then nMachCk = 1 end
|
|
|
|
if nMachCk > 0 and nMachCk < 10 then
|
|
|
|
local nNewEntId = EntList[j]
|
|
local sMachining = EgtGetInfo( nNewEntId, 'Machining')
|
|
|
|
if sMachining and nMach == 1 and nMach2nd == 0 and sMachining == tLocTable[i].Mach then
|
|
|
|
-- cerco di unire più entità nella stessa lavorazione ( non da sotto e non oltre una certa distanza)
|
|
local tListSameMach = MB.FindEntitiesCompMach( nNewEntId, EntList, sMachining, tLocTable[i].Join, dMaxDistToChain, true)
|
|
|
|
-- se più di 1 entità le ordino
|
|
if #tListSameMach > 1 then
|
|
tListSameMach = MB.OrderEnt( tListSameMach, EndLastMach)
|
|
EndLastMach = EgtSP( tListSameMach[#tListSameMach], GDB_ID.ROOT )
|
|
end
|
|
|
|
bOk, nNumMach = InsertMachiningByMachNum( tListSameMach, nMach, tLocTable[i].Name, nNumGroup, tLocTable[i].Mach,
|
|
tLocTable[i].MachUp, tLocTable[i].MachDw, bOk, nNumMach, true,
|
|
GEN_MACH, nil, dBladePerpLeadIn, dPercRedFeed)
|
|
|
|
-- se ho assegnato lavorazione a più entità, marco quelle che ho già fatto
|
|
SetInfoTable( tListSameMach, 'Mach2nd', 1)
|
|
|
|
local nNewMach = EgtGetInfo( tListSameMach[1], 'Mach', 'i') or 1
|
|
if nNewMach > 30 and nNewMach < 40 then
|
|
SetInfoTable( tListSameMach, 'Mach', nNewMach-20) -- assegno nota per non lavorarla di nuovo
|
|
elseif nNewMach > 40 and nNewMach < 50 then
|
|
SetInfoTable( tListSameMach, 'Mach', nNewMach-30) -- assegno nota per non lavorarla di nuovo
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- tolgo di mezzo le note secondarie
|
|
for j = 1, #EntList do
|
|
EgtRemoveInfo( EntList[j], 'Mach2nd')
|
|
end
|
|
end
|
|
|
|
return bOk, nNumMach
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
-- *** Movimento ventose ***
|
|
-----------------------------------------------------------------
|
|
local ThroughId, BlindId
|
|
-----------------------------------------------------------------
|
|
local function StartVacVerify( nIdSolid, bFlipped)
|
|
-- regioni passante e cieca non definite
|
|
EgtErase( ThroughId or GDB_ID.NULL)
|
|
ThroughId = nil
|
|
EgtErase( BlindId or GDB_ID.NULL)
|
|
BlindId = nil
|
|
-- recupero le regioni sopra e sotto della porta messa in macchina
|
|
local UpId, DwId
|
|
-- se porta ribaltata
|
|
if bFlipped then
|
|
-- superficie a contatto con le ventose
|
|
DwId = MB.FindGeomWithName( nIdSolid, 'FLAT_UP', true)
|
|
-- superficie sopra
|
|
UpId = MB.FindGeomWithName( nIdSolid, 'FLAT_DW', true)
|
|
else
|
|
-- superficie a contatto con le ventose
|
|
DwId = MB.FindGeomWithName( nIdSolid, 'FLAT_DW', true)
|
|
-- superficie sopra
|
|
UpId = MB.FindGeomWithName( nIdSolid, 'FLAT_UP', true)
|
|
end
|
|
-- creo le regioni complementari
|
|
local b3Up = EgtGetBBoxGlob( UpId, GDB_BB.EXACT)
|
|
local CompUpId = EgtSurfFrRectangle( nIdSolid, b3Up:getMin(), b3Up:getMax(), GDB_RT.GLOB)
|
|
local vtNUp = EgtSurfFrNormVersor( UpId, GDB_ID.ROOT)
|
|
local vtNCompUp = EgtSurfFrNormVersor( CompUpId, GDB_ID.ROOT)
|
|
if not AreSameVectorApprox( vtNUp, vtNCompUp) then EgtInvertSurf( CompUpId) end
|
|
EgtSurfFrSubtract( CompUpId, UpId)
|
|
if not EgtExistsObj( CompUpId) then CompUpId = nil end
|
|
local b3Dw = EgtGetBBoxGlob( DwId, GDB_BB.EXACT)
|
|
local CompDwId = EgtSurfFrRectangle( nIdSolid, b3Dw:getMin(), b3Dw:getMax(), GDB_RT.GLOB)
|
|
local vtNDw = EgtSurfFrNormVersor( DwId, GDB_ID.ROOT)
|
|
local vtNCompDw = EgtSurfFrNormVersor( CompDwId, GDB_ID.ROOT)
|
|
if not AreSameVectorApprox( vtNDw, vtNCompDw) then EgtInvertSurf( CompDwId) end
|
|
EgtSurfFrSubtract( CompDwId, DwId)
|
|
if not EgtExistsObj( CompDwId) then CompDwId = nil end
|
|
if CompDwId then EgtInvertSurf( CompDwId) end
|
|
-- calcolo le regioni passante e cieca
|
|
local ThroughRegId = nil
|
|
local BlindRegId = nil
|
|
-- se ci sono entrambe le regioni
|
|
if CompUpId and CompDwId then
|
|
-- per ottenere la regione passante faccio intersezione tra sopra e sotto
|
|
EgtSurfFrIntersect( CompUpId, CompDwId)
|
|
if EgtExistsObj( CompUpId) then
|
|
ThroughRegId = CompUpId
|
|
end
|
|
-- per ottenere la regione cieca faccio differenza tra sotto e passante
|
|
if ThroughRegId then
|
|
EgtSurfFrSubtract( CompDwId, ThroughRegId)
|
|
if EgtExistsObj( CompDwId) then
|
|
BlindRegId = CompDwId
|
|
end
|
|
else
|
|
BlindRegId = CompDwId
|
|
end
|
|
-- se c'è solo la regione sotto è già quella delle lavorazioni cieche
|
|
elseif CompDwId then
|
|
BlindRegId = CompDwId
|
|
-- se c'è solo la sopra, non interessa e la cancello
|
|
elseif CompUpId then
|
|
EgtErase( CompUpId)
|
|
end
|
|
-- sistemazioni finali
|
|
if ThroughRegId then
|
|
ThroughId = EgtGroup( GDB_ID.ROOT)
|
|
EgtSetName( ThroughId, 'THROUGH')
|
|
EgtSetColor( ThroughId, RED())
|
|
EgtSetLevel( ThroughId, GDB_LV.TEMP)
|
|
local nChunk = 0
|
|
while EgtExtractSurfFrChunkLoops( ThroughRegId, nChunk, ThroughId) do
|
|
nChunk = nChunk + 1
|
|
end
|
|
EgtErase( ThroughRegId)
|
|
--EgtSetName( ThroughRegId, 'THROUGH')
|
|
--EgtSetColor( ThroughRegId, RED())
|
|
--EgtSetLevel( ThroughRegId, GDB_LV.TEMP)
|
|
end
|
|
if BlindRegId then
|
|
BlindId = EgtGroup( GDB_ID.ROOT)
|
|
EgtSetName( BlindId, 'BLIND')
|
|
EgtSetColor( BlindId, BLUE())
|
|
EgtSetLevel( BlindId, GDB_LV.TEMP)
|
|
local nChunk = 0
|
|
while EgtExtractSurfFrChunkLoops( BlindRegId, nChunk, BlindId) do
|
|
nChunk = nChunk + 1
|
|
end
|
|
EgtErase( BlindRegId)
|
|
--EgtSetName( BlindRegId, 'BLIND')
|
|
--EgtSetColor( BlindRegId, BLUE())
|
|
--EgtSetLevel( BlindRegId, GDB_LV.TEMP)
|
|
end
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
local function ExecVacVerify( ptVac, Pz, dDistInterferThru, dDistInterferBlind, dDistInterferUnder)
|
|
-- verifica con le regioni passanti
|
|
local nId = EgtGetFirstInGroup( ThroughId or GDB_ID.NULL)
|
|
while nId do
|
|
local ptNear = EgtNP( nId, ptVac, GDB_ID.ROOT)
|
|
if ptNear then
|
|
local dDist = sqrt( ( ptNear[1] - ptVac[1]) * ( ptNear[1] - ptVac[1]) +
|
|
( ptNear[2] - ptVac[2]) * ( ptNear[2] - ptVac[2]))
|
|
-- se distanza inferiore al limite ...
|
|
if dDist < dDistInterferThru then
|
|
return false
|
|
end
|
|
end
|
|
nId = EgtGetNext( nId)
|
|
end
|
|
-- verifica con le regioni cieche
|
|
nId = EgtGetFirstInGroup( BlindId or GDB_ID.NULL)
|
|
while nId do
|
|
local ptNear = EgtNP( nId, ptVac, GDB_ID.ROOT)
|
|
if ptNear then
|
|
local dDist = sqrt( ( ptNear[1] - ptVac[1]) * ( ptNear[1] - ptVac[1]) +
|
|
( ptNear[2] - ptVac[2]) * ( ptNear[2] - ptVac[2]))
|
|
-- se distanza inferiore al limite ...
|
|
if dDist < dDistInterferBlind then
|
|
return false
|
|
end
|
|
end
|
|
nId = EgtGetNext( nId)
|
|
end
|
|
|
|
-- se ho delle lavorazioni da sotto
|
|
if bMachUnder then
|
|
local tUnderList = {}
|
|
tUnderList = MB.FindGeomWithNote( Pz, 'UnderneathMach', 'b', true, tUnderList)
|
|
for i = 1, #tUnderList do
|
|
local ptNear = EgtNP( tUnderList[i], ptVac, GDB_ID.ROOT)
|
|
if ptNear then
|
|
local dDist = sqrt( ( ptNear[1] - ptVac[1]) * ( ptNear[1] - ptVac[1]) +
|
|
( ptNear[2] - ptVac[2]) * ( ptNear[2] - ptVac[2]))
|
|
-- se distanza inferiore al limite ...
|
|
if dDist < dDistInterferUnder then
|
|
return false
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- nessuna interferenza
|
|
return true
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
local function EndVacVerify()
|
|
-- cancello regioni passante e cieca
|
|
EgtErase( ThroughId or GDB_ID.NULL)
|
|
ThroughId = nil
|
|
EgtErase( BlindId or GDB_ID.NULL)
|
|
BlindId = nil
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
local function MoveVac( nGroupId, sName, dVal)
|
|
local nId = EgtGetFirstNameInGroup( nGroupId or GDB_ID.NULL, sName)
|
|
local dOldVal = EgtGetInfo( nId, 'Val', 'd')
|
|
EgtMove( nId, Vector3d( 0, 0, dVal - dOldVal), GDB_RT.GLOB)
|
|
EgtSetInfo( nId, 'Val', dVal)
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
local function MakeBoxFromSolidLayer( nSolidLayer, nProbeMode, nAuxLayer)
|
|
|
|
-- Box solido: lo ottengo dalla somma delle varie superfici della porta
|
|
local tListFaces = {}
|
|
if nProbeMode == 2 then
|
|
table.insert( tListFaces, EgtGetFirstNameInGroup( nSolidLayer, 'FLAT_UP_2'))
|
|
table.insert( tListFaces, EgtGetFirstNameInGroup( nSolidLayer, 'FLAT_DW_2'))
|
|
else
|
|
table.insert( tListFaces, EgtGetFirstNameInGroup( nSolidLayer, 'FLAT_UP'))
|
|
table.insert( tListFaces, EgtGetFirstNameInGroup( nSolidLayer, 'FLAT_DW'))
|
|
end
|
|
table.insert( tListFaces, EgtGetFirstNameInGroup( nSolidLayer, 'SIDE_LF'))
|
|
table.insert( tListFaces, EgtGetFirstNameInGroup( nSolidLayer, 'SIDE_RH'))
|
|
table.insert( tListFaces, EgtGetFirstNameInGroup( nSolidLayer, 'SIDE_BT'))
|
|
table.insert( tListFaces, EgtGetFirstNameInGroup( nSolidLayer, 'SIDE_TP'))
|
|
table.insert( tListFaces, EgtGetFirstNameInGroup( nSolidLayer, 'SIDE'))
|
|
|
|
-- aggiungo anche il layer AUX escludendo il testo
|
|
if nAuxLayer then
|
|
|
|
local nIdGeom = EgtGetFirstInGroup(nAuxLayer)
|
|
local nTypeEnt
|
|
|
|
while nIdGeom do
|
|
-- se elemento passato è un testo lo escludo
|
|
nTypeEnt = EgtGetType( nIdGeom)
|
|
if nTypeEnt ~= GDB_TY.EXT_TEXT then
|
|
table.insert( tListFaces, nIdGeom)
|
|
end
|
|
nIdGeom = EgtGetNext(nIdGeom)
|
|
end
|
|
end
|
|
|
|
local b3fx = BBox3d() -- inizializzo il box nullo
|
|
|
|
for i = 1, #tListFaces do
|
|
if tListFaces[i] then
|
|
local b3f1 = EgtGetBBoxGlob( tListFaces[i], GDB_BB.EXACT)
|
|
b3fx:Add(b3f1)
|
|
end
|
|
end
|
|
|
|
return b3fx
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
local function CheckPieceDimension ( dLengthDoor, dWidthDoor, dThickDoor, OffsXSovr, OffsYSovr,
|
|
ShiftXOri, ShiftYOri, dMinDoorLength, dMaxDoorLength, dMinDoorWidth,
|
|
dMaxDoorWidth, dMinDoorThick, dMaxDoorThick)
|
|
|
|
local bFailDim = false
|
|
local sErrMess = ''
|
|
local dLimitToCheck
|
|
|
|
dLimitToCheck = dMinDoorLength - abs(ShiftXOri)
|
|
if ( dLengthDoor + OffsXSovr) < dLimitToCheck then -- se lunghezza inferiore
|
|
bFailDim = true
|
|
sErrMess = string.format(EgtDoorsMsg[617], EgtDoorsMsg[622], EgtToUiUnits(dLengthDoor), EgtToUiUnits(OffsXSovr), EgtToUiUnits(dLengthDoor+OffsXSovr),
|
|
EgtToUiUnits(abs(ShiftXOri)), EgtToUiUnits(dLimitToCheck))
|
|
if #DGD.EMC > 0 then
|
|
DGD.EMC = DGD.EMC .. '\n'.. sErrMess
|
|
else
|
|
DGD.EMC = '\n'.. sErrMess
|
|
end
|
|
end
|
|
|
|
dLimitToCheck = dMaxDoorLength - abs(ShiftXOri)
|
|
if ( dLengthDoor + OffsXSovr) > dLimitToCheck then -- se lunghezza superiore
|
|
bFailDim = true
|
|
sErrMess = string.format(EgtDoorsMsg[616], EgtDoorsMsg[622], EgtToUiUnits(dLengthDoor), EgtToUiUnits(OffsXSovr), EgtToUiUnits(dLengthDoor+OffsXSovr),
|
|
EgtToUiUnits(abs(ShiftXOri)), EgtToUiUnits(dLimitToCheck))
|
|
if #DGD.EMC > 0 then
|
|
DGD.EMC = DGD.EMC .. '\n'.. sErrMess
|
|
else
|
|
DGD.EMC = '\n'.. sErrMess
|
|
end
|
|
end
|
|
|
|
-- dLimitToCheck = dMinDoorWidth - abs(2*ShiftYOri)
|
|
dLimitToCheck = dMinDoorWidth + abs(ShiftYOri)
|
|
if ( dWidthDoor + (2*OffsYSovr)) < dLimitToCheck then -- se larghezza inferiore
|
|
bFailDim = true
|
|
sErrMess = string.format(EgtDoorsMsg[619], EgtDoorsMsg[622], EgtToUiUnits(dWidthDoor), EgtToUiUnits(2*OffsYSovr), EgtToUiUnits(dWidthDoor+(2*OffsYSovr)),
|
|
EgtToUiUnits(abs(ShiftYOri)), EgtToUiUnits(dLimitToCheck))
|
|
if #DGD.EMC > 0 then
|
|
DGD.EMC = DGD.EMC .. '\n'.. sErrMess
|
|
else
|
|
DGD.EMC = '\n'.. sErrMess
|
|
end
|
|
end
|
|
|
|
-- dLimitToCheck = dMaxDoorWidth - abs(2*ShiftYOri)
|
|
dLimitToCheck = dMaxDoorWidth + abs(ShiftYOri)
|
|
if ( dWidthDoor + (2*OffsYSovr)) > dLimitToCheck then -- se larghezza superiore
|
|
bFailDim = true
|
|
sErrMess = string.format(EgtDoorsMsg[618], EgtDoorsMsg[622], EgtToUiUnits(dWidthDoor), EgtToUiUnits(2*OffsYSovr), EgtToUiUnits(dWidthDoor+(2*OffsYSovr)),
|
|
EgtToUiUnits(abs(ShiftYOri)), EgtToUiUnits(dLimitToCheck))
|
|
if #DGD.EMC > 0 then
|
|
DGD.EMC = DGD.EMC .. '\n'.. sErrMess
|
|
else
|
|
DGD.EMC = '\n'.. sErrMess
|
|
end
|
|
end
|
|
|
|
dLimitToCheck = dMinDoorThick
|
|
if dThickDoor < dLimitToCheck then -- se spessore inferiore
|
|
bFailDim = true
|
|
sErrMess = string.format(EgtDoorsMsg[621], EgtDoorsMsg[622], EgtToUiUnits(dThickDoor), EgtToUiUnits(dLimitToCheck))
|
|
if #DGD.EMC > 0 then
|
|
DGD.EMC = DGD.EMC .. '\n'.. sErrMess
|
|
else
|
|
DGD.EMC = '\n'.. sErrMess
|
|
end
|
|
end
|
|
|
|
dLimitToCheck = dMaxDoorThick
|
|
if dThickDoor > dLimitToCheck then -- se spessore superiore
|
|
bFailDim = true
|
|
sErrMess = string.format(EgtDoorsMsg[620], EgtDoorsMsg[622], EgtToUiUnits(dThickDoor), EgtToUiUnits(dLimitToCheck))
|
|
if #DGD.EMC > 0 then
|
|
DGD.EMC = DGD.EMC .. '\n'.. sErrMess
|
|
else
|
|
DGD.EMC = '\n'.. sErrMess
|
|
end
|
|
end
|
|
|
|
return bFailDim
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
-- *** Funzione di generazione lavorazioni ***
|
|
-----------------------------------------------------------------
|
|
function MachiningLoc.Calc( tPz, tsAssemb, nNumMachFromTable, nNumMachFromCam, nNumGroup)
|
|
|
|
--macchina e tabella di default
|
|
local MachName = 'Multiax-'
|
|
|
|
-- Machinings Tables
|
|
local MachiningsTable = 'MachStdTable'
|
|
local MachiningsTableOrd = 'MachStdTable_Ord'
|
|
|
|
-- References on table (respect Zero machine)
|
|
-- Y Table
|
|
local Ori1 = Point3d( -21.991, -57.090, -11.511) * GEO.ONE_INCH
|
|
local Ori2 = Point3d( -21.991, -57.090, -11.511) * GEO.ONE_INCH
|
|
-- shift value
|
|
local vShift = Vector3d(0,0,0)
|
|
local vShiftVac = Vector3d(0,0,0)
|
|
local vShiftAct = Vector3d(0,0,0)
|
|
local vNullShift = Vector3d(0,0,0)
|
|
local vShiftLockSide = Vector3d(0,0,0)
|
|
-- variabile per posizione media della porta per il cambio navette
|
|
local dPosShuttleChange = 40 * GEO.ONE_INCH
|
|
-- tabella raggi profili su ogni lato
|
|
local tsRadiusProf = {}
|
|
local tsPlaneProf = {}
|
|
|
|
-- utilizzo la tabella dati cam
|
|
local sPathCurrMachtabOri = 'CurrCamInfo'
|
|
local mCamData = require( sPathCurrMachtabOri)
|
|
|
|
-- variabili pezzo singolo
|
|
local nPz
|
|
local sAssemb
|
|
|
|
-- variabile check dimensioni porta
|
|
local bFailDim = false
|
|
|
|
-- resetto la macchinata (riporto il pezzo in area disegno)
|
|
EgtResetCurrMachGroup()
|
|
|
|
-- elimino percorsi eventualmente creati dal Mach
|
|
-- cancello tutti i percorsi ghost
|
|
local DelList = MB.FindEntitiesWithPartName( tPz, '_HIDE')
|
|
-- ciclo su tutte le entità trovate
|
|
for j = 1, #DelList do
|
|
EgtErase( DelList[j] )
|
|
end
|
|
DelList = MB.FindEntitiesWithPartName( tPz, 'ROUGH_')
|
|
-- ciclo su tutte le entità trovate
|
|
for j = 1, #DelList do
|
|
EgtErase( DelList[j] )
|
|
end
|
|
|
|
-- se la variabile è una tabella, estrapolo solo la porta
|
|
local PzIsTab = type(tPz) == 'table'
|
|
if PzIsTab then
|
|
for v = 1, #tPz do
|
|
|
|
Pz = tPz[v]
|
|
sAssemb = tsAssemb[v]
|
|
|
|
-- se non ha nota o nota della prima porta esco
|
|
if not sAssemb or ( sAssemb and sAssemb == 'first') then
|
|
break
|
|
end
|
|
end
|
|
else
|
|
Pz = tPz
|
|
sAssemb = tsAssemb
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- Dati della porta
|
|
local sDoorCode = EgtGetInfo( Pz, 'Code')
|
|
local dWidthDoor = EgtGetInfo( Pz, 'W', 'd')
|
|
local dLengthDoor = EgtGetInfo( Pz, 'H', 'd')
|
|
local dThickDoor = EgtGetInfo( Pz, 'T', 'd')
|
|
local sSwing = EgtGetInfo( Pz, 'Swing')
|
|
MachiningsTable = EgtGetInfo( Pz, 'MTable') -- ottengo la tabella corrente
|
|
local sSecure = EgtGetInfo( Pz, 'Secure')
|
|
local sHingeTrim = EgtGetInfo( Pz, 'hingeedge_trimming')
|
|
local sLockTrim = EgtGetInfo( Pz, 'lockedge_trimming')
|
|
local sTopTrim = EgtGetInfo( Pz, 'top_trimming')
|
|
local sBottomTrim = EgtGetInfo( Pz, 'bottom_trimming')
|
|
local bHingeMach = EgtGetInfo( Pz, 'hingeedge_machining', 'b')
|
|
local bLockMach = EgtGetInfo( Pz, 'lockedge_machining', 'b')
|
|
local bTopMach = EgtGetInfo( Pz, 'top_machining', 'b')
|
|
local bBottomMach = EgtGetInfo( Pz, 'bottom_machining', 'b')
|
|
local bAtRight = ( sSwing:sub(1,1) == 'L') -- flag che viene settato a vero se serratura a destra
|
|
local bSwingDriveDisp = EgtGetInfo( Pz, 'SwingDriveDisp', 'b' )
|
|
local bOppoBevelProf = EgtGetInfo( Pz, 'OppoBevelProf', 'b' )
|
|
tsRadiusProf[1] = EgtGetInfo( Pz, 'RadHingeProfile', 'd')
|
|
tsRadiusProf[2] = EgtGetInfo( Pz, 'RadLockProfile', 'd')
|
|
tsRadiusProf[3] = EgtGetInfo( Pz, 'RadTopProfile', 'd')
|
|
tsRadiusProf[4] = EgtGetInfo( Pz, 'RadBottomProfile', 'd')
|
|
tsPlaneProf[1] = EgtGetInfo( Pz, 'PlnHingeProfile', 'd')
|
|
tsPlaneProf[2] = EgtGetInfo( Pz, 'PlnLockProfile', 'd')
|
|
tsPlaneProf[3] = EgtGetInfo( Pz, 'PlnTopProfile', 'd')
|
|
tsPlaneProf[4] = EgtGetInfo( Pz, 'PlnBottomProfile', 'd')
|
|
local dRadiusPrf = tsRadiusProf[1]
|
|
local dPlanePrf = tsPlaneProf[1]
|
|
local dNumHingesPivots = EgtGetInfo( Pz, 'NumHingesPivots', 'd') or 0
|
|
local dLeftOffs = EgtGetInfo( EgtGetFirstNameInGroup( Pz, 'Left') or GDB_ID.NULL, 'Offs', 'd') or 0
|
|
local dRightOffs = EgtGetInfo( EgtGetFirstNameInGroup( Pz, 'Right') or GDB_ID.NULL, 'Offs', 'd') or 0
|
|
local dTopOffs = EgtGetInfo( EgtGetFirstNameInGroup( Pz, 'Top') or GDB_ID.NULL, 'Offs', 'd') or 0
|
|
local dBottomOffs = EgtGetInfo( EgtGetFirstNameInGroup( Pz, 'Bottom') or GDB_ID.NULL, 'Offs', 'd') or 0
|
|
|
|
-- Box pezzo
|
|
local Ls = EgtGetFirstNameInGroup( Pz, 'SOLID')
|
|
local b3Part = EgtGetBBoxGlob( Pz, GDB_BB.EXACT)
|
|
|
|
local b3fx = BBox3d() -- inizializzo il box nullo
|
|
b3fx = MakeBoxFromSolidLayer( Ls, 0, Aux)
|
|
local b3Solid = b3fx
|
|
-- local b3Solid = EgtGetBBoxGlob( Ls, GDB_BB.EXACT)
|
|
|
|
-- Project path, name, extension
|
|
local sFilePath = EgtGetCurrFilePath()
|
|
local sFileDir, sFileName, sFileExt = EgtSplitPath( sFilePath)
|
|
|
|
------------------------------------------------------
|
|
-- se codice porta contiene comandi speciali
|
|
-- che non producono la generazione del part program della porta ma dei part program speciali
|
|
if sDoorCode then
|
|
local sCode = string.lower(sDoorCode)
|
|
if sCode == 'p1' or sCode == 'p2' or sCode == 'p3' or sCode == 'p4' or sCode == 'p5' or sCode == 'p6' then
|
|
EgtSetInfo( Pz, 'SpecialCmd', sCode)
|
|
end
|
|
end
|
|
------------------------------------------------------
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- *** settaggi CAM *** -- Mtable 1
|
|
if not MachiningsTable then -- se non c'è il nome della MTable esco
|
|
DoorOutLog( string.format(EgtDoorsMsg[597], MachiningsTable), 0) -- errore, file di tabella non trovato
|
|
return false
|
|
end
|
|
EgtAddToPackagePath( sBaseDir .. 'MTables\\?.mtl')
|
|
local TAB
|
|
if EgtExistsFile( sBaseDir .. 'MTables\\' .. MachiningsTable .. '.mtl') then
|
|
TAB = require( MachiningsTable)
|
|
if not TAB then
|
|
DoorOutLog( string.format(EgtDoorsMsg[490], sBaseDir .. 'MTables\\' .. MachiningsTable .. '.mtl'), 0) -- errore tabella non trovata nel file
|
|
return false
|
|
end
|
|
else
|
|
DoorOutLog( string.format(EgtDoorsMsg[597], sBaseDir .. 'MTables\\' .. MachiningsTable .. '.mtl'), 0) -- errore, file di tabella non trovato
|
|
return false
|
|
end
|
|
local MachinesName = TAB.MMachineData
|
|
if not MachinesName then
|
|
DoorOutLog( string.format(EgtDoorsMsg[491], ''), 0) -- Errore! Nome macchina: non presente in MTable
|
|
return false
|
|
end
|
|
-- *** settaggi CAM *** -- Mtable 2
|
|
MachiningsTableOrd = MachiningsTable..'_'..EgtNumToString(nNumMachFromTable,0)
|
|
EgtAddToPackagePath( sBaseDir .. 'MTables\\?.otl')
|
|
local TABORD
|
|
if EgtExistsFile( sBaseDir .. 'MTables\\' .. MachiningsTableOrd .. '.otl') then
|
|
TABORD = require( MachiningsTableOrd)
|
|
if not TABORD then
|
|
DoorOutLog( string.format(EgtDoorsMsg[490], sBaseDir .. 'MTables\\' .. MachiningsTableOrd .. '.otl'), 0) -- errore tabella non trovata nel file
|
|
return false
|
|
end
|
|
else
|
|
DoorOutLog( string.format(EgtDoorsMsg[597], sBaseDir .. 'MTables\\' .. MachiningsTableOrd .. '.otl'), 0) -- errore tabella non trovata nel file
|
|
return false
|
|
end
|
|
|
|
local dMaxDoorLength
|
|
local dMinDoorLength
|
|
local dMaxDoorWidth
|
|
local dMinDoorWidth
|
|
local dMaxDoorThick
|
|
local dMinDoorThick
|
|
local nForceUseShuttle
|
|
local nForceDisableHood
|
|
local dAltRef
|
|
local dTallRef
|
|
local sLocSecure
|
|
local dMaxOverMat
|
|
local dStepOverMat
|
|
local dMaxDistToChain
|
|
local dExtraThruDepth
|
|
local nGenCncAsDdfName
|
|
local dBladePerpLeadIn
|
|
local dPercRedFeed
|
|
|
|
-- imposto i dati macchina secondo le informazioni del file cam
|
|
MachName = mCamData[nNumMachFromCam].MachName
|
|
Ori1 = mCamData[nNumMachFromCam].Ori1
|
|
Ori2 = mCamData[nNumMachFromCam].Ori2
|
|
vShiftAct = mCamData[nNumMachFromCam].Shift1
|
|
vShiftLockSide = mCamData[nNumMachFromCam].ShiftLck
|
|
dMaxDoorLength = mCamData[nNumMachFromCam].MaxDoorLength
|
|
dMinDoorLength = mCamData[nNumMachFromCam].MinDoorLength
|
|
dMaxDoorWidth = mCamData[nNumMachFromCam].MaxDoorWidth
|
|
dMinDoorWidth = mCamData[nNumMachFromCam].MinDoorWidth
|
|
dMaxDoorThick = mCamData[nNumMachFromCam].MaxDoorThick
|
|
dMinDoorThick = mCamData[nNumMachFromCam].MinDoorThick
|
|
nForceUseShuttle = mCamData[nNumMachFromCam].ForceShuttleUse
|
|
nForceDisableHood = mCamData[nNumMachFromCam].ForceDisableHood
|
|
dAltRef = mCamData[nNumMachFromCam].dAltRef
|
|
dTallRef = mCamData[nNumMachFromCam].dTallRef
|
|
sLocSecure = mCamData[nNumMachFromCam].sLocSecure
|
|
dMaxOverMat = mCamData[nNumMachFromCam].MaxOverMat
|
|
dStepOverMat = mCamData[nNumMachFromCam].StepOverMat or 10
|
|
dMaxDistToChain = mCamData[nNumMachFromCam].MaxDistToChain
|
|
dExtraThruDepth = mCamData[nNumMachFromCam].ExtraThruDepthMachining
|
|
nGenCncAsDdfName = mCamData[nNumMachFromCam].nGenCncAsDdfName or 0
|
|
dBladePerpLeadIn = mCamData[nNumMachFromCam].BladePerpLeadIn or (3*25.4)
|
|
dPercRedFeed = mCamData[nNumMachFromCam].PercRedFeed or 0.3
|
|
Big_Dorr_Height = mCamData[nNumMachFromCam].BigDoorHeight or 2700.0
|
|
|
|
-- se non devo generare il cn esco subito
|
|
if MachinesName[nNumMachFromTable].NcGenerate ~= nil and not MachinesName[nNumMachFromTable].NcGenerate then
|
|
DoorOutLog( string.format(EgtDoorsMsg[492], MachName), 0) -- warning. Cnc generation disable
|
|
return true
|
|
end
|
|
|
|
-- setto come generare il nome del file cnc (di default è uguale al nome del parametro interno ad ddf)
|
|
if nGenCncAsDdfName == 0 then
|
|
-- assegno al nome file il nome del campo code, come faccio nel main quando creo più pezzi
|
|
sFileName = sDoorCode
|
|
end
|
|
|
|
local MTable = TAB.MTable
|
|
local MTableOrd = TABORD.MTable
|
|
-- variabile principale per definizione disposizione porta a destra o sinistra
|
|
local sLocMachId
|
|
local bOk = true
|
|
local bFirstStep = true
|
|
local bShiftedDoor = false
|
|
local sDispMode
|
|
local sTotDispMode = ''
|
|
local sNumGroup = ''
|
|
local bWork = true
|
|
-- variabili utilizzate dentro al ciclo
|
|
local nMchId
|
|
local sTab
|
|
local tabOri
|
|
local Ori
|
|
local ColA
|
|
local nRaw
|
|
local bMoveRaw
|
|
local bPush
|
|
local bFlip
|
|
local bTopOnRight
|
|
-- variabili per disposizione sottopezzi
|
|
local dMobOffs
|
|
local dVacOffs
|
|
local dDistMinX
|
|
local dDistMaxX
|
|
local dVacOn
|
|
local dInterAx
|
|
local OffsXSovr = 0
|
|
local OffsYSovr = 0
|
|
local dDistInterferThru
|
|
local dDistInterferBlind
|
|
local dDistInterferUnder
|
|
-- variabile per tool setup
|
|
local MSetup
|
|
local sSetup
|
|
-- variabili calcolo box
|
|
local b3SolidOnTab
|
|
local pMin
|
|
local pMax
|
|
-- variabili conteggio lavorazioni profilatura bevel e saltate
|
|
local nNumMachSkip = 0
|
|
local bLocMach
|
|
local sMachProf
|
|
local bNoVertProf = true
|
|
local bWorkUnder = true
|
|
-- variabile per conteggio lavorazioni
|
|
local nNumMach
|
|
local nNumSkip
|
|
local tSecMachTab = {}
|
|
-- variabili per fase
|
|
local nNumPhase
|
|
local nNumCycle = 1
|
|
-- variabili per gestione ripresa porta
|
|
local bFlipFirst
|
|
local bTopOnRightFirst
|
|
local sProfiles = ''
|
|
local nNumGeomBottom = 0
|
|
local nNumGeomTop = 0
|
|
local nNumGeomBottomHole = 0
|
|
local nNumGeomTopHole = 0
|
|
-- variabili per geometrie lato Hinge
|
|
local nNumTopGeom = 0
|
|
local nNumBottomGeom = 0
|
|
-- variabile piazzamento porta
|
|
local sLight
|
|
-- variabile direzione riordino gruppi
|
|
local nDirReorderGroups
|
|
-- tabella lavorazioni
|
|
local tLocMach = {}
|
|
local tLocMachOrd = {}
|
|
|
|
-- Set Current Machine: si setta sulla fase 1
|
|
EgtSetCurrMachine( MachName)
|
|
|
|
-------------------------------------------------------------------------------------------------------
|
|
-- per questa macchina è importante differenziare il nome del profilo lato lock rispetto al lato hinge
|
|
-- in modo che venga lavorato prima il lato hinge e poi il lock
|
|
-------------------------------------------------------------------------------------------------------
|
|
-- Recupero le entità
|
|
local nLockProf
|
|
-- se serratura è a destra cerco il nome dl profilo corrispondente a quel lato
|
|
if bAtRight then
|
|
nLockProf = EgtGetFirstNameInGroup( Pz, 'Right')
|
|
else
|
|
nLockProf = EgtGetFirstNameInGroup( Pz, 'Left')
|
|
end
|
|
|
|
local EntListHg = MB.FindEntities( nLockProf)
|
|
sLockTrim = sLockTrim..'_LK'
|
|
|
|
-- rinomino tutte le entità del gruppo
|
|
for j = 1, #EntListHg do
|
|
local sNameEnt = EgtGetName( EntListHg[j])
|
|
if not string.find( sNameEnt, '_LK') then
|
|
sNameEnt = sNameEnt .. '_LK'
|
|
end
|
|
EgtSetName( EntListHg[j], sNameEnt)
|
|
end
|
|
|
|
-- faccio tutte le fasi ( probabilmente solo una perché non sono previsti ribaltamenti)
|
|
while bWork do
|
|
|
|
sDispMode = ''
|
|
bMachUnder = nil
|
|
|
|
nNumGroup = nNumGroup + 1
|
|
-- Set Machining Group
|
|
if not sAssemb then -- se pezzo unico
|
|
nMchId = EgtAddMachGroup( 'Mach_' .. EgtNumToString(nNumGroup,0) .. '_' .. MachName)
|
|
else
|
|
nMchId = EgtAddMachGroup( 'Id_'.. EgtNumToString(Pz,0) ..'_'..'Mach_' .. EgtNumToString(nNumGroup,0) .. '_' .. MachName)
|
|
end
|
|
nNumPhase = EgtGetCurrPhase()
|
|
|
|
-----------------------------------------------------------------------
|
|
-- Calcolo dei sovramateriali e definizione e posizionamento del grezzo
|
|
-----------------------------------------------------------------------
|
|
|
|
-- se check macchina settato per non gestire grezzo
|
|
if MachinesName[nNumMachFromTable].MakeRaw ~= nil and not MachinesName[nNumMachFromTable].MakeRaw then
|
|
dLeftOffs = 0
|
|
dRightOffs = 0
|
|
dTopOffs = 0
|
|
dBottomOffs = 0
|
|
end
|
|
|
|
ColA = Color3d( 255, 165, 0, 15)
|
|
nRaw = EgtAddRawPart( Point3d(0,0,0),b3Solid:getDimX() + dLeftOffs + dRightOffs,
|
|
b3Solid:getDimY() + dTopOffs + dBottomOffs, b3Solid:getDimZ(), ColA)
|
|
EgtAddPartToRawPart( Pz, b3Part:getMin() - b3Solid:getMin() + Vector3d( dLeftOffs, dBottomOffs, 0), nRaw)
|
|
|
|
-- fase premach, in base al profilo cerniere e/o serratura, e se ci sono lavorazioni sopra o sotto o entrambe,
|
|
-- decido su quale lato disporre la porta per evitare inutili ribaltamenti
|
|
|
|
-- ricavo minimo e massimo del solido del pezzo
|
|
b3SolidOnTab = EgtGetBBoxGlob( Ls, GDB_BB.EXACT)
|
|
pMin = b3SolidOnTab:getMin()
|
|
pMax = b3SolidOnTab:getMax()
|
|
|
|
tLocMach = MTable
|
|
tLocMachOrd = MTableOrd
|
|
sMachProf = ''
|
|
|
|
-- prendo nota dei profili tipo bevel e bull nose
|
|
-- verifico se cave da sotto o da sopra
|
|
-- verifico se trovate lavorazioni applicate con 'shift'
|
|
local nUnderGeom
|
|
|
|
for i = 1, #tLocMach do
|
|
if tLocMach[i].On ~= 0 then
|
|
sLocMachId = tLocMach[i].MachId
|
|
-- se non c'è il campo macchina setto di default la 1
|
|
if not sLocMachId then sLocMachId = 1 end
|
|
|
|
-- se macchina corrispondente
|
|
if sLocMachId == nNumMachFromTable then
|
|
|
|
local sUpperProfName = string.upper(tLocMach[i].Name)
|
|
-- prendo i profili bevel direttamente dalla tabella
|
|
if tLocMach[i].Oper and tLocMach[i].Oper == 'AdjustBevel' then
|
|
if not string.find( sProfiles, sUpperProfName) then
|
|
sProfiles = sProfiles .. sUpperProfName .. ','
|
|
end
|
|
end
|
|
|
|
-- Recupero le entità
|
|
local EntList = MB.FindEntitiesWithName( Pz, tLocMach[i].Name)
|
|
-- Test delle lavorazioni
|
|
for j = 1, #EntList do
|
|
-- OPERAZIONI
|
|
if tLocMach[i].Oper == 'AdjustThrouIsle' then
|
|
bLocMach, nUnderGeom = MB.TestThrouIsle( EntList[j], b3Solid:getDimZ(), pMin, pMax, bWorkUnder)
|
|
if bLocMach then
|
|
if nUnderGeom and nUnderGeom == 1 then
|
|
nNumGeomBottom = nNumGeomBottom + 1
|
|
elseif nUnderGeom and nUnderGeom == -1 then
|
|
nNumGeomTop = nNumGeomTop + 1
|
|
end
|
|
end
|
|
elseif tLocMach[i].Oper == 'AdjustVertHole' then
|
|
bLocMach, nUnderGeom = MB.TestVertHole( EntList[j], b3Solid:getDimZ(), pMin, pMax, bWorkUnder)
|
|
if bLocMach then
|
|
if nUnderGeom and nUnderGeom == 1 then
|
|
nNumGeomBottom = nNumGeomBottom + 1
|
|
nNumGeomBottomHole = nNumGeomBottomHole + 1
|
|
elseif nUnderGeom and nUnderGeom == -1 then
|
|
nNumGeomTop = nNumGeomTop + 1
|
|
nNumGeomTopHole = nNumGeomTopHole + 1
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-----------------------
|
|
-- *** Disposizione ***
|
|
-----------------------
|
|
|
|
-- controllo se ho profili bullnose sul lato hinge (INDIPENDENTEMENTE CHE SIANO O MENO DA LAVORARE)
|
|
if ( sHingeTrim == '1B' or sHingeTrim == '2B') then -- se profilo cerniere è bullnose
|
|
bShiftedDoor = true
|
|
end
|
|
|
|
-- controllo se ho profili bullnose sul lato serratura (INDIPENDENTEMENTE CHE SIANO O MENO DA LAVORARE)
|
|
if ( sLockTrim == '1B_LK' or sLockTrim == '2B_LK' or sLockTrim == '3B_LK' or sLockTrim == '4B_LK') then -- se profilo serratura indicato è bullnose
|
|
vShiftVac = vShiftLockSide
|
|
else
|
|
vShiftVac = vNullShift
|
|
end
|
|
|
|
-- Scelta della tavola
|
|
sTab = 'Tab'
|
|
EgtSetTable( sTab)
|
|
|
|
-- Origine tavola corrente rispetto a Zero macchina
|
|
tabOri = EgtGetTableRef( 1)
|
|
-- Scelta dell'origine (ora espressa rispetto Zero Tavola)
|
|
Ori = EgtIf( DISPMODE > 0, Ori1, Ori2)
|
|
|
|
-- se porta da traslare setto lo shift da applicare
|
|
if bShiftedDoor then
|
|
vShift = vShiftAct
|
|
else
|
|
vShift = vNullShift
|
|
end
|
|
|
|
Ori = Ori + vShift
|
|
|
|
-- Rotazione porta in base alla macchina
|
|
bMoveRaw = false
|
|
|
|
-- definito col cliente: prima comanda il lato hinge, se ha il bevel lo si dispone secondo quello che c'è nel ddf
|
|
-- se il lato hinge non ha profilo bevel si guarda il profilo lock, se ha un bevel allora guardo quello.
|
|
-- in caso di inactive doors con bevel paralleli comanda ovviamente il lato hinge
|
|
-- in caso nessuno dei due lati ha un profilo bevel, utilizzo il parametro Secure passato nel ddf
|
|
-- se non c'è il parametro considero la porta come se avesse bevel down
|
|
-- ed effettuo il ribaltamento e rotazioni in base allo swing ( con DGD.SwDD = 1 nel file EgtDoorsData)
|
|
if sSwing == 'RH' or sSwing == 'RHA' or sSwing == 'RHI' or
|
|
sSwing == 'LH' or sSwing == 'LHA' or sSwing == 'LHI' then
|
|
bPush = true
|
|
else
|
|
bPush = false
|
|
end
|
|
|
|
local sNumPhase
|
|
if nNumPhase and nNumPhase < 10 then
|
|
sNumPhase = '0'.. tostring( nNumPhase)
|
|
elseif nNumPhase then
|
|
sNumPhase = tostring( nNumPhase)
|
|
else
|
|
sNumPhase = '0'
|
|
end
|
|
|
|
local bOkDisp = false
|
|
|
|
-- prima controllo che il lato cerniere abbia un bevel (da lavorare), se no passo al lato serratura,
|
|
-- se non ha bevel nemmeno il lato serratura considero il parametro secure
|
|
-- if ( sHingeTrim == 'BD' or sHingeTrim == 'BU') and bHingeMach then -- se profilo cerniera indicato bevel e da lavorare
|
|
if ( sHingeTrim == 'BD' or sHingeTrim == 'BU' or sHingeTrim == 'BDEB' or sHingeTrim == 'BUEB') then -- se profilo cerniera indicato bevel
|
|
|
|
-- verifico se i profili risultanti sono presenti in tabella
|
|
if sHingeTrim == 'BD' and bPush and string.find( sProfiles, 'BU,') then
|
|
bOkDisp = true
|
|
elseif sHingeTrim == 'BDEB' and bPush and string.find( sProfiles, 'BU,') then
|
|
bOkDisp = true
|
|
elseif sHingeTrim == 'BD' and not bPush and string.find( sProfiles, 'BD,') then
|
|
bOkDisp = true
|
|
elseif sHingeTrim == 'BDEB' and not bPush and string.find( sProfiles, 'BD,') then
|
|
bOkDisp = true
|
|
elseif sHingeTrim == 'BU' and not bPush and string.find( sProfiles, 'BD,') then
|
|
bOkDisp = true
|
|
elseif sHingeTrim == 'BUEB' and not bPush and string.find( sProfiles, 'BD,') then
|
|
bOkDisp = true
|
|
elseif sHingeTrim == 'BU' and bPush and string.find( sProfiles, 'BU,') then
|
|
bOkDisp = true
|
|
elseif sHingeTrim == 'BUEB' and bPush and string.find( sProfiles, 'BU,') then
|
|
bOkDisp = true
|
|
end
|
|
|
|
if bOkDisp then
|
|
|
|
-- casi in cui il bevel indicato nel ddf non corrisponde al bevel generato dallo swing
|
|
-- devo ribaltare la porta e la parte top va posizionata in modo che il lato cerniere sia davanti
|
|
if ( ( sHingeTrim == 'BD' or sHingeTrim == 'BDEB') and bPush) or
|
|
( ( sHingeTrim == 'BU' or sHingeTrim == 'BUEB') and not bPush) then
|
|
|
|
bFlip = true
|
|
if bAtRight then -- se serratura a destra
|
|
bTopOnRight = true
|
|
else
|
|
bTopOnRight = false
|
|
end
|
|
|
|
-- gli altri casi in cui il bevel indicato corrisponde al bevel generato dallo swing
|
|
-- non devo ribaltare la porta e la parte top va posizionata in modo che il lato cerniere sia davanti
|
|
else
|
|
|
|
bFlip = false
|
|
if bAtRight then -- se serratura a destra
|
|
bTopOnRight = false
|
|
else
|
|
bTopOnRight = true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- se profilo serratura indicato bevel (e da lavorare)
|
|
-- if ( sLockTrim == 'BD_LK' or sLockTrim == 'BU_LK') and bLockMach and not bOkDisp then
|
|
if ( sLockTrim == 'BD_LK' or sLockTrim == 'BU_LK' or sLockTrim == 'BDEB_LK' or sLockTrim == 'BUEB_LK') and not bOkDisp then
|
|
|
|
-- verifico se i profili risultanti sono presenti in tabella
|
|
if sLockTrim == 'BD_LK' and bPush and string.find( sProfiles, 'BU_LK,') then
|
|
bOkDisp = true
|
|
elseif sLockTrim == 'BDEB_LK' and bPush and string.find( sProfiles, 'BU_LK,') then
|
|
bOkDisp = true
|
|
elseif sLockTrim == 'BD_LK' and not bPush and string.find( sProfiles, 'BD_LK,') then
|
|
bOkDisp = true
|
|
elseif sLockTrim == 'BDEB_LK' and not bPush and string.find( sProfiles, 'BD_LK,') then
|
|
bOkDisp = true
|
|
elseif sLockTrim == 'BU_LK' and not bPush and string.find( sProfiles, 'BD_LK,') then
|
|
bOkDisp = true
|
|
elseif sLockTrim == 'BUEB_LK' and not bPush and string.find( sProfiles, 'BD_LK,') then
|
|
bOkDisp = true
|
|
elseif sLockTrim == 'BU_LK' and bPush and string.find( sProfiles, 'BU_LK,') then
|
|
bOkDisp = true
|
|
elseif sLockTrim == 'BUEB_LK' and not bPush and string.find( sProfiles, 'BD_LK,') then
|
|
bOkDisp = true
|
|
end
|
|
|
|
if bOkDisp then
|
|
|
|
-- casi in cui il bevel indicato nel ddf non corrisponde al bevel generato dallo swing
|
|
-- a meno che ho il profilo opposto, in questo caso non ribalto la porta, altrimenti devo ribaltare la porta
|
|
-- e la parte top va posizionata in modo che il lato cerniere sia davanti
|
|
if ( ( sLockTrim == 'BD_LK' or sLockTrim == 'BDEB_LK') and bPush) or
|
|
( ( sLockTrim == 'BU_LK' or sLockTrim == 'BUEB_LK') and not bPush and not bOppoBevelProf) or
|
|
( ( sLockTrim == 'BU_LK' or sLockTrim == 'BUEB_LK') and bPush and bOppoBevelProf) then
|
|
|
|
bFlip = true
|
|
if bAtRight then -- se serratura a destra
|
|
bTopOnRight = true
|
|
else
|
|
bTopOnRight = false
|
|
end
|
|
|
|
-- gli altri casi in cui il bevel indicato corrisponde al bevel generato dallo swing
|
|
-- non devo ribaltare la porta e la parte top va posizionata in modo che il lato cerniere sia davanti
|
|
else
|
|
|
|
bFlip = false
|
|
if bAtRight then -- se serratura a destra
|
|
bTopOnRight = false
|
|
else
|
|
bTopOnRight = true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- se profilo top indicato bevel (e da lavorare)
|
|
if ( sTopTrim == 'BD' or sTopTrim == 'BU' or sTopTrim == 'BDEB' or sTopTrim == 'BUEB') and not bOkDisp then
|
|
|
|
-- verifico se i profili risultanti sono presenti in tabella
|
|
if sTopTrim == 'BD' and bPush and string.find( sProfiles, 'BU,') then
|
|
bOkDisp = true
|
|
elseif sTopTrim == 'BDEB' and bPush and string.find( sProfiles, 'BU,') then
|
|
bOkDisp = true
|
|
elseif sTopTrim == 'BD' and not bPush and string.find( sProfiles, 'BD,') then
|
|
bOkDisp = true
|
|
elseif sTopTrim == 'BDEB' and not bPush and string.find( sProfiles, 'BD,') then
|
|
bOkDisp = true
|
|
elseif sTopTrim == 'BU' and not bPush and string.find( sProfiles, 'BD,') then
|
|
bOkDisp = true
|
|
elseif sTopTrim == 'BUEB' and not bPush and string.find( sProfiles, 'BD,') then
|
|
bOkDisp = true
|
|
elseif sTopTrim == 'BU' and bPush and string.find( sProfiles, 'BU,') then
|
|
bOkDisp = true
|
|
elseif sTopTrim == 'BUEB' and bPush and string.find( sProfiles, 'BU,') then
|
|
bOkDisp = true
|
|
end
|
|
|
|
if bOkDisp then
|
|
|
|
-- casi in cui il bevel indicato nel ddf non corrisponde al bevel generato dallo swing
|
|
-- devo ribaltare la porta e la parte top va posizionata in modo che il lato cerniere sia davanti
|
|
if ( ( sTopTrim == 'BD' or sTopTrim == 'BDEB') and bPush) or
|
|
( ( sTopTrim == 'BU' or sTopTrim == 'BUEB') and not bPush) then
|
|
|
|
bFlip = true
|
|
if bAtRight then -- se serratura a destra
|
|
bTopOnRight = true
|
|
else
|
|
bTopOnRight = false
|
|
end
|
|
|
|
-- gli altri casi in cui il bevel indicato corrisponde al bevel generato dallo swing
|
|
-- non devo ribaltare la porta e la parte top va posizionata in modo che il lato cerniere sia davanti
|
|
else
|
|
|
|
bFlip = false
|
|
if bAtRight then -- se serratura a destra
|
|
bTopOnRight = false
|
|
else
|
|
bTopOnRight = true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- se profilo top indicato bevel (e da lavorare)
|
|
if ( sBottomTrim == 'BD' or sBottomTrim == 'BU' or sBottomTrim == 'BDEB' or sBottomTrim == 'BUEB') and not bOkDisp then
|
|
|
|
-- verifico se i profili risultanti sono presenti in tabella
|
|
if sBottomTrim == 'BD' and bPush and string.find( sProfiles, 'BU,') then
|
|
bOkDisp = true
|
|
elseif sBottomTrim == 'BDEB' and bPush and string.find( sProfiles, 'BU,') then
|
|
bOkDisp = true
|
|
elseif sBottomTrim == 'BD' and not bPush and string.find( sProfiles, 'BD,') then
|
|
bOkDisp = true
|
|
elseif sBottomTrim == 'BDEB' and not bPush and string.find( sProfiles, 'BD,') then
|
|
bOkDisp = true
|
|
elseif sBottomTrim == 'BU' and not bPush and string.find( sProfiles, 'BD,') then
|
|
bOkDisp = true
|
|
elseif sBottomTrim == 'BUEB' and not bPush and string.find( sProfiles, 'BD,') then
|
|
bOkDisp = true
|
|
elseif sBottomTrim == 'BU' and bPush and string.find( sProfiles, 'BU,') then
|
|
bOkDisp = true
|
|
elseif sBottomTrim == 'BUEB' and bPush and string.find( sProfiles, 'BU,') then
|
|
bOkDisp = true
|
|
end
|
|
|
|
if bOkDisp then
|
|
|
|
-- casi in cui il bevel indicato nel ddf non corrisponde al bevel generato dallo swing
|
|
-- devo ribaltare la porta e la parte top va posizionata in modo che il lato cerniere sia davanti
|
|
if ( ( sBottomTrim == 'BD' or sBottomTrim == 'BDEB') and bPush) or
|
|
( ( sBottomTrim == 'BU' or sBottomTrim == 'BUEB') and not bPush) then
|
|
|
|
bFlip = true
|
|
if bAtRight then -- se serratura a destra
|
|
bTopOnRight = true
|
|
else
|
|
bTopOnRight = false
|
|
end
|
|
|
|
-- gli altri casi in cui il bevel indicato corrisponde al bevel generato dallo swing
|
|
-- non devo ribaltare la porta e la parte top va posizionata in modo che il lato cerniere sia davanti
|
|
else
|
|
|
|
bFlip = false
|
|
if bAtRight then -- se serratura a destra
|
|
bTopOnRight = false
|
|
else
|
|
bTopOnRight = true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- in caso non ci sia nessun profilo bevel verifico il parametro Secure
|
|
if not bOkDisp then
|
|
|
|
-- se il parametro secure è passato con valore '0' prendo quello del CurCamInfo atrimenti do errore
|
|
if sSecure and string.upper(sSecure) == '0' then
|
|
-- se parametro da CurrcamInfo non è valido do errore
|
|
if not sLocSecure or ( string.upper(sLocSecure) ~= 'UP' and string.upper(sLocSecure) ~= 'DN') then
|
|
bOk = false
|
|
DGD.EMC = ' ' .. EgtDoorsMsg[590]
|
|
break
|
|
else
|
|
sSecure = sLocSecure
|
|
end
|
|
end
|
|
|
|
-- se lato secure va sopra il ribaltamento è obbligato
|
|
if sSecure and string.upper(sSecure) == 'UP' then
|
|
bFlip = true
|
|
if bAtRight then -- se serratura a destra
|
|
bTopOnRight = true
|
|
else
|
|
bTopOnRight = false
|
|
end
|
|
elseif sSecure and string.upper(sSecure) == 'DN' then
|
|
bFlip = false
|
|
if bAtRight then -- se serratura a destra
|
|
bTopOnRight = false
|
|
else
|
|
bTopOnRight = true
|
|
end
|
|
-- altrimenti la preferenza sembrerebbe essere ( non è ancora confermata) quella di considerare la porta bevel down
|
|
-- quindi se è una reverse non deve essere ribaltata, mentre se è normale deve essere ribaltata
|
|
-- ed effettuo il ribaltamento e rotazioni in base allo swing ( con DGD.SwDD = 1 nel file EgtDoorsData)
|
|
else
|
|
|
|
if bSwingDriveDisp then -- se metodo di posizionamento guidato dallo swing
|
|
|
|
-- se porta a spingere ( dovrebbe avere bevel up) la ribalto per essere bevel down
|
|
if bPush then
|
|
bFlip = true
|
|
if bAtRight then -- se serratura a destra
|
|
bTopOnRight = true
|
|
else
|
|
bTopOnRight = false
|
|
end
|
|
-- se porta a tirare non la ribalto perché si presta già ad essere bevel down
|
|
else
|
|
bFlip = false
|
|
if bAtRight then -- se serratura a destra
|
|
bTopOnRight = false
|
|
else
|
|
bTopOnRight = true
|
|
end
|
|
end
|
|
else -- in base alle geometrie trovate ribalto o meno la porta
|
|
|
|
if nNumGeomBottom > nNumGeomTop then
|
|
bFlip = true
|
|
if bAtRight then -- se serratura a destra
|
|
bTopOnRight = true
|
|
else
|
|
bTopOnRight = false
|
|
end
|
|
elseif nNumGeomTop >= nNumGeomBottom then
|
|
bFlip = false
|
|
if bAtRight then -- se serratura a destra
|
|
bTopOnRight = false
|
|
else
|
|
bTopOnRight = true
|
|
end
|
|
else -- altrimenti vecchio metodo
|
|
bFlip = true
|
|
if bAtRight then -- se serratura a destra
|
|
bTopOnRight = true
|
|
else
|
|
bTopOnRight = false
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- faccio le rotazioni della porta
|
|
if bFlip then
|
|
EgtRotateRawPart( nRaw, Y_AX(), 180)
|
|
sDispMode = sDispMode .. EgtDoorsMsg[511] .. sNumPhase .. ' ' .. EgtDoorsMsg[479]
|
|
else
|
|
sDispMode = sDispMode .. EgtDoorsMsg[511] .. sNumPhase .. ' ' .. EgtDoorsMsg[480]
|
|
end
|
|
|
|
if bTopOnRight then
|
|
EgtRotateRawPart( nRaw, Z_AX(), -90)
|
|
sDispMode = sDispMode .. EgtDoorsMsg[481]
|
|
else
|
|
EgtRotateRawPart( nRaw, Z_AX(), 90)
|
|
sDispMode = sDispMode .. EgtDoorsMsg[482]
|
|
end
|
|
|
|
if bShiftedDoor then
|
|
sDispMode = sDispMode .. EgtDoorsMsg[510]
|
|
end
|
|
sTotDispMode = sTotDispMode .. ' ' .. sDispMode .. '\n'
|
|
|
|
------------------------------------------------------------------
|
|
-- calcolo delta Y in base al profilo e al ribaltamento del pezzo
|
|
------------------------------------------------------------------
|
|
local vExtraYDelta
|
|
local dExtraY = 0
|
|
local dDeltaProbe = 0
|
|
-- variabili per note relative al lato hinges
|
|
local nHingeMach = 0 -- setto default non lavorato
|
|
local nLockMach = 0 -- setto default non lavorato
|
|
local nSideType = -1 -- 0 per profili SQ
|
|
|
|
if sHingeTrim == 'SQ' or sHingeTrim == 'EB' then
|
|
nSideType = 0
|
|
-- se disposizione bevel down uso il riferimento in alto
|
|
elseif sHingeTrim == 'BD' or sHingeTrim == 'BDEB' then
|
|
nSideType = 1
|
|
if dThickDoor > dAltRef then
|
|
dExtraY = ( dThickDoor - dAltRef) * TAN3
|
|
end
|
|
-- calcolo errore del probe tastando a metà spessore
|
|
dDeltaProbe = (( dThickDoor / 2) * TAN3) - dExtraY
|
|
-- se disposizione bevel up uso il riferimento in basso
|
|
elseif sHingeTrim == 'BU' or sHingeTrim == 'BUEB' then
|
|
nSideType = 2
|
|
dExtraY = ( dAltRef - dTallRef) * TAN3
|
|
-- calcolo errore del probe tastando a metà spessore
|
|
dDeltaProbe = (( dThickDoor / 2) * TAN3) - dExtraY
|
|
-- se profilo bull nose verifico in base al raggio
|
|
elseif sHingeTrim == '1B' or sHingeTrim == '2B' or
|
|
sHingeTrim == '3B' or sHingeTrim == '4B' then
|
|
|
|
nSideType = 3
|
|
-- calcolo punto massimo ingombro profilo
|
|
local dAltProf = dThickDoor/2
|
|
local dAltcalc = 0
|
|
|
|
-- se punto max è sotto il minimo riferimento
|
|
if dAltProf < ( dAltRef - dTallRef) then
|
|
dAltcalc = dAltRef - dTallRef - dAltProf
|
|
-- se punto max è sopra il massimo riferimento
|
|
elseif dAltProf > dAltRef then
|
|
dAltcalc = dAltProf - dAltRef
|
|
end
|
|
|
|
-- se punto massimo profilo non è compreso nel riferimento calcolo il delta Y
|
|
if dAltcalc > 0 then
|
|
dExtraY = dRadiusPrf - sqrt((dRadiusPrf*dRadiusPrf)-(dAltcalc*dAltcalc))
|
|
end
|
|
-- calcolo errore del probe tastando a metà spessore
|
|
dDeltaProbe = -dExtraY
|
|
-- se profilo convex verifico in base al raggio
|
|
elseif sHingeTrim == 'CV' then
|
|
|
|
nSideType = 4
|
|
-- calcolo punto minimo ingombro profilo
|
|
local dAltProf = dThickDoor/2
|
|
local dAltcalc = (dTallRef/2)
|
|
-- calcolo il delta Y massimo del minimo ingombro profilo
|
|
local dMaxInsPrf = sqrt((dRadiusPrf*dRadiusPrf)-((dAltProf-dPlanePrf)*(dAltProf-dPlanePrf)))
|
|
|
|
-- se riferimento è sul max ingombro porta
|
|
if ( dThickDoor < dAltRef) and ( dThickDoor > ( dAltRef - dTallRef)) then
|
|
dAltcalc = 0
|
|
-- se punto minimo ingombro profilo è sotto all'altezza media del riferimento
|
|
elseif dAltProf < ( dAltRef - (dTallRef/2)) then
|
|
dAltcalc = dAltRef - dAltProf
|
|
-- se punto minimo ingombro profilo è sopra all'altezza media del riferimento
|
|
elseif dAltProf > ( dAltRef - (dTallRef/2)) then
|
|
dAltcalc = dAltProf - dAltRef + dTallRef
|
|
end
|
|
|
|
-- calcolo il delta Y
|
|
if dAltcalc > 0 then
|
|
dExtraY = sqrt((dRadiusPrf*dRadiusPrf)-(dAltcalc*dAltcalc)) - dMaxInsPrf
|
|
end
|
|
-- calcolo errore del probe tastando a metà spessore
|
|
dDeltaProbe = dRadiusPrf - dExtraY
|
|
end
|
|
|
|
-- se profilo hinge è da lavorare annullo il delta Y e setto il valore della nota
|
|
if bHingeMach then
|
|
dExtraY = 0
|
|
nHingeMach = 1
|
|
dDeltaProbe = 0
|
|
end
|
|
-- se profilo lock da lavorare setto la variabile per la nota
|
|
if bLockMach then
|
|
nLockMach = 1
|
|
end
|
|
|
|
vExtraYDelta = Vector3d(0,-dExtraY,0)
|
|
-- scrivo le note
|
|
EgtSetInfo( Pz, 'ExtraCalcMoveY', dExtraY)
|
|
EgtSetInfo( Pz, 'DoorProbeErrorY', dDeltaProbe)
|
|
EgtSetInfo( Pz, 'SideDisposition', DISPMODE)
|
|
-- scrivo nota disabilitazione cuffia
|
|
EgtSetInfo( Pz, 'ForceDisableHood', nForceDisableHood)
|
|
-- scrivo nota lavorazione lato hinge
|
|
EgtSetInfo( Pz, 'SideHingeMach', nHingeMach)
|
|
-- scrivo nota tipo profilo lato hinge
|
|
EgtSetInfo( Pz, 'SideHingeProf', nSideType)
|
|
-- scrivo nota lavorazione lato lock
|
|
EgtSetInfo( Pz, 'SideLockMach', nLockMach)
|
|
|
|
-- sommo il delta spostamento
|
|
Ori = Ori + vExtraYDelta
|
|
|
|
-- Muovo porta con l'angolo indicato dal tipo di disposizione nella posizione di origine
|
|
bMoveRaw = EgtMoveToCornerRawPart( nRaw, Ori, EgtIf( DISPMODE > 0, MCH_CR.BL, MCH_CR.BR))
|
|
|
|
-- memorizzo i flag per le fasi successive
|
|
bFlipFirst = bFlip
|
|
bTopOnRightFirst = bTopOnRight
|
|
|
|
if not bMoveRaw then
|
|
bOk = false
|
|
DGD.EMC = ' ' .. EgtDoorsMsg[529]..EgtDoorsMsg[474] -- Error positioning raw part on table
|
|
break
|
|
end
|
|
|
|
if bShiftedDoor then
|
|
-- salvo una nota con le info della disposizione traslata
|
|
EgtSetInfo( Pz, 'DoorOnTable' .. '_' .. tostring(nNumPhase) .. '_' .. MachName, sDispMode)
|
|
EgtSetInfo( Pz, 'KindPhase' .. '_' .. tostring(nNumPhase) .. '_' .. MachName, 'SHIFT')
|
|
else
|
|
-- salvo una nota con le info della disposizione normale
|
|
EgtSetInfo( Pz, 'DoorOnTable' .. '_' .. tostring(nNumPhase) .. '_' .. MachName, sDispMode)
|
|
EgtSetInfo( Pz, 'KindPhase' .. '_' .. tostring(nNumPhase) .. '_' .. MachName, 'NORMAL')
|
|
end
|
|
|
|
if bFlip then -- se porta capovolta
|
|
if bTopOnRight then -- se top a destra
|
|
-- il lato sinistro è quello delle hinges
|
|
OffsYSovr = dLeftOffs
|
|
OffsXSovr = EgtIf( DISPMODE > 0, dBottomOffs, dTopOffs)
|
|
else -- se top a sinistra
|
|
-- il lato destro è quello delle hinges
|
|
OffsYSovr = dRightOffs
|
|
OffsXSovr = EgtIf( DISPMODE > 0, dTopOffs, dBottomOffs)
|
|
end
|
|
else -- altrimenti non è capovolta
|
|
if bTopOnRight then -- se top a destra
|
|
-- il lato destro è quello delle hinges
|
|
OffsYSovr = dRightOffs
|
|
OffsXSovr = EgtIf( DISPMODE > 0, dBottomOffs, dTopOffs)
|
|
else -- se top a sinistra
|
|
-- il lato sinistro è quello delle hinges
|
|
OffsYSovr = dLeftOffs
|
|
OffsXSovr = EgtIf( DISPMODE > 0, dTopOffs, dBottomOffs)
|
|
end
|
|
end
|
|
|
|
-- Controllo dimensioni pezzo
|
|
-- controllo se le dimensioni porta sono compresi nei valori minimi e massimi
|
|
bFailDim = CheckPieceDimension( dLengthDoor, dWidthDoor, dThickDoor, OffsXSovr, OffsYSovr,
|
|
vShift:getX(), vShift:getY(), dMinDoorLength, dMaxDoorLength, dMinDoorWidth,
|
|
dMaxDoorWidth, dMinDoorThick, dMaxDoorThick)
|
|
|
|
if bFailDim then
|
|
|
|
DGD.ERR = 19
|
|
-- cancello e ricreo il file txt
|
|
EgtEraseFile( sFileDir..sFileName..'.txt')
|
|
--ricreo il file txt con la disposizione
|
|
WriteErrFile( sFileDir..sFileName..'.txt')
|
|
|
|
-- se lanciato da DMach stampo anche un messaggio a video
|
|
if not DGD or not DGD.NCGEN then
|
|
DoorOutLog( ' Err=' .. tostring( DGD.ERR), 0)
|
|
DoorOutLog( DGD.EMC, 0)
|
|
EgtOutBox( ' Err=' .. tostring( DGD.ERR) .. DGD.EMC, EgtDoorsMsg[476], EgtDoorsMsg[477]) -- Error on Nc part program generation
|
|
end
|
|
return false
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
-- abilito/disabilito geometrie probe in base alla lavorazione del lato hinge e alla disposizione sulla tavola
|
|
-------------------------------------------------------------------------------------------------------------
|
|
if bHingeMach then -- se profilo hinge è da lavorare rinomino nome entita
|
|
|
|
-- Recupero le entità probe
|
|
local ProbeList = MB.FindEntitiesWithName( Pz, 'Hinge_Probe')
|
|
-- ciclo su tutte le entità trovate
|
|
for j = 1, #ProbeList do
|
|
EgtSetName( ProbeList[j], 'NO_Hinge_Probe' )
|
|
end
|
|
|
|
ProbeList = MB.FindEntitiesWithName( Pz, 'Hinge_Probe_POS')
|
|
-- ciclo su tutte le entità trovate
|
|
for j = 1, #ProbeList do
|
|
EgtSetName( ProbeList[j], 'NO_Hinge_Probe' )
|
|
end
|
|
|
|
ProbeList = MB.FindEntitiesWithName( Pz, 'Hinge_Probe_NEG')
|
|
-- ciclo su tutte le entità trovate
|
|
for j = 1, #ProbeList do
|
|
EgtSetName( ProbeList[j], 'NO_Hinge_Probe' )
|
|
end
|
|
|
|
-- Recupero le entità pivot
|
|
ProbeList = MB.FindEntitiesWithName( Pz, 'Pivot_Probe')
|
|
-- ciclo su tutte le entità trovate
|
|
for j = 1, #ProbeList do
|
|
EgtSetName( ProbeList[j], 'NO_Pivot_Probe' )
|
|
end
|
|
|
|
ProbeList = MB.FindEntitiesWithName( Pz, 'Pivot_Probe_POS')
|
|
-- ciclo su tutte le entità trovate
|
|
for j = 1, #ProbeList do
|
|
EgtSetName( ProbeList[j], 'NO_Pivot_Probe' )
|
|
end
|
|
|
|
ProbeList = MB.FindEntitiesWithName( Pz, 'Pivot_Probe_NEG')
|
|
-- ciclo su tutte le entità trovate
|
|
for j = 1, #ProbeList do
|
|
EgtSetName( ProbeList[j], 'NO_Pivot_Probe' )
|
|
end
|
|
else -- profilo hinge non lavorato
|
|
|
|
-- il probe deve essere sempre quello a sinistra rispetto al piazzamento
|
|
-- considerando lo swing perché le cerniere a seconda di questo vengono tuotate e il probe _POS e _NED risultano
|
|
-- scambiati rispetto al top della porta
|
|
local sProbeHingeToFind = ''
|
|
local sProbeHingeDis = ''
|
|
local sProbePivotToFind = ''
|
|
local sProbePivotDis = ''
|
|
|
|
if DISPMODE > 0 then -- se disposizione a sinistra
|
|
if ( bPush and bAtRight) or ( not bPush and not bAtRight) then
|
|
if not bTopOnRight then -- se top a sinistra
|
|
sProbeHingeToFind = 'Hinge_Probe_NEG'
|
|
sProbeHingeDis = 'NO_Hinge_Probe_NEG'
|
|
else -- top a destra
|
|
sProbeHingeToFind = 'Hinge_Probe_POS'
|
|
sProbeHingeDis = 'NO_Hinge_Probe_POS'
|
|
end
|
|
else
|
|
if not bTopOnRight then -- se top a sinistra
|
|
sProbeHingeToFind = 'Hinge_Probe_POS'
|
|
sProbeHingeDis = 'NO_Hinge_Probe_POS'
|
|
else -- top a destra
|
|
sProbeHingeToFind = 'Hinge_Probe_NEG'
|
|
sProbeHingeDis = 'NO_Hinge_Probe_NEG'
|
|
end
|
|
end
|
|
if not bTopOnRight then -- se top a sinistra
|
|
sProbePivotToFind = 'Pivot_Probe_NEG'
|
|
sProbePivotDis = 'NO_Pivot_Probe_NEG'
|
|
else -- se top è a destra
|
|
sProbePivotToFind = 'Pivot_Probe_POS'
|
|
sProbePivotDis = 'NO_Pivot_Probe_POS'
|
|
end
|
|
else -- disposizione a destra
|
|
if ( bPush and bAtRight) or ( not bPush and not bAtRight) then
|
|
if bTopOnRight then -- se top a destra
|
|
sProbeHingeToFind = 'Hinge_Probe_POS'
|
|
sProbeHingeDis = 'NO_Hinge_Probe_POS'
|
|
else -- top a sinistra
|
|
sProbeHingeToFind = 'Hinge_Probe_NEG'
|
|
sProbeHingeDis = 'NO_Hinge_Probe_NEG'
|
|
end
|
|
else
|
|
if bTopOnRight then -- se top a destra
|
|
sProbeHingeToFind = 'Hinge_Probe_NEG'
|
|
sProbeHingeDis = 'NO_Hinge_Probe_NEG'
|
|
else -- top a sinistra
|
|
sProbeHingeToFind = 'Hinge_Probe_POS'
|
|
sProbeHingeDis = 'NO_Hinge_Probe_POS'
|
|
end
|
|
end
|
|
if bTopOnRight then -- se top a destra
|
|
sProbePivotToFind = 'Pivot_Probe_POS'
|
|
sProbePivotDis = 'NO_Pivot_Probe_POS'
|
|
else -- se top a sinistra
|
|
sProbePivotToFind = 'Pivot_Probe_NEG'
|
|
sProbePivotDis = 'NO_Pivot_Probe_NEG'
|
|
end
|
|
end
|
|
local ProbeList = MB.FindEntitiesWithName( Pz, sProbeHingeToFind)
|
|
for j = 1, #ProbeList do
|
|
EgtSetName( ProbeList[j], sProbeHingeDis)
|
|
end
|
|
ProbeList = MB.FindEntitiesWithName( Pz, sProbePivotToFind)
|
|
for j = 1, #ProbeList do
|
|
EgtSetName( ProbeList[j], sProbePivotDis)
|
|
end
|
|
end
|
|
|
|
-- *** Lavorazioni ***
|
|
-- setto variabili in funzione della disposizione porta
|
|
local bMakeGhost = true
|
|
nDirReorderGroups = DISPMODE
|
|
local dPercentDoorLength
|
|
---------------------------------------------------------------------------------------------------------------------------
|
|
-- 06/05/2021 in base al seguente avvenimento: porta lunga 3025 con 4 cerniere, 2 per ogni shuttle, e con una groove che
|
|
-- sborda sul lato cerniere. Alla chiamata della DANGER_L (nel Processo4) lo shuttle 1 a sinistra chiede di parcheggiare
|
|
-- nella posizione calcolata (L88) nel P5INIT che è a pacco con lo shuttle 2 nella parte destra della porta. L'arbitro non
|
|
-- da il consenso al parcheggio perchè la posizione è ancora occupata dallo shuttle 2 che sta lavorando e quindi manda
|
|
-- in parcheggio lo shuttle 1 fuori (tutto a sinistra) ma che, data la lunghezza elevata della porta, quando il gruppo 4
|
|
-- andando a lavorare la groove vicino al lato hinge, rischia di collidere con lo shuttle 1.
|
|
-- Quindi per ovviare al problema è stato stabilito, in accordo con Carlo Viviani, di controllare per prima
|
|
-- la dimensione della porta, e se la lunghezza porta è maggiore del valore stabilito nella macro P5INIT nella variabile
|
|
-- L116 (ad oggi al valore 2700mm) allora la percentuale di distribuzione cerniere passa a 52% da sinistra in ogni caso
|
|
---------------------------------------------------------------------------------------------------------------------------
|
|
if dLengthDoor >= Big_Dorr_Height then
|
|
dPercentDoorLength = EgtIf( DISPMODE > 0, 0.52, 0.48)
|
|
else
|
|
-------------------------------------------------------------------------------------------
|
|
-- in base alla richiesta di Mark Offman 18/10/2018
|
|
-------------------------------------------------------------------------------------------
|
|
-- assegno una percentuale di 0.5 allo shuttle di sinistra (Mark 18/10/2018)
|
|
-- ma con 3 cerniere o 3 pivot, cambio la percentuale, cioè 0.4 da sinistra
|
|
dPercentDoorLength = EgtIf( DISPMODE > 0, EgtIf( dNumHingesPivots == 3 ,0.5, 0.6), EgtIf( dNumHingesPivots == 3, 0.6,0.5))
|
|
-------------------------------------------------------------------------------------------
|
|
|
|
-------------------------------------------------------------------------------------------
|
|
-- Vecchia disposizione di Viviani
|
|
-------------------------------------------------------------------------------------------
|
|
-- assegno una percentuale di 0.6 sempre verso lo shuttle di sinistra (Viviani 30/01/2017)
|
|
-- se disposta a sinistra assegno 0.6 da sinistra, se disposta a destra assegno 0.4 da destra, il risultato è quindi
|
|
-- sempre 0.6 da sinistra
|
|
-- ma con 3 cerniere o 3 pivot, inverto la percentuale, cioè sempre 0.4 da sinistra
|
|
-- dPercentDoorLength = EgtIf( DISPMODE > 0, EgtIf( dNumHingesPivots == 3 ,0.4, 0.6), EgtIf( dNumHingesPivots == 3, 0.6,0.4))
|
|
-------------------------------------------------------------------------------------------
|
|
end
|
|
|
|
-- Se uso shuttle forzato su uno dei due shuttle cambio la percentuale
|
|
if nForceUseShuttle then
|
|
if nForceUseShuttle == 1 then
|
|
dPercentDoorLength = 0
|
|
elseif nForceUseShuttle == 2 then
|
|
dPercentDoorLength = 1
|
|
else
|
|
nForceUseShuttle = 0
|
|
end
|
|
else
|
|
nForceUseShuttle = 0
|
|
end
|
|
|
|
-- scrivo la nota
|
|
EgtSetInfo( Pz, 'ForceShuttle', nForceUseShuttle)
|
|
|
|
-- quanto segue nella sottostante spiegazione è stato cambiato
|
|
---- determino la posizione del cambio shuttle utilizzando un coefficiente di 0.4 verso destra se il posizionamento è a destra
|
|
---- e un coefficiente di 0.6 verso destra se il posizionamento è a sinistra, in modo
|
|
---- da favorire lo shuttle che è dalla parte del riferimento ( a destra con assegnazione nMach a 2 e a sinistra con assegnazione nMach a 3)
|
|
dPosShuttleChange = EgtIf( DISPMODE > 0, Ori1:getX(), Ori2:getX()) + ( dLengthDoor * dPercentDoorLength * nDirReorderGroups) + ( OffsXSovr * nDirReorderGroups) + tabOri:getX()
|
|
|
|
-- ricavo minimo e massimo del solido del pezzo
|
|
b3SolidOnTab = EgtGetBBoxGlob( Ls, GDB_BB.EXACT)
|
|
pMin = b3SolidOnTab:getMin()
|
|
pMax = b3SolidOnTab:getMax()
|
|
local tOrderGrp = {}
|
|
|
|
-- print Machining table
|
|
-- solo il primo giro: aggiusto i profili bevel per essere coerente con la sequenza di tabella
|
|
-- riordino i gruppi geometrici che hanno l'operazione AdjustHead o AdjustHeadOnASplint in ordine di X decrescente
|
|
for i = 1, #tLocMach do
|
|
|
|
-- print Machining table
|
|
DoorOutLog( 'L'..tostring( i) .. ' EN='.. (tLocMach[i].On or ' ') ..' N='.. tLocMach[i].Name .. ' O='.. (tLocMach[i].Oper or ' ') ..
|
|
' M='.. (tLocMach[i].Mach or ' ') .. ' MAC='.. (tLocMach[i].MachName or ' '), -1)
|
|
|
|
if tLocMach[i].On ~= 0 then
|
|
sLocMachId = tLocMach[i].MachId
|
|
if not sLocMachId then sLocMachId = 1 end
|
|
|
|
if sLocMachId == nNumMachFromTable then
|
|
-- Recupero le entità
|
|
local EntList = MB.FindEntitiesWithName( Pz, tLocMach[i].Name)
|
|
-- Applico le lavorazioni
|
|
for j = 1, #EntList do
|
|
-- OPERAZIONI
|
|
if tLocMach[i].Oper then
|
|
if tLocMach[i].Oper == 'AdjustBevel' then
|
|
local sNewName
|
|
_, sNewName = MB.AdjustBevel( EntList[j], tLocMach[i].Name, bFirstStep, bNoVertProf)
|
|
elseif tLocMach[i].Oper == 'AdjustHead' or tLocMach[i].Oper == 'AdjustHeadOnASplint' then
|
|
-- nDirReorderGroups = -1 = ordine decrescente ( da dx a sx <--); nDirReorderGroups = 1 ordine crescente ( da sx a dx -->)
|
|
MB.ReorderGroup( EntList[j], tOrderGrp, nDirReorderGroups)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- conteggio lavorazioni saltate
|
|
nNumMachSkipResult = 0
|
|
-- variabile per conteggio lavorazioni
|
|
nNumMach = 0
|
|
nNumSkip = 0
|
|
-- se porta ribatata inverto anche le variabili contatori lavorazioni sopra e sotto
|
|
if bFlip then
|
|
local nValAppo = nNumGeomBottom
|
|
nNumGeomBottom = nNumGeomTop
|
|
nNumGeomTop = nValAppo
|
|
nValAppo = nNumGeomBottomHole
|
|
nNumGeomBottomHole = nNumGeomTopHole
|
|
nNumGeomTopHole = nValAppo
|
|
end
|
|
|
|
-- Machining adding, only for selected machine
|
|
-- faccio tutto in un unico giro per non dover avere due contatori di break, uno per le operazioni e uno per le lavorazioni
|
|
for i = 1, #tLocMach do
|
|
|
|
if tLocMach[i].On ~= 0 then
|
|
|
|
sLocMachId = tLocMach[i].MachId
|
|
if not sLocMachId then sLocMachId = 1 end
|
|
|
|
if sLocMachId == nNumMachFromTable then
|
|
-- Recupero le entità
|
|
local EntList = MB.FindEntitiesWithName( Pz, tLocMach[i].Name)
|
|
-- Applico le lavorazioni
|
|
for j = 1, #EntList do
|
|
|
|
local bAdjustHead = false
|
|
local nNewIdEnt
|
|
|
|
-- OPERAZIONI
|
|
if tLocMach[i].Oper then
|
|
|
|
if tLocMach[i].Oper == 'AdjustBevel' then
|
|
|
|
local sNewName
|
|
bLocMach, sNewName, nNewIdEnt = MB.AdjustBevel( EntList[j], tLocMach[i].Name, bFirstStep, bNoVertProf, bMakeGhost)
|
|
|
|
if bLocMach then
|
|
|
|
local bInsLav = false
|
|
-- faccio il test per vedere se la lavorazione è applicabile
|
|
local nMach = EgtGetInfo( nNewIdEnt, 'Mach', 'i') or 1
|
|
|
|
if nMach == 1 then
|
|
bInsLav = MB.TestMachining( tLocMach[i].Mach, nNewIdEnt)
|
|
elseif nMach == 2 then
|
|
bInsLav = MB.TestMachining( tLocMach[i].MachUp, nNewIdEnt)
|
|
elseif nMach == 3 then
|
|
bInsLav = MB.TestMachining( tLocMach[i].MachDw, nNewIdEnt)
|
|
end
|
|
|
|
-- se la lavorazione è applicabile
|
|
if bInsLav then
|
|
-- ottengo il nome del lato lavorato
|
|
local sEdge = EgtGetName( EgtGetParent( EntList[j]))
|
|
if sEdge then
|
|
if #sMachProf > 0 then
|
|
sMachProf = sMachProf .. ',' .. sEdge
|
|
else
|
|
sMachProf = sEdge
|
|
end
|
|
|
|
-- in base a quale lato è verifico se il sovramateriale supera il valore massimo e genero sgrossatura
|
|
if string.lower( sEdge) == 'left' then
|
|
local dOffsLoc = 0
|
|
if bAtRight then
|
|
if sHingeTrim == 'BD' or sHingeTrim == 'BU' or sHingeTrim == 'BDEB' or sHingeTrim == 'BUEB' then
|
|
dOffsLoc = dThickDoor * TAN3
|
|
elseif sHingeTrim == 'CV' then
|
|
-- calcolo minimo ingombro profilo
|
|
local dAltProf = dThickDoor/2 - tsPlaneProf[1]
|
|
local dMaxInsPrf = sqrt((tsRadiusProf[1]*tsRadiusProf[1])-(dAltProf*dAltProf))
|
|
dOffsLoc = tsRadiusProf[1] - dMaxInsPrf
|
|
-- assegno al nuovo percorso il delta tra il fondo profilo e il bordo porta
|
|
EgtSetInfo( nNewIdEnt, 'OFFSTOPATH', dOffsLoc)
|
|
end
|
|
elseif not bAtRight then
|
|
if sLockTrim == 'BD' or sLockTrim == 'BD_LK' or sLockTrim == 'BU' or sLockTrim == 'BU_LK' or
|
|
sLockTrim == 'BDEB' or sLockTrim == 'BDEB_LK' or sLockTrim == 'BUEB' or sLockTrim == 'BUEB_LK' then
|
|
dOffsLoc = dThickDoor * TAN3
|
|
elseif sLockTrim == 'CV' or sLockTrim == 'CV_LK' then
|
|
-- calcolo minimo ingombro profilo
|
|
local dAltProf = dThickDoor/2 - tsPlaneProf[2]
|
|
local dMaxInsPrf = sqrt((tsRadiusProf[2]*tsRadiusProf[2])-(dAltProf*dAltProf))
|
|
dOffsLoc = tsRadiusProf[2] - dMaxInsPrf
|
|
-- assegno al nuovo percorso il delta tra il fondo profilo e il bordo porta
|
|
EgtSetInfo( nNewIdEnt, 'OFFSTOPATH', dOffsLoc)
|
|
end
|
|
end
|
|
MB.MakeRoughPaths( dLeftOffs, dMaxOverMat, dStepOverMat, nNewIdEnt, false, bFlip, nil, dOffsLoc)
|
|
elseif string.lower( sEdge) == 'right' then
|
|
local dOffsLoc = 0
|
|
if bAtRight then
|
|
if sLockTrim == 'BD' or sLockTrim == 'BD_LK' or sLockTrim == 'BU' or sLockTrim == 'BU_LK' or
|
|
sLockTrim == 'BDEB' or sLockTrim == 'BDEB_LK' or sLockTrim == 'BUEB' or sLockTrim == 'BUEB_LK' then
|
|
dOffsLoc = dThickDoor * TAN3
|
|
elseif sLockTrim == 'CV' or sLockTrim == 'CV_LK' then
|
|
-- calcolo minimo ingombro profilo
|
|
local dAltProf = dThickDoor/2 - tsPlaneProf[2]
|
|
local dMaxInsPrf = sqrt((tsRadiusProf[2]*tsRadiusProf[2])-(dAltProf*dAltProf))
|
|
dOffsLoc = tsRadiusProf[2] - dMaxInsPrf
|
|
-- assegno al nuovo percorso il delta tra il fondo profilo e il bordo porta
|
|
EgtSetInfo( nNewIdEnt, 'OFFSTOPATH', dOffsLoc)
|
|
end
|
|
elseif not bAtRight then
|
|
if sHingeTrim == 'BD' or sHingeTrim == 'BU' or sHingeTrim == 'BDEB' or sHingeTrim == 'BUEB' then
|
|
dOffsLoc = dThickDoor * TAN3
|
|
elseif sHingeTrim == 'CV' then
|
|
-- calcolo minimo ingombro profilo
|
|
local dAltProf = dThickDoor/2 - tsPlaneProf[1]
|
|
local dMaxInsPrf = sqrt((tsRadiusProf[1]*tsRadiusProf[1])-(dAltProf*dAltProf))
|
|
dOffsLoc = tsRadiusProf[1] - dMaxInsPrf
|
|
-- assegno al nuovo percorso il delta tra il fondo profilo e il bordo porta
|
|
EgtSetInfo( nNewIdEnt, 'OFFSTOPATH', dOffsLoc)
|
|
end
|
|
end
|
|
MB.MakeRoughPaths( dRightOffs, dMaxOverMat, dStepOverMat, nNewIdEnt, false, bFlip, nil, dOffsLoc)
|
|
elseif string.lower( sEdge) == 'top' then
|
|
local dOffsLoc = 0
|
|
if sTopTrim == 'BD' or sTopTrim == 'BU' or sTopTrim == 'BDEB' or sTopTrim == 'BUEB' then
|
|
dOffsLoc = dThickDoor * TAN3
|
|
elseif sTopTrim == 'CV' then
|
|
-- calcolo minimo ingombro profilo
|
|
local dAltProf = dThickDoor/2 - tsPlaneProf[3]
|
|
local dMaxInsPrf = sqrt((tsRadiusProf[3]*tsRadiusProf[3])-(dAltProf*dAltProf))
|
|
dOffsLoc = tsRadiusProf[3] - dMaxInsPrf
|
|
-- assegno al nuovo percorso il delta tra il fondo profilo e il bordo porta
|
|
EgtSetInfo( nNewIdEnt, 'OFFSTOPATH', dOffsLoc)
|
|
end
|
|
MB.MakeRoughPaths( dTopOffs, dMaxOverMat, dStepOverMat, nNewIdEnt, true, bFlip, nil, dOffsLoc)
|
|
elseif string.lower( sEdge) == 'bottom' then
|
|
local dOffsLoc = 0
|
|
if sBottomTrim == 'BD' or sBottomTrim == 'BU' or sBottomTrim == 'BDEB' or sBottomTrim == 'BUEB' then
|
|
dOffsLoc = dThickDoor * TAN3
|
|
end
|
|
MB.MakeRoughPaths( dBottomOffs, dMaxOverMat, dStepOverMat, nNewIdEnt, true, bFlip, nil, dOffsLoc)
|
|
end
|
|
end
|
|
end
|
|
else
|
|
bOk = false
|
|
end
|
|
elseif tLocMach[i].Oper == 'AdjustVertCurve' then
|
|
bOk, nNewIdEnt = MB.AdjustVertCurve( EntList[j], bMakeGhost)
|
|
elseif tLocMach[i].Oper == 'AdjustRoughCurve' then
|
|
bOk, nNewIdEnt = MB.AdjustThrouCurve( EntList[j], bMakeGhost, true)
|
|
elseif tLocMach[i].Oper == 'AdjustThrouCurve' then
|
|
bLocMach, nNewIdEnt = MB.AdjustThrouCurve( EntList[j], bMakeGhost)
|
|
if bLocMach then
|
|
|
|
local bInsLav = false
|
|
-- faccio un test per vedere che la lavorazione è applicabile
|
|
local nMach = EgtGetInfo( nNewIdEnt, 'Mach', 'i') or 1
|
|
|
|
if nMach == 1 then
|
|
bInsLav = MB.TestMachining( tLocMach[i].Mach, nNewIdEnt)
|
|
elseif nMach == 2 then
|
|
bInsLav = MB.TestMachining( tLocMach[i].MachUp, nNewIdEnt)
|
|
elseif nMach == 3 then
|
|
bInsLav = MB.TestMachining( tLocMach[i].MachDw, nNewIdEnt)
|
|
end
|
|
|
|
if bInsLav then
|
|
-- ottengo il nome del lato lavorato
|
|
local sEdge = EgtGetName( EgtGetParent( EntList[j]))
|
|
if sEdge then
|
|
if #sMachProf > 0 then
|
|
sMachProf = sMachProf .. ',' .. sEdge
|
|
else
|
|
sMachProf = sEdge
|
|
end
|
|
end
|
|
|
|
-- in base a quale lato è verifico se il sovramateriale supera il valore massimo e genero sgrossatura
|
|
if string.lower( sEdge) == 'left' then
|
|
local dOffsLoc = 0
|
|
if bAtRight then
|
|
if sHingeTrim == 'BD' or sHingeTrim == 'BU' or sHingeTrim == 'BDEB' or sHingeTrim == 'BUEB' then
|
|
dOffsLoc = dThickDoor * TAN3
|
|
elseif sHingeTrim == 'CV' then
|
|
-- calcolo minimo ingombro profilo
|
|
local dAltProf = dThickDoor/2 - tsPlaneProf[1]
|
|
local dMaxInsPrf = sqrt((tsRadiusProf[1]*tsRadiusProf[1])-(dAltProf*dAltProf))
|
|
dOffsLoc = tsRadiusProf[1] - dMaxInsPrf
|
|
-- assegno al nuovo percorso il delta tra il fondo profilo e il bordo porta
|
|
EgtSetInfo( nNewIdEnt, 'OFFSTOPATH', dOffsLoc)
|
|
end
|
|
elseif not bAtRight then
|
|
if sLockTrim == 'BD' or sLockTrim == 'BD_LK' or sLockTrim == 'BU' or sLockTrim == 'BU_LK' or
|
|
sLockTrim == 'BDEB' or sLockTrim == 'BDEB_LK' or sLockTrim == 'BUEB' or sLockTrim == 'BUEB_LK' then
|
|
dOffsLoc = dThickDoor * TAN3
|
|
elseif sLockTrim == 'CV' or sLockTrim == 'CV_LK' then
|
|
-- calcolo minimo ingombro profilo
|
|
local dAltProf = dThickDoor/2 - tsPlaneProf[2]
|
|
local dMaxInsPrf = sqrt((tsRadiusProf[2]*tsRadiusProf[2])-(dAltProf*dAltProf))
|
|
dOffsLoc = tsRadiusProf[2] - dMaxInsPrf
|
|
-- assegno al nuovo percorso il delta tra il fondo profilo e il bordo porta
|
|
EgtSetInfo( nNewIdEnt, 'OFFSTOPATH', dOffsLoc)
|
|
end
|
|
end
|
|
MB.MakeRoughPaths( dLeftOffs, dMaxOverMat, dStepOverMat, nNewIdEnt, false, bFlip, nil, dOffsLoc)
|
|
elseif string.lower( sEdge) == 'right' then
|
|
local dOffsLoc = 0
|
|
if bAtRight then
|
|
if sLockTrim == 'BD' or sLockTrim == 'BD_LK' or sLockTrim == 'BU' or sLockTrim == 'BU_LK' or
|
|
sLockTrim == 'BDEB' or sLockTrim == 'BDEB_LK' or sLockTrim == 'BUEB' or sLockTrim == 'BUEB_LK' then
|
|
dOffsLoc = dThickDoor * TAN3
|
|
elseif sLockTrim == 'CV' or sLockTrim == 'CV_LK' then
|
|
-- calcolo minimo ingombro profilo
|
|
local dAltProf = dThickDoor/2 - tsPlaneProf[2]
|
|
local dMaxInsPrf = sqrt((tsRadiusProf[2]*tsRadiusProf[2])-(dAltProf*dAltProf))
|
|
dOffsLoc = tsRadiusProf[2] - dMaxInsPrf
|
|
-- assegno al nuovo percorso il delta tra il fondo profilo e il bordo porta
|
|
EgtSetInfo( nNewIdEnt, 'OFFSTOPATH', dOffsLoc)
|
|
end
|
|
elseif not bAtRight then
|
|
if sHingeTrim == 'BD' or sHingeTrim == 'BU' or sHingeTrim == 'BDEB' or sHingeTrim == 'BUEB' then
|
|
dOffsLoc = dThickDoor * TAN3
|
|
elseif sHingeTrim == 'CV' then
|
|
-- calcolo minimo ingombro profilo
|
|
local dAltProf = dThickDoor/2 - tsPlaneProf[1]
|
|
local dMaxInsPrf = sqrt((tsRadiusProf[1]*tsRadiusProf[1])-(dAltProf*dAltProf))
|
|
dOffsLoc = tsRadiusProf[1] - dMaxInsPrf
|
|
-- assegno al nuovo percorso il delta tra il fondo profilo e il bordo porta
|
|
EgtSetInfo( nNewIdEnt, 'OFFSTOPATH', dOffsLoc)
|
|
end
|
|
end
|
|
MB.MakeRoughPaths( dRightOffs, dMaxOverMat, dStepOverMat, nNewIdEnt, false, bFlip, nil, dOffsLoc)
|
|
elseif string.lower( sEdge) == 'top' then
|
|
local dOffsLoc = 0
|
|
if sTopTrim == 'BD' or sTopTrim == 'BU' or sTopTrim == 'BDEB' or sTopTrim == 'BUEB' then
|
|
dOffsLoc = dThickDoor * TAN3
|
|
elseif sTopTrim == 'CV' then
|
|
-- calcolo minimo ingombro profilo
|
|
local dAltProf = dThickDoor/2 - tsPlaneProf[3]
|
|
local dMaxInsPrf = sqrt((tsRadiusProf[3]*tsRadiusProf[3])-(dAltProf*dAltProf))
|
|
dOffsLoc = tsRadiusProf[3] - dMaxInsPrf
|
|
-- assegno al nuovo percorso il delta tra il fondo profilo e il bordo porta
|
|
EgtSetInfo( nNewIdEnt, 'OFFSTOPATH', dOffsLoc)
|
|
end
|
|
MB.MakeRoughPaths( dTopOffs, dMaxOverMat, dStepOverMat, nNewIdEnt, true, bFlip, nil, dOffsLoc)
|
|
elseif string.lower( sEdge) == 'bottom' then
|
|
local dOffsLoc = 0
|
|
if sBottomTrim == 'BD' or sBottomTrim == 'BU' or sBottomTrim == 'BDEB' or sBottomTrim == 'BUEB' then
|
|
dOffsLoc = dThickDoor * TAN3
|
|
end
|
|
MB.MakeRoughPaths( dBottomOffs, dMaxOverMat, dStepOverMat, nNewIdEnt, true, bFlip, nil, dOffsLoc)
|
|
end
|
|
end
|
|
else
|
|
bOk = false
|
|
end
|
|
elseif tLocMach[i].Oper == 'AdjustThrouIsle' then
|
|
bLocMach, nNumMachSkipResult, nNewIdEnt = MB.AdjustThrouIsle( EntList[j], b3Solid:getDimZ(), pMin, pMax, nNumMachSkip, bFirstStep, bWorkUnder, bMakeGhost, dExtraThruDepth)
|
|
if not bLocMach then -- se operazione fallita
|
|
bOk = false
|
|
end
|
|
if nNumMachSkipResult > nNumMachSkip then -- se lavorazione skippata la inserisco nella tabella
|
|
if bFirstStep then
|
|
-- inserisco in tabella solo se non già presente
|
|
tSecMachTab = AddMachIntable( tLocMach[i], tSecMachTab, i)
|
|
end
|
|
nNumMachSkip = nNumMachSkipResult
|
|
else -- se non skippata provo a verificare se la lavorazione è applicabile
|
|
|
|
local bInsLav = true
|
|
-- faccio un test per vedere che la lavorazione è applicabile
|
|
local nMach = EgtGetInfo( nNewIdEnt, 'Mach', 'i') or 1
|
|
local sResMach
|
|
|
|
if nMach == 1 then
|
|
bInsLav, sResMach = MB.TestMachining( tLocMach[i].Mach, nNewIdEnt)
|
|
elseif nMach == 2 then
|
|
bInsLav, sResMach = MB.TestMachining( tLocMach[i].MachUp, nNewIdEnt)
|
|
elseif nMach == 3 then
|
|
bInsLav, sResMach = MB.TestMachining( tLocMach[i].MachDw, nNewIdEnt)
|
|
end
|
|
|
|
if not bInsLav then
|
|
if bFirstStep then
|
|
-- inserisco in tabella solo se non già presente
|
|
tSecMachTab = AddMachIntable( tLocMach[i], tSecMachTab, i)
|
|
end
|
|
-- se nome lavorazione non nullo, incremento i contatori
|
|
if sResMach and #sResMach > 0 then
|
|
-- aumento di 1 il numero di lavorazioni skippate
|
|
nNumMachSkip = nNumMachSkip + 1
|
|
-- ricambio la nota come non lavorabile in questa fase
|
|
EgtSetInfo( nNewIdEnt, 'Mach', nMach + 10)
|
|
-- incremento il numero di lavorazioni da sotto
|
|
nNumGeomBottom = nNumGeomBottom + 1
|
|
end
|
|
else -- se è andata a buon punto vedo di sottrarle ai contatori degli skip
|
|
if nMach == 1 then
|
|
if nNumGeomTop > 0 then
|
|
nNumGeomTop = nNumGeomTop - 1
|
|
end
|
|
elseif nMach == 2 then
|
|
if nNumGeomBottom > 0 then
|
|
nNumGeomBottom = nNumGeomBottom - 1
|
|
end
|
|
end
|
|
end
|
|
end
|
|
elseif tLocMach[i].Oper == 'AdjustHorizAS' then
|
|
bLocMach, nNewIdEnt = MB.AdjustHorizAS( EntList[j], bMakeGhost)
|
|
if not bLocMach then
|
|
bOk = false
|
|
end
|
|
elseif tLocMach[i].Oper == 'AdjustHorNegativeAS' then
|
|
bLocMach, nNewIdEnt = MB.AdjustHorNegativeAS( EntList[j], bMakeGhost)
|
|
if not bLocMach then
|
|
bOk = false
|
|
end
|
|
elseif tLocMach[i].Oper == 'AdjustMortise' then
|
|
bLocMach,_, nNewIdEnt = MB.AdjustMortise( EntList[j], nNumMachSkip, NO_WORK_UNDERSQUARE, bMakeGhost)
|
|
if not bLocMach then
|
|
bOk = false
|
|
end
|
|
elseif tLocMach[i].Oper == 'AdjustHeadChisel' then
|
|
bLocMach, nNewIdEnt, nNumMachSkipResult = MB.AdjustHeadChisel( EntList[j], bMakeGhost, CHISEL_ONLY_HORIZONTAL, nNumMachSkip, NO_WORK_UPSQUARE, NO_WORK_UNDERSQUARE)
|
|
if not bLocMach then
|
|
bOk = false
|
|
end
|
|
if nNumMachSkipResult > nNumMachSkip then -- se lavorazione skippata la inserisco nella tabella
|
|
if bFirstStep then
|
|
-- inserisco in tabella solo se non già presente
|
|
tSecMachTab = AddMachIntable( tLocMach[i], tSecMachTab, i)
|
|
end
|
|
nNumMachSkip = nNumMachSkipResult
|
|
end
|
|
elseif tLocMach[i].Oper == 'AdjustVertHole' then
|
|
bLocMach, nNumMachSkipResult, nNewIdEnt = MB.AdjustVertHole( EntList[j], b3Solid:getDimZ(), pMin, pMax, nNumMachSkip, bFirstStep, bWorkUnder, bMakeGhost, dExtraThruDepth)
|
|
if not bLocMach then
|
|
bOk = false
|
|
end
|
|
if nNumMachSkipResult > nNumMachSkip then -- se lavorazione skippata la inserisco nella tabella
|
|
if bFirstStep then
|
|
-- inserisco in tabella solo se non già presente
|
|
tSecMachTab = AddMachIntable( tLocMach[i], tSecMachTab, i)
|
|
end
|
|
nNumMachSkip = nNumMachSkipResult
|
|
else -- se non skippata provo a verificare se la lavorazione è applicabile
|
|
|
|
local bInsLav = true
|
|
-- faccio un test per vedere che la lavorazione è applicabile
|
|
local nMach = EgtGetInfo( nNewIdEnt, 'Mach', 'i') or 1
|
|
local sResMach
|
|
|
|
if nMach == 1 then
|
|
bInsLav, sResMach = MB.TestMachining( tLocMach[i].Mach, nNewIdEnt)
|
|
elseif nMach == 2 then
|
|
bInsLav, sResMach = MB.TestMachining( tLocMach[i].MachUp, nNewIdEnt)
|
|
elseif nMach == 3 then
|
|
bInsLav, sResMach = MB.TestMachining( tLocMach[i].MachDw, nNewIdEnt)
|
|
end
|
|
|
|
if not bInsLav then
|
|
if bFirstStep then
|
|
-- inserisco in tabella solo se non già presente
|
|
tSecMachTab = AddMachIntable( tLocMach[i], tSecMachTab, i)
|
|
end
|
|
-- se nome lavorazione non nullo, incremento i contatori
|
|
if sResMach and #sResMach > 0 then
|
|
-- aumento di 1 il numero di lavorazioni skippate
|
|
nNumMachSkip = nNumMachSkip + 1
|
|
-- ricambio la nota come non lavorabile in questa fase
|
|
EgtSetInfo( nNewIdEnt, 'Mach', nMach + 10)
|
|
-- incremento il numero di lavorazioni da sotto
|
|
nNumGeomBottom = nNumGeomBottom + 1
|
|
end
|
|
else -- se è andato a buon fine, verifico di sottrarlo alle variabili skip
|
|
if nMach == 1 then
|
|
if nNumGeomTopHole > 0 then
|
|
nNumGeomTopHole = nNumGeomTopHole - 1
|
|
nNumGeomTop = nNumGeomTop - 1
|
|
end
|
|
elseif nMach == 2 then
|
|
if nNumGeomBottomHole > 0 then
|
|
nNumGeomBottomHole = nNumGeomBottomHole - 1
|
|
nNumGeomBottom = nNumGeomBottom - 1
|
|
end
|
|
end
|
|
end
|
|
end
|
|
elseif tLocMach[i].Oper == 'AdjustHole' then
|
|
bLocMach, nNewIdEnt = MB.AdjustHole( EntList[j], bMakeGhost)
|
|
if not bLocMach then
|
|
bOk = false
|
|
end
|
|
elseif tLocMach[i].Oper == 'AdjustHead' then
|
|
bLocMach, nNumTopGeom, nNumBottomGeom, nNewIdEnt = MB.AdjustHead( EntList[j], nNumTopGeom, nNumBottomGeom, dPosShuttleChange, nForceUseShuttle)
|
|
bAdjustHead = true
|
|
if not bLocMach then
|
|
bOk = false
|
|
end
|
|
elseif tLocMach[i].Oper == 'AdjustHeadOnASplint' then
|
|
bLocMach, nNumTopGeom, nNumBottomGeom, nNewIdEnt = MB.AdjustHeadOnASplint( EntList[j], nNumTopGeom, nNumBottomGeom, dPosShuttleChange, nil,
|
|
DISPMODE, bFlip, MAXMACH)
|
|
bAdjustHead = true
|
|
if not bLocMach then
|
|
bOk = false
|
|
end
|
|
elseif tLocMach[i].Oper == 'AdjustBladeVertCurve' then
|
|
bOk, nNewIdEnt = MB.AdjustBladeVertCurve( EntList[j], bMakeGhost)
|
|
elseif tLocMach[i].Oper == 'AdjustASplintWithBlade' then
|
|
bOk, nNewIdEnt = MB.AdjustASplintWithBlade( EntList[j], bMakeGhost, DISPMODE, bFlip)
|
|
end
|
|
else -- se nessuna operazione
|
|
nNewIdEnt = MB.MakeGhostCopy( EntList[j])
|
|
end
|
|
|
|
-- LAVORAZIONI
|
|
local nMach
|
|
if nNewIdEnt then
|
|
nMach = EgtGetInfo( nNewIdEnt, 'Mach', 'i') or 1
|
|
else
|
|
nMach = 0
|
|
end
|
|
if nMach > 30 and nMach < 40 then nMach = nMach - 30 end
|
|
|
|
if bAdjustHead and nMach > 0 and nMach < 4 then -- se navette
|
|
-- riciclo per prendere tutte le entità di un gruppo che devono essere lavorate assieme
|
|
bOk, nNumMach = FindAndCalcGroupMachining( EntList[j], nNewIdEnt, tLocMach, nNumMachFromTable, nMach,
|
|
nNumGroup, nNumMach, bOk, dBladePerpLeadIn, dPercRedFeed)
|
|
elseif nMach > 0 and nMach < 4 then -- se è fuori range non ci entro nemmeno
|
|
|
|
-- carico id entità in una tabella
|
|
local tListSameMach = {}
|
|
table.insert( tListSameMach, nNewIdEnt)
|
|
|
|
bOk, nNumMach = InsertMachiningByMachNum( tListSameMach, nMach, tLocMach[i].Name, nNumGroup, tLocMach[i].Mach,
|
|
tLocMach[i].MachUp, tLocMach[i].MachDw, bOk, nNumMach, false,
|
|
NOT_GEN_MACH, nil, dBladePerpLeadIn, dPercRedFeed)
|
|
else
|
|
if not bAdjustHead then
|
|
DoorOutLog( EgtDoorsMsg[497]..tostring( EntList[j])..' '..tLocMach[i].Name.. EgtDoorsMsg[595].. EgtIf( tLocMach[i].Mach, tLocMach[i].Mach, '') ..
|
|
EgtDoorsMsg[596]..tostring( nNumPhase), 0)
|
|
nNumSkip = nNumSkip + 1
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local i = 1
|
|
while i <= #tLocMachOrd do
|
|
|
|
-- carico tutto il gruppo in una tabella
|
|
local tGroup = {}
|
|
local nNumGrp = tLocMachOrd[i].Group
|
|
local sProperty = tLocMachOrd[i].Property
|
|
tGroup, i = MB.GetGroup( tLocMachOrd, i, nNumGrp, sProperty)
|
|
|
|
if sProperty and nNumGrp > 0 then -- se esiste proprietà del gruppo e non è 0
|
|
|
|
if sProperty == 'MinDist' then -- ottimizzare alla minima distanza
|
|
|
|
-- prendo l'ultima lavorazione inserita ( lavorazione o disposizione)
|
|
local LastMch = EgtGetLastOperation()
|
|
local EndLastMach
|
|
|
|
-- se l'ultima lavorazione non sia nulla o non sia disposizione mi faccio dare il punto finale
|
|
if EgtGetOperationType(LastMch) ~= MCH_OY.DISP and EgtGetOperationType(LastMch) ~= MCH_OY.NONE then
|
|
EgtSetCurrMachining( LastMch)
|
|
EndLastMach = EgtGetMachiningEndPoint()
|
|
end
|
|
|
|
local tMachining = {}
|
|
-- creo lavorazioni del gruppo
|
|
for k = 1, #tGroup do
|
|
|
|
-- Recupero le entità
|
|
local EntList = MB.FindEntitiesWithName( Pz, tGroup[k].Name..'_HIDE')
|
|
local bAdjustHead = false
|
|
|
|
-- Applico le lavorazioni
|
|
for j = 1, #EntList do
|
|
|
|
-- LAVORAZIONI
|
|
local nMach = EgtGetInfo( EntList[j], 'Mach', 'i') or 1
|
|
nMach = nMach - 30 -- se lavorazione corretta ottengo 1
|
|
local nMach2nd = EgtGetInfo( EntList[j], 'Mach2nd', 'i') or 0
|
|
local sMachining = EgtGetInfo( EntList[j], 'Machining')
|
|
-- con questa tabella non ci sono seconde o terze lavorazioni, solo la prima
|
|
if nMach > 0 and nMach < 4 then nMach = 1 end
|
|
|
|
-- se lavorazione esiste e corrisponde e numero lavorazione è = 1
|
|
if sMachining and nMach == 1 and nMach2nd == 0 and sMachining == tGroup[k].Mach then
|
|
|
|
-- cerco di unire più entità nella stessa lavorazione ( non da sotto e non oltre una certa distanza)
|
|
local tListSameMach = MB.FindEntitiesCompMach( EntList[j], EntList, sMachining, tGroup[k].Join, dMaxDistToChain)
|
|
|
|
-- se più di 1 entità le ordino
|
|
if #tListSameMach > 1 then
|
|
tListSameMach = MB.OrderEnt( tListSameMach, EndLastMach)
|
|
EndLastMach = EgtSP( tListSameMach[#tListSameMach], GDB_ID.ROOT )
|
|
end
|
|
|
|
bOk, nNumMach, tMachining = InsertMachiningByMachNum( tListSameMach, nMach, tGroup[k].Name, nNumGrp, tGroup[k].Mach,
|
|
tGroup[k].MachUp, tGroup[k].MachDw, bOk, nNumMach, bAdjustHead,
|
|
GEN_MACH, tMachining, dBladePerpLeadIn, dPercRedFeed)
|
|
|
|
-- se ho assegnato lavorazione a più entità, marco quelle che ho già fatto
|
|
SetInfoTable( tListSameMach, 'Mach2nd', 1)
|
|
|
|
local nNewMach = EgtGetInfo( tListSameMach[1], 'Mach', 'i') or 1
|
|
if nNewMach > 30 and nNewMach < 40 then
|
|
SetInfoTable( tListSameMach, 'Mach', nNewMach-20) -- assegno nota per non lavorarla di nuovo
|
|
elseif nNewMach > 40 and nNewMach < 50 then
|
|
SetInfoTable( tListSameMach, 'Mach', nNewMach-30) -- assegno nota per non lavorarla di nuovo
|
|
end
|
|
end
|
|
end
|
|
|
|
-- tolgo di mezzo le note secondarie
|
|
for j = 1, #EntList do
|
|
EgtRemoveInfo( EntList[j], 'Mach2nd')
|
|
end
|
|
end
|
|
|
|
-- ordino le lavorazioni
|
|
if #tMachining > 1 then
|
|
|
|
-- Tavole per fresature da ordinare
|
|
local TabMill = {}
|
|
local TabMStEnP = {}
|
|
local TabZMach = {}
|
|
|
|
for k = 1, #tMachining do
|
|
-- Se appartiene alla fase corrente e fresatura non vuota
|
|
if EgtGetOperationPhase( tMachining[k][1]) == nNumPhase then
|
|
EgtSetCurrMachining( tMachining[k][1])
|
|
local ptStart = EgtGetMachiningStartPoint()
|
|
local ptEnd = EgtGetMachiningEndPoint()
|
|
if ptStart and ptEnd then
|
|
table.insert( TabMill, tMachining[k][1])
|
|
table.insert( TabMStEnP, { ptStart, ptEnd})
|
|
MB.InsZedByTool( TabZMach, tMachining, k)
|
|
end
|
|
end
|
|
end
|
|
-- calcolo ordinamento
|
|
EgtSpInit()
|
|
for k = 1, #TabMill do
|
|
EgtSpAddPoint( TabMStEnP[k][1]:getX(), TabMStEnP[k][1]:getY(), TabZMach[k], 0, 0,
|
|
TabMStEnP[k][2]:getX(), TabMStEnP[k][2]:getY(), TabZMach[k], 0, 0)
|
|
end
|
|
if EndLastMach then
|
|
EgtSpSetOpenBound(true,SHP_OB.NEAR_PNT,EndLastMach:getX(),EndLastMach:getY(),0,90,90)
|
|
else
|
|
EgtSpSetOpenBound(true,SHP_OB.NEAR_PNT,-2000,0,0,90,90)
|
|
end
|
|
local vMillOrd = EgtSpCalculate(SHP_TY.OPEN)
|
|
EgtSpTerminate()
|
|
-- applico ordinamento calcolato
|
|
-- parto da LastMch precedente
|
|
if vMillOrd then
|
|
for k = 1, #vMillOrd do
|
|
EgtRelocateGlob(TabMill[vMillOrd[k]],LastMch,GDB_IN.AFTER)
|
|
LastMch = TabMill[vMillOrd[k]]
|
|
end
|
|
end
|
|
end
|
|
elseif sProperty == 'Shuttle' then -- lavorazione con shuttle
|
|
|
|
-- per ogni layer padre nella lista fatta con il reordergroup
|
|
for k = 1, #tOrderGrp do
|
|
|
|
-- Recupero la prima entità del layer padre
|
|
local EntList = MB.FindEntities( tOrderGrp[k][1], true)
|
|
|
|
-- LAVORAZIONI
|
|
local nMach = 1
|
|
|
|
-- riciclo per prendere tutte le entità di un gruppo che devono essere lavorate assieme
|
|
bOk, nNumMach = MakeGroupMachining( EntList, tOrderGrp[k][1], tGroup, nMach, nNumGrp,
|
|
nNumMach, bOk, '_HIDE', dMaxDistToChain, EndLastMach,
|
|
dBladePerpLeadIn, dPercRedFeed)
|
|
end
|
|
elseif sProperty == 'Layer' then -- lavorazione layer
|
|
|
|
-- ottengo tutte le entità del gruppo
|
|
local EntListGrp = MB.LoadEntitiesFromGroup( tGroup, Pz, '_HIDE')
|
|
|
|
-- Applico le lavorazioni
|
|
for j = 1, #EntListGrp do
|
|
|
|
local nParendId = EgtGetParent(EntListGrp[j])
|
|
|
|
-- Recupero la prima entità del layer padre
|
|
local EntList = MB.FindEntities( nParendId, true)
|
|
|
|
-- LAVORAZIONI
|
|
local nMach = 1
|
|
|
|
-- riciclo per prendere tutte le entità di un gruppo che devono essere lavorate assieme
|
|
bOk, nNumMach = MakeGroupMachining( EntList, nParendId, tGroup, nMach, nNumGrp,
|
|
nNumMach, bOk, '_HIDE', dMaxDistToChain, EndLastMach,
|
|
dBladePerpLeadIn, dPercRedFeed)
|
|
end
|
|
elseif sProperty == '' then -- proprietà nulla
|
|
|
|
-- creo lavorazioni del gruppo
|
|
for k = 1, #tGroup do
|
|
|
|
-- Recupero le entità
|
|
local EntList = MB.FindEntitiesWithName( Pz, tGroup[k].Name..'_HIDE')
|
|
local bAdjustHead = false
|
|
|
|
-- Applico le lavorazioni
|
|
for j = 1, #EntList do
|
|
|
|
-- LAVORAZIONI
|
|
local nMach = EgtGetInfo( EntList[j], 'Mach', 'i') or 1
|
|
nMach = nMach - 30 -- se lavorazione corretta ottengo 1
|
|
local nMach2nd = EgtGetInfo( EntList[j], 'Mach2nd', 'i') or 0
|
|
local sMachining = EgtGetInfo( EntList[j], 'Machining')
|
|
-- con questa tabella non ci sono seconde o terze lavorazioni, solo la prima
|
|
if nMach > 0 and nMach < 4 then nMach = 1 end
|
|
|
|
if sMachining and nMach == 1 and nMach2nd == 0 and sMachining == tGroup[k].Mach then
|
|
|
|
-- cerco di unire più entità nella stessa lavorazione ( non da sotto e non oltre una certa distanza)
|
|
local tListSameMach = MB.FindEntitiesCompMach( EntList[j], EntList, sMachining, tGroup[k].Join, dMaxDistToChain)
|
|
|
|
-- se più di 1 entità le ordino
|
|
if #tListSameMach > 1 then
|
|
tListSameMach = MB.OrderEnt( tListSameMach, EndLastMach)
|
|
EndLastMach = EgtSP( tListSameMach[#tListSameMach], GDB_ID.ROOT )
|
|
end
|
|
|
|
bOk, nNumMach = InsertMachiningByMachNum( tListSameMach, nMach, tGroup[k].Name, nNumGrp, tGroup[k].Mach,
|
|
tGroup[k].MachUp, tGroup[k].MachDw, bOk, nNumMach, bAdjustHead,
|
|
GEN_MACH, nil, dBladePerpLeadIn, dPercRedFeed)
|
|
|
|
-- se ho assegnato lavorazione a più entità, marco quelle che ho già fatto
|
|
SetInfoTable( tListSameMach, 'Mach2nd', 1)
|
|
|
|
local nNewMach = EgtGetInfo( tListSameMach[1], 'Mach', 'i') or 1
|
|
if nNewMach > 30 and nNewMach < 40 then
|
|
SetInfoTable( tListSameMach, 'Mach', nNewMach-20) -- assegno nota per non lavorarla di nuovo
|
|
elseif nNewMach > 40 and nNewMach < 50 then
|
|
SetInfoTable( tListSameMach, 'Mach', nNewMach-30) -- assegno nota per non lavorarla di nuovo
|
|
end
|
|
end
|
|
end
|
|
|
|
-- tolgo di mezzo le note secondarie
|
|
for j = 1, #EntList do
|
|
EgtRemoveInfo( EntList[j], 'Mach2nd')
|
|
end
|
|
end
|
|
end
|
|
elseif nNumGrp == 0 then -- se lavorazioni in gruppo 0 do errore
|
|
DGD.ERR = -15
|
|
if DGD.EMC and #DGD.EMC > 0 then
|
|
DGD.EMC = DGD.EMC .. ' ' .. string.format(EgtDoorsMsg[639], tGroup[1].Name) -- con gruppo 0 c'è solo un'istanza
|
|
else
|
|
DGD.EMC = '\n' .. ' ' .. string.format(EgtDoorsMsg[639], tGroup[1].Name) -- con gruppo 0 c'è solo un'istanza
|
|
end
|
|
if DGD.ERM and #DGD.ERM > 0 then
|
|
DGD.ERM = DGD.ERM .. ' ' .. string.format(EgtDoorsMsg[639], tGroup[1].Name) -- con gruppo 0 c'è solo un'istanza
|
|
else
|
|
DGD.ERM = ' ' .. string.format(EgtDoorsMsg[639], tGroup[1].Name) -- con gruppo 0 c'è solo un'istanza
|
|
end
|
|
end
|
|
|
|
i = i + 1
|
|
end
|
|
|
|
----------------------------------------
|
|
-- Inserimento riferimenti e ventose
|
|
----------------------------------------
|
|
|
|
-- Offset ventose da bordo pezzo in Y
|
|
dVacOffs = 52
|
|
-- Offset barra riferimenti mobile da riferimenti quando posizione 0
|
|
dMobOffs = 160 + 65
|
|
-- Lunghezza minima per alzare prima ventosa da bordo sinistro
|
|
dDistMinX = 120.61 + 40 + DIST_MIN_VAC_L -- distanza misurata tra appoggio riferimento e centro ventose + quota sicurezza ( R ventosa + sicurezza)
|
|
-- Lunghezza minima per alzare prima ventosa da bordo destro
|
|
dDistMaxX = 168.2 + 40 + DIST_MIN_VAC_R -- distanza misurata tra appoggio riferimento e centro ventose + quota sicurezza ( R ventosa + sicurezza)
|
|
-- Posizione ventose in alto
|
|
dVacOn = 110
|
|
-- Interasse ventose
|
|
dInterAx = 232
|
|
-- distanza interferenza con cave passanti
|
|
dDistInterferThru = 42 + 8 -- modificato da 8 a 12 il 21/12/2017 su richiesta di Mark
|
|
dDistInterferBlind = 42 + 45
|
|
dDistInterferUnder = 42 + 55
|
|
|
|
-- Ventose
|
|
local nTabId = EgtGetTableId( 'Tab')
|
|
local nMobId = EgtGetFirstNameInGroup( nTabId or GDB_ID.NULL, 'MOBILE')
|
|
local nFixId = EgtGetFirstNameInGroup( nTabId or GDB_ID.NULL, 'FIXED')
|
|
local nDispId = EgtGetPhaseDisposition( nNumPhase)
|
|
-- se gruppi richiesti non trovati
|
|
if not nMobId or not nFixId then
|
|
bOk = false
|
|
DGD.EMC = ' ' .. EgtDoorsMsg[529]..EgtDoorsMsg[530] -- Error on MOBILE or FIXED table bar'
|
|
break
|
|
end
|
|
-- Posizionamento barra mobile
|
|
local dOldVal = EgtGetInfo( nMobId, 'Val', 'd')
|
|
-- calcolo nuova posizione con: larghezza finita porta ( uso getDimX perché presa prima della disposizione porta) +
|
|
-- sovramateriale a contatto con il riferimento in basso - distanza ventose - offset barra
|
|
local dNewVal = b3Solid:getDimX() + OffsYSovr + vShift:getY() + vShiftVac:getY() - dVacOffs - dMobOffs
|
|
EgtMove( nMobId, Vector3d( 0, dNewVal - dOldVal, 0), GDB_RT.GLOB)
|
|
EgtSetInfo( nMobId, 'Val', dNewVal)
|
|
EgtSetInfo( nDispId, 'MOB', dNewVal)
|
|
-- Elevazione ventose con: altezza porta ( uso getDimY perché presa prima della disposizione porta) +
|
|
-- sovramateriale a contatto con il riferimento a sx - distanza ventosa
|
|
local dCalcLen = b3Solid:getDimY() + OffsXSovr - EgtIf( DISPMODE > 0, dDistMinX, dDistMaxX)
|
|
|
|
-- predispongo regioni per verifica interferenza con lavorazioni passanti o da sotto
|
|
StartVacVerify( Ls, bFlip)
|
|
|
|
-- ciclo sulle ventose
|
|
local nInd = 1
|
|
local nIndVac
|
|
local nNumTotVacRow = 13
|
|
local nCountFailed = 0
|
|
local nIniFailed = 0
|
|
local nMiddleFailed = 0
|
|
local nEndFailed = 0
|
|
local nMaxIniFailed = 0
|
|
local nMaxMiddleFailed = 0
|
|
local nMaxEndFailed = 0
|
|
|
|
while dCalcLen > 0 and nInd <= nNumTotVacRow do
|
|
|
|
nIndVac = EgtIf( DISPMODE > 0, nInd, ( nNumTotVacRow - nInd + 1))
|
|
|
|
local sInd = tostring( nIndVac)
|
|
|
|
-- eseguo verifica
|
|
local nCenFixId = EgtGetFirstNameInGroup( nFixId, 'CEN'..sInd)
|
|
local bCanUpFix = ExecVacVerify( EgtSP( nCenFixId, GDB_ID.ROOT), Pz, dDistInterferThru, dDistInterferBlind, dDistInterferUnder)
|
|
local nCenMobId = EgtGetFirstNameInGroup( nMobId, 'CEN'..sInd)
|
|
local bCanUpMob = ExecVacVerify( EgtSP( nCenMobId, GDB_ID.ROOT), Pz, dDistInterferThru, dDistInterferBlind, dDistInterferUnder)
|
|
-- eventuale movimento
|
|
if bCanUpFix and bCanUpMob then
|
|
-- alzo le due ventose
|
|
MoveVac( nFixId, 'VAC'..sInd, dVacOn)
|
|
MoveVac( nFixId, 'ROD'..sInd, dVacOn)
|
|
MoveVac( nMobId, 'VAC'..sInd, dVacOn)
|
|
MoveVac( nMobId, 'ROD'..sInd, dVacOn)
|
|
-- salvo lo stato
|
|
EgtSetInfo( nDispId, 'VAC'..sInd, dVacOn)
|
|
-- interrompo le serie negative
|
|
if nInd > 1 then
|
|
nCountFailed = 0
|
|
if nMaxIniFailed < nIniFailed then
|
|
nMaxIniFailed = nIniFailed
|
|
end
|
|
if nMaxMiddleFailed < nMiddleFailed then
|
|
nMaxMiddleFailed = nMiddleFailed
|
|
end
|
|
if nMaxEndFailed < nEndFailed then
|
|
nMaxEndFailed = nEndFailed
|
|
end
|
|
nIniFailed = 0
|
|
nMiddleFailed = 0
|
|
nEndFailed = 0
|
|
end
|
|
else
|
|
EgtRemoveInfo( nDispId, 'VAC'..sInd)
|
|
nCountFailed = nCountFailed + 1
|
|
if nInd == 1 then -- setto solo il fallimento iniziale
|
|
nIniFailed = nCountFailed
|
|
elseif nInd == nNumTotVacRow or ( dCalcLen - dInterAx) <= 0 then -- setto solo quello finale e annullo il medio
|
|
nEndFailed = nCountFailed
|
|
if nMaxEndFailed < nEndFailed then
|
|
nMaxEndFailed = nEndFailed
|
|
end
|
|
nMiddleFailed = 0
|
|
else -- se fallisce riga intermedia aggiorno solo i contatori già iniziati
|
|
if nIniFailed > 0 then
|
|
nIniFailed = nCountFailed
|
|
elseif nEndFailed > 0 then
|
|
nEndFailed = nCountFailed - 1
|
|
else
|
|
nMiddleFailed = nCountFailed
|
|
end
|
|
end
|
|
end
|
|
-- aggiorno la lunghezza di calcolo e l'indice
|
|
dCalcLen = dCalcLen - dInterAx
|
|
nInd = nInd + 1
|
|
end
|
|
-- elimino geometrie per verifica
|
|
EndVacVerify()
|
|
|
|
-- riassegno la quantità di file che effettivamente potrebbero essere alzate
|
|
nInd = nInd - 1
|
|
|
|
-- casi di scarse ventose
|
|
if nInd > 0 and ( nMaxIniFailed == nInd or nMaxMiddleFailed == nInd or nMaxEndFailed == nInd) then -- tutte le ventose basse
|
|
DGD.EMC = ' ' .. EgtDoorsMsg[531]
|
|
bOk = false
|
|
break
|
|
elseif nInd > 0 and nMaxIniFailed / nInd > 0.25 then -- ventose iniziali ( parte destra)
|
|
local nNumMsg = EgtIf( DISPMODE > 0, 532, 534)
|
|
DGD.EMC = ' ' .. EgtDoorsMsg[nNumMsg]
|
|
bOk = false
|
|
break
|
|
elseif nInd > 0 and nMaxMiddleFailed / nInd > 0.45 then -- ventose intermedie
|
|
DGD.EMC = ' ' .. EgtDoorsMsg[533]
|
|
bOk = false
|
|
break
|
|
elseif nInd > 0 and nMaxEndFailed / nInd > 0.25 then -- ventose finale ( parte sinistra)
|
|
local nNumMsg = EgtIf( DISPMODE > 0, 534, 532)
|
|
DGD.EMC = ' ' .. EgtDoorsMsg[nNumMsg]
|
|
bOk = false
|
|
break
|
|
elseif ( nMaxIniFailed + nMaxMiddleFailed + nMaxEndFailed) >= nInd/2 then -- somma di vari intervalli
|
|
DGD.EMC = ' ' .. EgtDoorsMsg[531]
|
|
bOk = false
|
|
break
|
|
end
|
|
|
|
-------------------------------------------------
|
|
-- gestione messaggi LIGHT: red, yellow, green
|
|
-------------------------------------------------
|
|
|
|
-- se ho geometrie da entrambe le parti la luce è red
|
|
if nNumGeomBottom > 0 and nNumGeomTop > 0 then
|
|
sLight = 'RED'
|
|
-- se non ho geometrie la luce è green
|
|
elseif nNumGeomBottom == 0 and nNumGeomTop == 0 then
|
|
sLight = 'GREEN'
|
|
-- se una delle due ha delle geometrie
|
|
else
|
|
-- in caso di geometrie tutte sotto luce yellow
|
|
if nNumGeomBottom > 0 then
|
|
sLight = 'YELLOW'
|
|
-- in caso di geometrie tutte sopra luce green
|
|
elseif nNumGeomTop > 0 then
|
|
sLight = 'GREEN'
|
|
end
|
|
end
|
|
|
|
-- *** Tools Setup ***
|
|
-- provo a importare l'attrezzaggio di default, se fallisce passo gli altri
|
|
local bSetUp = EgtImportSetup()
|
|
local tListError
|
|
local sListTool = ''
|
|
|
|
if bSetUp then -- se importato quello di default
|
|
|
|
sSetup = EgtGetDefaultSetupName()
|
|
-- verifico se l'attrezzaggio è idoneo
|
|
bSetUp, tListError = EgtVerifyCurrSetup()
|
|
-- se attrezzaggio andato a buon fine setto il nome dell'attrezzaggio di default
|
|
if bSetUp then
|
|
-- assegno nota con il nome del file setup assegnato
|
|
EgtSetInfo( EgtGetCurrSetup(), 'Name', sSetup)
|
|
else -- preparo la lista degli utensili mancanti
|
|
sListTool = string.format( EgtDoorsMsg[552], sSetup) .. ' (Default)'
|
|
sListTool = sListTool .. '\n ' .. EgtDoorsMsg[553]
|
|
for k = 1, #tListError do
|
|
sListTool = sListTool .. '\n ' .. tListError[k]
|
|
end
|
|
end
|
|
end
|
|
|
|
-- se fallito quello di default o utensili mancanti provo quello indicato nel CurrCamInfo
|
|
if not bSetUp then
|
|
|
|
local sDefSetUp = sSetup -- mi tengo via il nome dell'attrezzaggio di default
|
|
sSetup = mCamData[nNumMachFromCam].Setup1
|
|
-- se nome attrezzaggio non è vuoto
|
|
if sSetup and #sSetup > 0 then
|
|
bSetUp = EgtImportSetup(sSetup)
|
|
end
|
|
|
|
-- se nessuno è andato bene verifico se il primo era stato importato
|
|
if not bSetUp then
|
|
if sDefSetUp and #sDefSetUp > 0 then
|
|
if DGD.EMC and #DGD.EMC > 0 then
|
|
DGD.EMC = DGD.EMC .. '\n' .. ' ' .. EgtDoorsMsg[551]
|
|
else
|
|
DGD.EMC = ' ' .. EgtDoorsMsg[551]
|
|
end
|
|
bOk = false
|
|
if #sListTool > 0 then
|
|
DGD.EMC = DGD.EMC .. sListTool
|
|
end
|
|
break
|
|
else
|
|
-- assegno ugualmente un attrezzaggio vuoto
|
|
EgtSetInfo( EgtGetCurrSetup(), 'Name', EgtDoorsMsg[555])
|
|
end
|
|
else -- ha importato il fle da CurrCamInfo
|
|
-- verifico se l'attrezzaggio è idoneo
|
|
bSetUp, tListError = EgtVerifyCurrSetup()
|
|
|
|
if bSetUp then -- se è andato bene
|
|
-- assegno nota con il nome del file setup assegnato
|
|
EgtSetInfo( EgtGetCurrSetup(), 'Name', sSetup)
|
|
else -- se utensili mancanti
|
|
sListTool = sListTool .. '\n ' .. string.format( EgtDoorsMsg[552], sSetup) .. string.format(' (from CurrCamInfo Setup%s)', 1)
|
|
sListTool = sListTool .. '\n ' .. EgtDoorsMsg[553]
|
|
for k = 1, #tListError do
|
|
sListTool = sListTool .. '\n ' .. tListError[k]
|
|
end
|
|
DGD.EMC = DGD.EMC .. sListTool
|
|
bOk = false
|
|
break
|
|
end
|
|
end
|
|
end
|
|
|
|
-- se nessuna geometria skippata esco
|
|
if nNumMachSkip and nNumMachSkip == 0 then bWork = false end
|
|
|
|
-- se lavorazioni skippate abilito il ribaltamento porta in altra fase
|
|
if nNumMachSkip and nNumMachSkip > 0 then
|
|
nNumMachSkip = 0 -- resetto per il prossimo giro
|
|
-- per interrompere il giro forzatamente ( perché nessun ribaltamento) setto bWork
|
|
bWork = false
|
|
end
|
|
|
|
nNumCycle = nNumCycle + 1
|
|
end -- end while
|
|
|
|
--bOk = false -- per forzare l'errore
|
|
|
|
if nNumGroup > 1 then sNumGroup = '_'..EgtNumToString(nNumGroup,0) end
|
|
|
|
-- Eventuale messaggio di errore
|
|
if not bOk then
|
|
|
|
DoorOutLog( string.format(EgtDoorsMsg[494], MachName), 0) -- inizio lavorazione su macchina
|
|
|
|
DGD.ERR = 20
|
|
DoorOutLog( ' Err=' .. tostring( DGD.ERR), 1)
|
|
|
|
-- stampo gli errori del machiningBase
|
|
if DGD.EMC and #DGD.EMC > 0 then
|
|
DoorOutLog( DGD.EMC, 0)
|
|
end
|
|
|
|
DoorOutLog( string.format( EgtDoorsMsg[475], MachName), 0) -- Error on machining calculation
|
|
|
|
-- cancello il file cn e il txt
|
|
EgtEraseFile( sFileDir..sFileName..sNumGroup..'.cnc')
|
|
EgtEraseFile( sFileDir..sFileName..sNumGroup..'.txt')
|
|
--ricreo il file txt con l'errore
|
|
WriteErrFile( sFileDir..sFileName..sNumGroup..'.txt', string.format( EgtDoorsMsg[475], MachName))
|
|
|
|
if not DGD.NCGEN then -- modificato not DGD con not DGD.NCGEN perche ho incluso EgtDoorsData dove esiste DGD
|
|
if DGD.EMC and #DGD.EMC > 0 then
|
|
EgtOutBox( DGD.EMC .. '\n' .. string.format( EgtDoorsMsg[475], MachName), EgtDoorsMsg[476], EgtDoorsMsg[477]) -- Error on machining calculation
|
|
else
|
|
EgtOutBox( string.format( EgtDoorsMsg[475], MachName), EgtDoorsMsg[476], EgtDoorsMsg[477]) -- Error on machining calculation
|
|
end
|
|
end
|
|
|
|
-- Salvo progetto
|
|
EgtSaveFile()
|
|
|
|
return false, nNumGroup
|
|
end
|
|
|
|
-- Applica tutte le lavorazioni ( che comprende anche l'aggiornamento, EgtUpdateAllMachinings con il calcolo assi macchina e movimenti tra lavorazioni e finale)
|
|
EgtApplyAllMachinings( false, false)
|
|
|
|
-- Salvo progetto
|
|
EgtSaveFile()
|
|
|
|
-- Estimation
|
|
bOk = EgtEstimate( sFileDir..sFileName..sNumGroup..'.html', 'EgtCam5 - '..sFilePath)
|
|
-- NC code generation
|
|
bOk = EgtGenerate( sFileDir..sFileName..sNumGroup..'.cnc', 'EgtCam5 - '..sFilePath)
|
|
|
|
if bOk then
|
|
|
|
if not DGD.ERR then DGD.ERR = 0 end
|
|
|
|
-- luce di caricamento porta
|
|
if sLight then
|
|
DGD.ERM = ' LIGHT='..sLight..'\n'..DGD.ERM
|
|
end
|
|
|
|
DoorOutLog( string.format( '\n'..EgtDoorsMsg[494], MachName), 0) -- inizio lavorazione su macchina
|
|
DoorOutLog( ' Err=' .. tostring( DGD.ERR), 1)
|
|
if not DGD.NCGEN then
|
|
if DGD.ERM and #DGD.ERM > 0 then
|
|
DoorOutLog( DGD.ERM, 0) -- stampo eventuali errori
|
|
end
|
|
end
|
|
DoorOutLog( sTotDispMode, 0) -- stampo la disposizione nel log
|
|
|
|
-- cancello e ricreo il file txt
|
|
EgtEraseFile( sFileDir..sFileName..sNumGroup..'.txt')
|
|
--ricreo il file txt con la disposizione
|
|
WriteErrFile( sFileDir..sFileName..sNumGroup..'.txt', sTotDispMode)
|
|
else
|
|
|
|
DGD.ERR = 20
|
|
DGD.EMC = DGD.EMC .. string.format(EgtDoorsMsg[478], MachName, sSetup)
|
|
|
|
-- cancello e ricreo il file txt
|
|
EgtEraseFile( sFileDir..sFileName..sNumGroup..'.txt')
|
|
--ricreo il file txt con la disposizione
|
|
WriteErrFile( sFileDir..sFileName..sNumGroup..'.txt')
|
|
|
|
-- scrivo messaggio nei file log
|
|
DoorOutLog( string.format(EgtDoorsMsg[478], MachName, sSetup), 0) -- Error on Nc part program generation
|
|
|
|
-- se lanciato da DMach stampo anche un messaggio a video
|
|
if not DGD or not DGD.NCGEN then
|
|
DoorOutLog( ' Err=' .. tostring( DGD.ERR), 0)
|
|
EgtOutBox( string.format(EgtDoorsMsg[478], MachName, sSetup), EgtDoorsMsg[476], EgtDoorsMsg[477]) -- Error on Nc part program generation
|
|
end
|
|
|
|
return false, nNumGroup
|
|
end
|
|
|
|
-- reset librerie locali
|
|
package.loaded[MachiningsTable] = nil
|
|
package.loaded[MachiningsTableOrd] = nil
|
|
|
|
return true, nNumGroup
|
|
end
|
|
|
|
return MachiningLoc
|