713 lines
26 KiB
Lua
713 lines
26 KiB
Lua
-- BatchProcessNew.lua by Egalware s.r.l. 2025/04/24
|
|
|
|
-- Intestazioni
|
|
require( 'EgtBase')
|
|
_ENV = EgtProtectGlobal()
|
|
EgtEnableDebug( false)
|
|
|
|
-- Imposto direttorio libreria specializzata per Travi
|
|
EgtAddToPackagePath( BEAM.BASEDIR .. '\\LuaLibs\\?.lua')
|
|
-- Imposto direttorio strategie. N.B. Le strategie dovranno essere caricate con il nome del direttorio padre
|
|
EgtAddToPackagePath( BEAM.BASEDIR .. '\\Strategies\\Standard\\?.lua')
|
|
EgtAddToPackagePath( BEAM.BASEDIR .. '\\StrategyLibs\\?.lua')
|
|
|
|
-- Verifico che la macchina corrente sia abilitata per la lavorazione delle Travi
|
|
local sMachine = BEAM.MACHINE
|
|
if BEAM.FLAG ~= 6 then
|
|
EgtResetCurrMachGroup()
|
|
if not EgtSetCurrMachine( sMachine) then
|
|
BEAM.ERR = 11
|
|
BEAM.MSG = 'Error selecting machine : ' .. sMachine
|
|
WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
|
|
PostErrView( BEAM.ERR, BEAM.MSG)
|
|
return
|
|
end
|
|
end
|
|
local sMachDir = EgtGetCurrMachineDir()
|
|
if not sMachDir then
|
|
EgtOutBox( 'Errore nel caricamento della macchina corrente', 'Lavora Travi', 'ERROR')
|
|
return
|
|
end
|
|
if not EgtExistsFile( sMachDir .. '\\Beam\\BeamData.lua') then
|
|
EgtOutBox( 'La macchina corrente non è configurata per lavorare travi', 'Lavora Travi', 'ERROR')
|
|
BEAM.ERR = 12
|
|
BEAM.MSG = 'Error not configured for beams machine : ' .. sMachine
|
|
WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
|
|
PostErrView( BEAM.ERR, BEAM.MSG)
|
|
return
|
|
end
|
|
|
|
-- Elimino direttori altre macchine e imposto direttorio macchina corrente per ricerca librerie
|
|
EgtRemoveBaseMachineDirFromPackagePath()
|
|
EgtAddToPackagePath( sMachDir .. '\\Beam\\?.lua')
|
|
|
|
-- Segnalazione avvio
|
|
EgtOutLog( '*** Beam Process Start ***', 1)
|
|
|
|
-- Carico le librerie
|
|
_G.package.loaded.BeamExec = nil
|
|
_G.package.loaded.BeamLib = nil
|
|
_G.package.loaded.BeamData = nil
|
|
_G.package.loaded.Identity = nil
|
|
_G.package.loaded.BasicCustomerStrategies = nil
|
|
_G.package.loaded.FeatureLib = nil
|
|
_G.package.loaded.FaceData = nil
|
|
_G.package.loaded.MachiningLib = nil
|
|
_G.package.loaded.DiceCut = nil
|
|
_G.package.loaded.Logs = nil
|
|
-- strategie di base sempre presenti
|
|
_G.package.loaded['HEADCUT\\HEADCUT'] = nil
|
|
_G.package.loaded['TAILCUT\\TAILCUT'] = nil
|
|
|
|
-- TODO controllare se c'è un modo migliore per resettare librerie delle strategie caricate precedentemente
|
|
-- Per ottimizzare potremmo anche ciclare solo fino al numero di strategie raggiunto per il momento.
|
|
-- Infatti difficile ci siano 9999 strategie.
|
|
-- reset strategie caricate come librerie
|
|
for i = 1, 9999 do
|
|
local IdSTRTemp = EgtReplaceString( tostring( i/10000, 4), '0.', '')
|
|
local sLibraryToReload = "STR" .. IdSTRTemp .. "\\STR" .. IdSTRTemp
|
|
if _G.package.loaded[sLibraryToReload] then
|
|
_G.package.loaded[sLibraryToReload] = nil
|
|
end
|
|
end
|
|
local vtCoreStrategiesNames = EgtFindAllFiles( BEAM.BASEDIR .. '\\StrategyLibs\\*.lua')
|
|
for i = 1, #vtCoreStrategiesNames do
|
|
local sCurrentName = EgtSplitString( vtCoreStrategiesNames[i], '.')[1]
|
|
if _G.package.loaded[sCurrentName] then
|
|
_G.package.loaded[sCurrentName] = nil
|
|
end
|
|
end
|
|
|
|
|
|
-- Variabili globali
|
|
PARTS = {} -- tabella contenente tutte le informazioni di ogni pezzo
|
|
|
|
-- Carico i dati globali
|
|
local BeamData = require( 'BeamData')
|
|
-- carico librerie
|
|
local BeamExec = require( 'BeamExec')
|
|
local BeamLib = require( 'BeamLib')
|
|
|
|
-- Variabili di modulo
|
|
local dRawW
|
|
local dRawH
|
|
local sTxtLogFile = EgtChangePathExtension( BEAM.FILE, '.txt')
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
-- Funzioni di supporto
|
|
|
|
local function GetDataConfig()
|
|
-- recupero utensili dal magazzino
|
|
BeamExec.GetToolsFromDB()
|
|
-- se si utilizza interfaccia B&W, si carica il file JSON
|
|
local bIsBeamWall = BEAM.BW -- TODO verificare se questo parametro funziona
|
|
if bIsBeamWall then
|
|
BeamExec.GetStrategiesFromJSONinBD()
|
|
end
|
|
-- TODO da gestire eventuali errori bloccanti
|
|
return true
|
|
end
|
|
|
|
local function WriteErrToLogFile( nErr, sMsg, nRot, idCut, idTask)
|
|
local hFile = io.open( sTxtLogFile, 'a')
|
|
hFile:write( 'ERR=' .. tostring( nErr) .. '\n')
|
|
hFile:write( sMsg .. '\n')
|
|
hFile:write( 'ROT=' .. tostring( nRot or 0) .. '\n')
|
|
hFile:write( 'CUTID=' .. tostring( idCut or 0) .. '\n')
|
|
hFile:write( 'TASKID=' .. tostring( idTask or 0) .. '\n')
|
|
hFile:close()
|
|
end
|
|
|
|
local function WriteFallToLogFile( nErr, sMsg, idCut, nFall)
|
|
local hFile = io.open( sTxtLogFile, 'a')
|
|
hFile:write( 'ERR=' .. tostring( nErr) .. '\n')
|
|
hFile:write( sMsg .. '\n')
|
|
hFile:write( 'CUTID=' .. tostring( idCut or 0) .. '\n')
|
|
hFile:write( 'FALL=' .. tostring( nFall or 0) .. '\n')
|
|
hFile:close()
|
|
end
|
|
|
|
local function WriteTimeToLogFile( dTime)
|
|
local hFile = io.open( sTxtLogFile, 'a')
|
|
hFile:write( 'TIME=' .. EgtNumToString( dTime) .. '\n')
|
|
hFile:close()
|
|
end
|
|
|
|
-- Funzioni per gestire visualizzazione dopo errore e dopo warning
|
|
local function PostErrView( nErr, sMsg)
|
|
if nErr ~= 0 and ( BEAM.FLAG == 1 or BEAM.FLAG == 2) then
|
|
EgtSetView( SCE_VD.ISO_SW, false)
|
|
EgtZoom( SCE_ZM.ALL)
|
|
EgtOutBox( sMsg, 'BatchProcess (err=' .. tostring( nErr) .. ')', 'ERRORS')
|
|
end
|
|
end
|
|
|
|
local function PostWarnView( nWarn, sMsg)
|
|
if nWarn ~= 0 and ( BEAM.FLAG == 1 or BEAM.FLAG == 2) then
|
|
EgtSetView( SCE_VD.ISO_SW, false)
|
|
EgtZoom( SCE_ZM.ALL)
|
|
EgtOutBox( sMsg, 'BatchProcess (wrn=' .. tostring( nWarn) .. ')', 'WARNINGS')
|
|
end
|
|
end
|
|
|
|
-- Funzione di reset gruppo di lavoro in caso di impossibilità di inserire i pezzi
|
|
local function ResetMachGroup( PARTS)
|
|
for i = 1, #PARTS do
|
|
EgtErase( PARTS[i].id)
|
|
end
|
|
EgtRemoveMachGroup( EgtGetCurrMachGroup() or GDB_ID.NULL)
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
local sFlag = ''
|
|
if BEAM.FLAG == 0 then
|
|
sFlag = 'GENERATE'
|
|
elseif BEAM.FLAG == 1 then
|
|
sFlag = 'MODIFY'
|
|
elseif BEAM.FLAG == 2 then
|
|
sFlag = 'SIMULATE'
|
|
elseif BEAM.FLAG == 3 then
|
|
sFlag = 'CHECK'
|
|
elseif BEAM.FLAG == 4 then
|
|
sFlag = 'CHECK+GENERATE'
|
|
elseif BEAM.FLAG == 6 then
|
|
sFlag = 'CREATE_BAR'
|
|
else
|
|
sFlag = 'FLAG='..tostring( BEAM.FLAG)
|
|
end
|
|
local sLog = 'BatchProcess : ' .. BEAM.FILE .. ', ' .. BEAM.MACHINE .. ', ' .. sFlag
|
|
EgtOutLog( sLog)
|
|
|
|
-- Dati dei file
|
|
local sDir, sTitle = EgtSplitPath( BEAM.FILE)
|
|
local sOriFile = sDir..sTitle..'.ori.bwe'
|
|
local sNgeFile = sDir..sTitle..'.bwe'
|
|
|
|
-- cancellazione file log txt precedente
|
|
-- in caso sia richiesta generazione senza check, verifico prima che il file log specifico non contenga errori: se sì, forzo il check
|
|
-- TODO serve ancora?? forzare sempre il check e simulazione?
|
|
if BEAM.FLAG == 0 then
|
|
local hLogFile = io.open( sTxtLogFile, 'r')
|
|
if hLogFile then
|
|
for line in hLogFile:lines() do
|
|
if EgtStartsWith( line, 'ERR') and tonumber( EgtSplitString( line, '=')[2] or 0) > 0 then
|
|
BEAM.FLAG = 4
|
|
break
|
|
end
|
|
end
|
|
hLogFile:close()
|
|
end
|
|
end
|
|
-- Cancello file di log specifico
|
|
EgtEraseFile( sTxtLogFile)
|
|
|
|
-- In generale va completamente riprocessato
|
|
local bToProcess = true
|
|
local bToRecalc = false
|
|
-- se BTL, barra ed esiste già il corrispondente progetto Nge
|
|
if EgtExistsFile( sOriFile) then
|
|
bToProcess = false
|
|
EgtCopyFile( sOriFile, sNgeFile)
|
|
-- se cambiata configurazione macchina da ultima elaborazione, devo aggiornare
|
|
if EgtCompareFilesLastWriteTime( sOriFile, sMachDir .. '\\Beam\\TS3Data.lua') == -1 or
|
|
EgtCompareFilesLastWriteTime( sOriFile, sMachDir .. '\\Tools\\Tools.data') == -1 or
|
|
EgtCompareFilesLastWriteTime( sOriFile, sMachDir .. '\\' .. sMachine ..'.mlde') == -1 then
|
|
bToRecalc = true
|
|
end
|
|
end
|
|
|
|
-- Inizializzo contatori errori e avvisi
|
|
local nErrCnt = 0
|
|
local nWarnCnt = 0
|
|
|
|
-- Se da elaborare
|
|
if bToProcess then
|
|
EgtOutLog( ' +++ Processing Parts >>>')
|
|
|
|
-- Flag di barra da creare
|
|
local bCreateBar
|
|
-- Lunghezza della barra ed elenco travi
|
|
local dBarLen
|
|
|
|
-- Se necessario, apro il file Bwe
|
|
if BEAM.FLAG ~= 6 then
|
|
if not EgtOpenFile( BEAM.FILE) then
|
|
BEAM.ERR = 13
|
|
BEAM.MSG = 'Error opening BWE file : ' .. BEAM.FILE
|
|
WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
|
|
PostErrView( BEAM.ERR, BEAM.MSG)
|
|
return
|
|
end
|
|
-- Faccio copia del file originale
|
|
EgtCopyFile( BEAM.FILE, sOriFile)
|
|
|
|
-- Se già presente un gruppo di lavoro
|
|
if EgtGetFirstMachGroup() then
|
|
-- Barra già presente
|
|
bCreateBar = false
|
|
-- Rendo corrente il gruppo di lavoro
|
|
EgtSetCurrMachGroup()
|
|
-- Area tavola
|
|
local b3Tab = EgtGetTableArea()
|
|
-- Sezione del grezzo
|
|
local nRawId = EgtGetFirstRawPart()
|
|
if not nRawId then
|
|
BEAM.ERR = 14
|
|
BEAM.MSG = 'Error no Raw Parts in the file : ' .. BEAM.FILE
|
|
WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
|
|
PostErrView( BEAM.ERR, BEAM.MSG)
|
|
return
|
|
end
|
|
local b3Raw = EgtGetRawPartBBox( nRawId)
|
|
-- Calcolo posizione estremo TR o BR della tavola rispetto a sua origine in BL
|
|
local dPosY = EgtIf( BeamData.CENTER_BEAM, ( b3Tab:getDimY() + b3Raw:getDimY() * EgtIf( BeamData.RIGHT_LOAD, -1, 1)) / 2, EgtIf( BeamData.RIGHT_LOAD, 0, b3Tab:getDimY()))
|
|
BeamData.OriXR = Point3d( b3Tab:getDimX(), dPosY, 0)
|
|
BeamData.PosXR = EgtIf( BeamData.RIGHT_LOAD, MCH_CR.BR, MCH_CR.TR)
|
|
-- Calcolo minimo grezzo scaricabile
|
|
BeamExec.CalcMinUnloadableRaw( b3Raw:getDimY(), b3Raw:getDimZ())
|
|
-- altrimenti devo recuperare i pezzi per creare la barra
|
|
else
|
|
-- Barra da creare
|
|
bCreateBar = true
|
|
-- Recupero l'elenco ordinato delle travi
|
|
local nPartId = EgtGetFirstPart()
|
|
while nPartId do
|
|
table.insert( PARTS, { id = nPartId, sName = ( EgtGetName( nPartId) or ( 'Id=' .. tonumber( nPartId)))})
|
|
nPartId = EgtGetNextPart( nPartId)
|
|
end
|
|
if #PARTS == 0 then
|
|
BEAM.ERR = 14
|
|
BEAM.MSG = 'Error no beams in the file : ' .. BEAM.FILE
|
|
WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
|
|
PostErrView( BEAM.ERR, BEAM.MSG)
|
|
return
|
|
else
|
|
local sOut = ''
|
|
for i = 1, #PARTS do
|
|
sOut = sOut .. PARTS[i].sName .. ', '
|
|
end
|
|
sOut = sOut:sub( 1, -3)
|
|
EgtOutLog( 'Travi trovate : ' .. sOut, 1)
|
|
end
|
|
-- Ne recupero le dimensioni
|
|
for i = 1, #PARTS do
|
|
local Ls = EgtGetFirstNameInGroup( PARTS[i].id, 'Box')
|
|
local b3Solid = EgtGetBBoxGlob( Ls or GDB_ID.NULL, GDB_BB.STANDARD)
|
|
if not b3Solid then
|
|
BEAM.ERR = 15
|
|
BEAM.MSG = 'Box undefined for beam ' .. PARTS[i].sName
|
|
WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
|
|
PostErrView( BEAM.ERR, BEAM.MSG)
|
|
return
|
|
else
|
|
PARTS[i].b3PartOriginal = b3Solid
|
|
end
|
|
end
|
|
-- Assegno lunghezza della barra
|
|
dBarLen = PARTS[1].b3PartOriginal:getDimX() + 10
|
|
if dBarLen < 2200 then
|
|
dBarLen = dBarLen + 1800
|
|
end
|
|
-- Assegno posizione prima ed unica trave
|
|
PARTS[1].PosX = 10
|
|
end
|
|
|
|
-- Altrimenti, opero sul progetto corrente
|
|
else
|
|
-- Recupero l'identificativo del gruppo di lavoro corrente
|
|
local nMGrpId = EgtGetCurrMachGroup()
|
|
-- Barra da creare
|
|
bCreateBar = true
|
|
-- Lunghezza della barra
|
|
dBarLen = EgtGetInfo( nMGrpId, 'BARLEN', 'd')
|
|
-- Recupero l'elenco ordinato delle travi da inserire nella barra
|
|
for i = 1, 100 do
|
|
local sKey = 'PART'..tostring( i)
|
|
local sVal = EgtGetInfo( nMGrpId, sKey)
|
|
local vVal = EgtSplitString( sVal or '')
|
|
if not vVal or #vVal < 2 then break end
|
|
local nPartId = tonumber( vVal[1])
|
|
local dPosX = tonumber( vVal[2])
|
|
table.insert( PARTS, { id = nPartId, dPosX = dPosX, sName = ( EgtGetName( nPartId) or ( 'Id=' .. tonumber( nPartId)))})
|
|
end
|
|
if #PARTS == 0 then
|
|
BEAM.ERR = 14
|
|
BEAM.MSG = 'Error : no beams in the project'
|
|
WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
|
|
return
|
|
else
|
|
local sOut = ''
|
|
for i = 1, #PARTS do
|
|
sOut = sOut .. PARTS[i].sName .. ', '
|
|
end
|
|
sOut = sOut:sub( 1, -3)
|
|
EgtOutLog( 'Travi trovate : ' .. sOut, 1)
|
|
end
|
|
-- Ne recupero le dimensioni
|
|
for i = 1, #PARTS do
|
|
local Ls = EgtGetFirstNameInGroup( PARTS[i].id, 'Box')
|
|
local b3Solid = EgtGetBBoxGlob( Ls or GDB_ID.NULL, GDB_BB.STANDARD)
|
|
if not b3Solid then
|
|
BEAM.ERR = 15
|
|
BEAM.MSG = 'Box undefined for beam ' .. PARTS[i].sName
|
|
WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
|
|
return
|
|
else
|
|
PARTS[i].b3PartOriginal = b3Solid
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Se devo creare la barra
|
|
if bCreateBar then
|
|
if #PARTS == 0 then
|
|
-- Recupero l'identificativo del gruppo di lavoro corrente
|
|
local nMGrpId = EgtGetCurrMachGroup()
|
|
-- Recupero le dimensioni della barra
|
|
dRawW = EgtGetInfo(nMGrpId, 'BARWIDTH', 'd')
|
|
dRawH = EgtGetInfo(nMGrpId, 'BARHEIGHT', 'd')
|
|
else
|
|
-- Ne verifico le dimensioni
|
|
dRawW = PARTS[1].b3PartOriginal:getDimY()
|
|
dRawH = PARTS[1].b3PartOriginal:getDimZ()
|
|
end
|
|
local vBeamErr = {}
|
|
for i = 2, #PARTS do
|
|
local dDimW = PARTS[i].b3PartOriginal:getDimY()
|
|
local dDimH = PARTS[i].b3PartOriginal:getDimZ()
|
|
if ( abs( dDimW - dRawW) > 100 * GEO.EPS_SMALL or abs( dDimH - dRawH) > 100 * GEO.EPS_SMALL) and
|
|
( abs( dDimH - dRawW) > 100 * GEO.EPS_SMALL or abs( dDimW - dRawH) > 100 * GEO.EPS_SMALL) then
|
|
table.insert( vBeamErr, i)
|
|
end
|
|
end
|
|
if #vBeamErr > 0 then
|
|
local sOut = 'Rimosse travi con sezioni diverse dalla prima :\n'
|
|
for i = #vBeamErr, 1, -1 do
|
|
sOut = sOut .. PARTS[vBeamErr[i]].sName .. '\n'
|
|
table.remove( PARTS, vBeamErr[i])
|
|
end
|
|
ResetMachGroup( PARTS)
|
|
BEAM.ERR = 16
|
|
BEAM.MSG = sOut
|
|
WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
|
|
PostErrView( BEAM.ERR, BEAM.MSG)
|
|
return
|
|
end
|
|
|
|
-- Verifico sezione barra non troppo grande
|
|
if not BeamData.MAX_WIDTH2 or not BeamData.MAX_HEIGHT2 then
|
|
if ( dRawW > BeamData.MAX_WIDTH + 10 * GEO.EPS_SMALL or dRawH > BeamData.MAX_HEIGHT + 10 * GEO.EPS_SMALL) then
|
|
ResetMachGroup( PARTS)
|
|
local sOut = 'Sezione (' .. EgtNumToString( dRawW, 2) .. ' x ' .. EgtNumToString( dRawH, 2) .. ') ' ..
|
|
'oltre i limiti della macchina (' .. EgtNumToString( BeamData.MAX_WIDTH, 2) .. ' x ' .. EgtNumToString( BeamData.MAX_HEIGHT, 2) .. ') '
|
|
BEAM.ERR = 17
|
|
BEAM.MSG = sOut
|
|
WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
|
|
PostErrView( BEAM.ERR, BEAM.MSG)
|
|
return
|
|
end
|
|
else
|
|
if ( dRawW > BeamData.MAX_WIDTH + 10 * GEO.EPS_SMALL or dRawH > BeamData.MAX_HEIGHT + 10 * GEO.EPS_SMALL) and
|
|
( dRawW > BeamData.MAX_WIDTH2 + 10 * GEO.EPS_SMALL or dRawH > BeamData.MAX_HEIGHT2 + 10 * GEO.EPS_SMALL) then
|
|
ResetMachGroup( PARTS)
|
|
local sOut = 'Sezione (' .. EgtNumToString( dRawW, 2) .. ' x ' .. EgtNumToString( dRawH, 2) .. ') ' ..
|
|
'oltre i limiti della macchina (' .. EgtNumToString( BeamData.MAX_WIDTH, 2) .. ' x ' .. EgtNumToString( BeamData.MAX_HEIGHT, 2) .. ') ' ..
|
|
'e (' .. EgtNumToString( BeamData.MAX_WIDTH2, 2) .. ' x ' .. EgtNumToString( BeamData.MAX_HEIGHT2, 2) .. ')'
|
|
BEAM.ERR = 17
|
|
BEAM.MSG = sOut
|
|
WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
|
|
PostErrView( BEAM.ERR, BEAM.MSG)
|
|
return
|
|
end
|
|
end
|
|
|
|
-- Verifico sezione barra non troppo piccola
|
|
if dRawW < BeamData.MIN_WIDTH - 10 * GEO.EPS_SMALL or dRawH < BeamData.MIN_HEIGHT - 10 * GEO.EPS_SMALL then
|
|
ResetMachGroup( PARTS)
|
|
local sOut = 'Sezione (' .. EgtNumToString( dRawW, 2) .. ' x ' .. EgtNumToString( dRawH, 2) .. ') ' ..
|
|
'sotto i limiti della macchina (' .. EgtNumToString( BeamData.MIN_WIDTH, 2) .. ' x ' .. EgtNumToString( BeamData.MIN_HEIGHT, 2) .. ')'
|
|
BEAM.ERR = 17
|
|
BEAM.MSG = sOut
|
|
WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
|
|
PostErrView( BEAM.ERR, BEAM.MSG)
|
|
return
|
|
end
|
|
|
|
-- Lunghezza della barra
|
|
local dRawL = dBarLen + 0.1
|
|
-- Sovramateriale di testa
|
|
local dOvmHead = 0
|
|
if #PARTS > 0 then
|
|
dOvmHead = PARTS[1].PosX or 0
|
|
end
|
|
|
|
-- Sistemo le travi nel grezzo
|
|
local bPbOk, sPbErr = BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, nil, PARTS, BEAM.FLAG ~= 6)
|
|
if not bPbOk then
|
|
BEAM.ERR = 18
|
|
BEAM.MSG = sPbErr
|
|
WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
|
|
PostErrView( BEAM.ERR, BEAM.MSG)
|
|
return
|
|
else
|
|
-- Scrivo altezza e larghezza barra nel gruppo di lavoro corrente
|
|
local nMGrpId = EgtGetCurrMachGroup()
|
|
EgtSetInfo(nMGrpId, 'BARHEIGHT', dRawH)
|
|
EgtSetInfo(nMGrpId, 'BARWIDTH', dRawW)
|
|
end
|
|
-- sistemazioni per pezzi nella barra
|
|
else
|
|
-- ciclo sui grezzi
|
|
local nRawId = EgtGetFirstRawPart()
|
|
while nRawId do
|
|
-- massimo un pezzo per grezzo
|
|
local nPartId = EgtGetFirstPartInRawPart( nRawId)
|
|
-- box del pezzo
|
|
local Ls = EgtGetFirstNameInGroup( nPartId, 'Box')
|
|
local b3Solid = EgtGetBBoxGlob( Ls or GDB_ID.NULL, GDB_BB.STANDARD)
|
|
-- se nel grezzo c'è un pezzo
|
|
if nPartId then
|
|
-- creo o pulisco gruppo geometrie aggiuntive
|
|
BeamLib.CreateOrEmptyAddGroup( nPartId)
|
|
-- aggiungo faccia per taglio iniziale al pezzo
|
|
BeamLib.AddPartStartFace( nPartId, b3Solid)
|
|
-- aggiungo faccia per taglio finale al pezzo
|
|
BeamLib.AddPartEndFace( nPartId, b3Solid)
|
|
end
|
|
-- passo al successivo grezzo
|
|
nRawId = EgtGetNextRawPart( nRawId)
|
|
end
|
|
-- elimino le lavorazioni
|
|
EgtRemoveAllOperations()
|
|
-- Recupero l'identificativo del gruppo di lavoro corrente
|
|
local nMGrpId = EgtGetCurrMachGroup()
|
|
-- Recupero l'elenco ordinato delle travi da inserire nella barra
|
|
for i = 1, 100 do
|
|
local sKey = 'PART'..tostring( i)
|
|
local sVal = EgtGetInfo( nMGrpId, sKey)
|
|
local vVal = EgtSplitString( sVal or '')
|
|
if not vVal or #vVal < 2 then break end
|
|
local nPartId = tonumber( vVal[1])
|
|
local dPosX = tonumber( vVal[2])
|
|
table.insert( PARTS, { id = nPartId, dPosX = dPosX, sName = ( EgtGetName( nPartId) or ( 'Id=' .. tonumber( nPartId)))})
|
|
end
|
|
end
|
|
|
|
-- Se richiesta solo barra, esco
|
|
if BEAM.FLAG == 6 then
|
|
-- Completamento senza errori e avvisi
|
|
if nWarnCnt == 0 then
|
|
BEAM.ERR = 0
|
|
BEAM.MSG = '---'
|
|
WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
|
|
end
|
|
EgtOutLog( ' +++ BatchProcess completed')
|
|
return
|
|
end
|
|
|
|
-- Imposto Nome file CN
|
|
local _, sName, _ = EgtSplitPath( BEAM.FILE)
|
|
EgtSetInfo( EgtGetCurrMachGroup(), 'NcName', sName .. '.cnc')
|
|
|
|
-- Abilito Vmill
|
|
EgtSetInfo( EgtGetCurrMachGroup(), 'Vm', '1')
|
|
|
|
-- Aggiorno Setup utensili
|
|
EgtImportSetup()
|
|
|
|
-- Lavoro le features
|
|
if not GetDataConfig() then return end
|
|
BeamExec.GetProcessings( PARTS)
|
|
BeamExec.ProcessMachinings( PARTS)
|
|
local sOutput = ''
|
|
for i = 1, #RESULT do
|
|
local sMsg = ''
|
|
if RESULT[i].sType == 'Feature' then
|
|
sMsg = RESULT[i].ChosenStrategy.sInfo
|
|
elseif RESULT[i].sType == 'Part' then
|
|
sMsg = RESULT[i].sMsg
|
|
end
|
|
sMsg = string.gsub( sMsg or '', '\n', ' ', 10)
|
|
sMsg = string.gsub( sMsg or '', '\r', ' ', 10)
|
|
-- trovata almeno una strategia e feature lavorata completamente
|
|
if RESULT[i].sType == 'Feature' and RESULT[i].ChosenStrategy.sStatus == 'Completed' then
|
|
BEAM.ERR = 0
|
|
BEAM.MSG = '---'
|
|
BEAM.ROT = -( RESULT[i].nRotation or 1) + 1
|
|
BEAM.CUTID = RESULT[i].idCut
|
|
BEAM.TASKID = RESULT[i].idTask
|
|
WriteErrToLogFile( BEAM.ERR, BEAM.MSG, BEAM.ROT, BEAM.CUTID, BEAM.TASKID)
|
|
-- trovata almeno una strategia ma nessuna applicabile oppure non trovata alcuna strategia
|
|
elseif RESULT[i].sType == 'Feature'
|
|
and ( ( RESULT[i].ChosenStrategy.sStatus == 'Not-Applicable')
|
|
or ( not RESULT[i].ChosenStrategy.sStrategyName)) then
|
|
|
|
nErrCnt = nErrCnt + 1
|
|
if #sMsg == 0 then
|
|
sMsg = 'No applicable strategy found'
|
|
end
|
|
sOutput = sOutput .. string.format( '[%d,%d] %s\n', RESULT[i].idCut, RESULT[i].idTask, sMsg)
|
|
BEAM.ERR = 19
|
|
BEAM.MSG = sMsg
|
|
BEAM.ROT = -( RESULT[i].nRotation or 1) + 1
|
|
BEAM.CUTID = RESULT[i].idCut
|
|
BEAM.TASKID = RESULT[i].idTask
|
|
WriteErrToLogFile( BEAM.ERR, BEAM.MSG, BEAM.ROT, BEAM.CUTID, BEAM.TASKID)
|
|
else
|
|
-- segnalazione scarico pezzo standard, incompleto o a caduta
|
|
if RESULT[i].sType == 'Part' and ( RESULT[i].nErr == -100 or RESULT[i].nErr == -101 or RESULT[i].nErr == -102) then
|
|
BEAM.ERR = 0
|
|
BEAM.MSG = sMsg
|
|
BEAM.CUTID = RESULT[i].idCut
|
|
BEAM.FALL = abs( RESULT[i].nErr + 100)
|
|
WriteFallToLogFile( BEAM.ERR, BEAM.MSG, BEAM.CUTID, BEAM.FALL)
|
|
-- feature incompleta e altro
|
|
elseif RESULT[i].sType == 'Feature' and RESULT[i].ChosenStrategy.sStatus == 'Not-Completed' then
|
|
nWarnCnt = nWarnCnt + 1
|
|
sOutput = sOutput .. string.format( '[%d,%d] %s\n', RESULT[i].idCut, RESULT[i].idTask, sMsg)
|
|
BEAM.ERR = -19
|
|
BEAM.MSG = 'Incomplete : Completion index ' .. RESULT[i].ChosenStrategy.nCompletionIndex .. '/5\n' .. sMsg
|
|
BEAM.ROT = -( RESULT[i].nRotation or 1) + 1
|
|
BEAM.CUTID = RESULT[i].idCut
|
|
BEAM.TASKID = RESULT[i].idTask
|
|
WriteErrToLogFile( BEAM.ERR, BEAM.MSG, BEAM.ROT, BEAM.CUTID, BEAM.TASKID)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Salvo il progetto
|
|
EgtSaveFile( sNgeFile)
|
|
-- copio come originale (per dichiarare progetto ricalcolato)
|
|
EgtCopyFile( sNgeFile, sOriFile)
|
|
|
|
-- Visualizzazione avvisi o errori
|
|
if #sOutput > 0 then EgtOutLog( sOutput) end
|
|
if nErrCnt > 0 then
|
|
PostErrView( 19, sOutput)
|
|
elseif nWarnCnt > 0 then
|
|
PostWarnView( 19, sOutput)
|
|
end
|
|
|
|
-- Altrimenti carico il progetto salvato e dichiaro nessun errore
|
|
else
|
|
EgtOutLog( ' +++ Loading Project already processed >>>')
|
|
-- Carico il progetto già fatto
|
|
EgtOpenFile( sNgeFile)
|
|
-- Passo in modalità lavora
|
|
EgtSetCurrMachGroup( EgtGetLastMachGroup())
|
|
-- Se necessario eseguo aggiornamento con setup corrente e ricalcolo delle lavorazioni
|
|
if bToRecalc or BEAM.FLAG == 3 or BEAM.FLAG == 4 then
|
|
EgtOutLog( ' +++ Recalculating all dispositions and machinings >>>')
|
|
EgtImportSetup()
|
|
EgtApplyAllMachinings()
|
|
-- Salvo il progetto
|
|
EgtSaveFile( sNgeFile)
|
|
-- copio come originale (per dichiarare progetto ricalcolato)
|
|
EgtCopyFile( sNgeFile, sOriFile)
|
|
end
|
|
end
|
|
|
|
-- *** Eseguo simulazione con verifica collisione in cieco ***
|
|
if ( BEAM.FLAG == 0 and ( bToProcess or bToRecalc)) or BEAM.FLAG == 3 or BEAM.FLAG == 4 then
|
|
EgtOutLog( ' +++ Simulating with collision check >>>')
|
|
-- verifico setup
|
|
local bSetUpOk, SetUpErrors = EgtVerifyCurrSetup()
|
|
if not bSetUpOk then
|
|
local sToolsList = ""
|
|
for ToolIndex = 1, #SetUpErrors do
|
|
sToolsList = sToolsList .. SetUpErrors[ToolIndex]
|
|
if ToolIndex ~= #SetUpErrors then
|
|
sToolsList = sToolsList .. ", "
|
|
end
|
|
end
|
|
WriteErrToLogFile( 19, 'Error in setup: tool/s ' .. sToolsList .. ' not found', 0, 0, 0)
|
|
return
|
|
end
|
|
-- lancio simulazione
|
|
local bSimOk, nErr, sErr = EgtSimulate()
|
|
if not bSimOk then
|
|
if nErr == MCH_SHE.INIT then
|
|
BEAM.ERR = 19
|
|
BEAM.MSG = 'Error starting simulation'
|
|
elseif nErr == MCH_SHE.COLLISION then
|
|
BEAM.ERR = 22
|
|
BEAM.MSG = 'Head-part collision'
|
|
elseif nErr == MCH_SHE.OUTSTROKE then
|
|
BEAM.ERR = 23
|
|
BEAM.MSG = 'Axis outstroke ' .. sErr
|
|
elseif nErr == MCH_SHE.SPECIAL then
|
|
BEAM.ERR = 24
|
|
BEAM.MSG = 'Special error ' .. sErr
|
|
else
|
|
BEAM.ERR = 25
|
|
BEAM.MSG = 'General failure (contact supplier)'
|
|
end
|
|
BEAM.ROT = 0
|
|
BEAM.CUTID = 0
|
|
BEAM.TASKID = 0
|
|
local vItem = EgtSplitString( sErr, ';') or {}
|
|
for i = 1, #vItem do
|
|
vItem[i] = EgtTrim( vItem[i] or '')
|
|
if string.find( vItem[i], 'CUTID', 1, true) then
|
|
BEAM.CUTID = EgtGetVal( vItem[i], 'CUTID', 'i') or 0
|
|
elseif string.find( vItem[i], 'TASKID', 1, true) then
|
|
BEAM.TASKID = EgtGetVal( vItem[i], 'TASKID', 'i') or 0
|
|
end
|
|
end
|
|
WriteErrToLogFile( BEAM.ERR, BEAM.MSG, BEAM.ROT, BEAM.CUTID, BEAM.TASKID)
|
|
return
|
|
end
|
|
end
|
|
|
|
-- *** Genero programma CN *** ( se richiesto)
|
|
local bIsGenerationEnabled = ( EgtVerifyKeyOption( 110) == false)
|
|
if bIsGenerationEnabled and ( BEAM.FLAG == 0 or BEAM.FLAG == 4) then
|
|
EgtOutLog( ' +++ Generating NC part program >>>')
|
|
local sInfo = 'EgtCAM5' .. EgtIf( EgtIs64bit(), ' 64bit', '')
|
|
if EgtGetExeVersion then
|
|
sInfo = sInfo .. ' ver.' .. EgtGetExeVersion()
|
|
end
|
|
sInfo = sInfo .. ' - '
|
|
if not EgtGenerate( '', sInfo .. sNgeFile) then
|
|
BEAM.ERR = 20
|
|
local _, sName, _ = EgtSplitPath( BEAM.FILE)
|
|
BEAM.MSG = 'Error generating NC part program : ' .. sName
|
|
WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
|
|
PostErrView( BEAM.ERR, BEAM.MSG)
|
|
return
|
|
end
|
|
end
|
|
|
|
-- *** Eseguo stima tempi ***
|
|
EgtOutLog( ' +++ Estimating T&L >>>')
|
|
if not EgtEstimate( '', 'EgtCAM5 - ' .. sNgeFile) then
|
|
BEAM.ERR = 21
|
|
local _, sName, _ = EgtSplitPath( BEAM.FILE)
|
|
BEAM.MSG = 'Error estimating production time : ' .. sName
|
|
WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
|
|
PostErrView( BEAM.ERR, BEAM.MSG)
|
|
return
|
|
end
|
|
local Ttot = EgtGetInfo( EgtGetCurrMachGroup(), 'Ttot', 'd')
|
|
local sTime = 'Total Time = ' .. EgtNumToString( Ttot, 1)
|
|
EgtOutLog( sTime)
|
|
|
|
-- Se modifica o simula, imposto la vista ISO 3d opportuna
|
|
if BEAM.FLAG == 1 or BEAM.FLAG == 2 then
|
|
local vView = { SCE_VD.ISO_NW, SCE_VD.ISO_SW, SCE_VD.ISO_NE, SCE_VD.ISO_SE}
|
|
local nV = min( max( BeamData.SIMUL_VIEW_DIR or 2, 1), 4)
|
|
EgtSetView( vView[nV], false)
|
|
end
|
|
|
|
-- Completamento senza errori e avvisi
|
|
if nWarnCnt == 0 then
|
|
BEAM.ERR = 0
|
|
BEAM.MSG = '---'
|
|
WriteErrToLogFile( BEAM.ERR, BEAM.MSG)
|
|
end
|
|
|
|
-- Scrittura tempo totale stimato di lavorazione
|
|
WriteTimeToLogFile( Ttot)
|
|
|
|
EgtOutLog( ' +++ BatchProcess completed')
|