Egalware/DataGunstock
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
DataGunstock/Main.lua
T
DarioS 1bd70de55b Gunstock : 
- modifiche Beretta per import Fagor
- correzione per variabili con nomi contenuti in nomi di altre (@A e @ANG).
2022-07-18 09:06:18 +02:00

1763 lines
66 KiB
Lua
Raw Permalink Blame History

-- Main.lua by Egaltech s.r.l. 2022/07/15
-- Main gestione lavorazioni Gunstock
-- Intestazioni
require( 'EgtBase')
_ENV = EgtProtectGlobal()
EgtEnableDebug( false)
local sBaseDir = EgtGetSourceDir()
EgtAddToPackagePath( sBaseDir .. 'LuaLibs\\?.lua')
EGB = require( 'EgtGunstockBase')
-----------------------------------------------------------------
-- *** Global Variables ***
-----------------------------------------------------------------
_G.GGD = {}
-----------------------------------------------------------------
-- *** Local Variables ***
-----------------------------------------------------------------
local m_sModName
local m_sMachName
local m_sAttr
local m_sSboName
local m_vParams = {} -- array di record : .sName, .dMin, .dMax, .dDef, .sVar
local m_vVals = {} -- array di valori dei parametri da file PEZ
local m_vVars = {}
local m_vRaw = {}
local m_vRawRef = {}
local m_vGunRef = {}
local m_vMachs = {} -- array di record : .sInfo, .sName, .nLay, .Ang, .PrepRot, [1]...[N] Tras o Rotaz
local m_dCoeffAlt = 1 -- coefficiente altezza per posizionamento due pezzi uno sopra l'altro
local m_vSboMove = {} -- parametri di movimento sbozzato : X, Y, R
-----------------------------------------------------------------
-- *** Local Constants ***
-----------------------------------------------------------------
local LEN_MAX_ASTA = 400
local LEN_MIN_RIFLE = 650
-----------------------------------------------------------------
-- *** MOD file parsing ***
-----------------------------------------------------------------
local function GetHeader()
local sLine = EGB.GetLine()
if not sLine then return false end
if not sLine:find( '#NOME', 1, true) then return false end
m_sModName = EgtTrim( sLine:gsub( '#NOME', ''))
sLine = EGB.GetLine()
if not sLine then return false end
if not sLine:find( '#MACH', 1, true) then return false end
m_sMachName = EgtTrim( sLine:gsub( '#MACH', ''))
sLine = EGB.GetLine()
if not sLine then return false end
if not sLine:find( '#ATTR', 1, true) then
EGB.UngetLine( sLine)
m_sAttr = ''
else
m_sAttr = EgtTrim( sLine:gsub( '#ATTR', ''))
end
return true
end
-----------------------------------------------------------------
local function GetParams()
m_vParams = {}
local sLine = EGB.GetLine()
if not sLine then return false end
-- facoltativo
if not sLine:find( '#PARAM', 1, true) then
EGB.UngetLine( sLine)
return true
end
while not sLine:find( '#END_PAR', 1, true) do
if not sLine:find( '#PARAM', 1, true) then return false end
local sParam = EgtTrim( sLine:gsub( '#PARAM', ''))
local vsTok = EgtSplitString( sParam, ' ')
local Param = {}
Param.sName = vsTok[1]
Param.dMin = tonumber( vsTok[2])
Param.dMax = tonumber( vsTok[3])
Param.dDef = tonumber( vsTok[4])
Param.sVar = vsTok[5]
table.insert( m_vParams, Param)
sLine = EGB.GetLine()
if not sLine then return false end
end
return true
end
-----------------------------------------------------------------
local function GetVars()
local sLine = EGB.GetLine()
if not sLine then return false end
while not sLine:find( '#END_VAR', 1, true) do
if not sLine:find( '#VAR', 1, true) then return false end
local sVar = EgtTrim( sLine:gsub( '#VAR', ''))
local vsTok = EgtSplitString( sVar, ' ')
local Var = {}
Var.sName = vsTok[1]
Var.sExpr = vsTok[2]
Var.dVal = nil
table.insert( m_vVars, Var)
sLine = EGB.GetLine()
if not sLine then return false end
end
return true
end
-----------------------------------------------------------------
local function GetRawDim()
local sLine = EGB.GetLine()
if not sLine then return false end
if not sLine:find( '#LUNG_GREZZO', 1, true) then return false end
m_vRaw.sLenExpr = EgtTrim( sLine:gsub( '#LUNG_GREZZO', ''))
m_vRaw.dLen = 0
sLine = EGB.GetLine()
if not sLine then return false end
if not sLine:find( '#LARG_GREZZO', 1, true) then return false end
m_vRaw.sLarExpr = EgtTrim( sLine:gsub( '#LARG_GREZZO', ''))
m_vRaw.dLar = 0
sLine = EGB.GetLine()
if not sLine then return false end
if not sLine:find( '#ALT_GREZZO', 1, true) then return false end
m_vRaw.sAltExpr = EgtTrim( sLine:gsub( '#ALT_GREZZO', ''))
m_vRaw.dAlt = 0
sLine = EGB.GetLine()
if not sLine then return false end
if not sLine:find( '#DOPPIO', 1, true) then
m_dCoeffAlt = 1
else
m_dCoeffAlt = EgtIf( EgtTrim( sLine:gsub( '#DOPPIO', '')) ~= '0', 2, 1)
sLine = EGB.GetLine()
if not sLine then return false end
end
if not sLine:find( '#SBO', 1, true) then
m_sSboName = nil
else
m_sSboName = EgtTrim( sLine:gsub( '#SBO', ''))
sLine = EGB.GetLine()
if not sLine then return false end
end
if not sLine:find( '#MUOVI_SBO', 1, true) then
m_vSboMove = nil
else
sLine = sLine:gsub( '#MUOVI_SBO', '')
local vsTok = EgtSplitStringPlus( sLine, 'XYR')
m_vSboMove.sX = '0' ; m_vSboMove.dX = 0
m_vSboMove.sY = '0' ; m_vSboMove.dY = 0
m_vSboMove.sR = '0' ; m_vSboMove.dR = 0
for i = 1, #vsTok do
local sId = string.sub( vsTok[i], 1, 1)
if sId == 'X' then
m_vSboMove.sX = EgtTrim( string.sub( vsTok[i], 2))
elseif sId == 'Y' then
m_vSboMove.sY = EgtTrim( string.sub( vsTok[i], 2))
elseif sId == 'R' then
m_vSboMove.sR = EgtTrim( string.sub( vsTok[i], 2))
end
end
sLine = EGB.GetLine()
if not sLine then return false end
end
return sLine:find( '#END_DIM_GREZZO', 1, true)
end
-----------------------------------------------------------------
local function GetStartStdMachining()
local sLine = EGB.GetLine()
if not sLine then return false end
return sLine:find( '#LAV_PIA_', 1, true)
end
-----------------------------------------------------------------
local function GetEndStdMachining()
local sLine = EGB.GetLine()
if not sLine then return true end
if sLine:find( '#END_PIA_', 1, true) then
return true
else
EGB.UngetLine( sLine)
return false
end
end
-----------------------------------------------------------------
local function ParseTras( sParam)
local Tras = {}
Tras.Type = 1
sParam = sParam:gsub( 'X', '')
sParam = sParam:gsub( 'Y', ',')
sParam = sParam:gsub( 'Z', ',')
local vsTok = EgtSplitString( sParam, ',')
if #vsTok < 3 then return nil end
Tras.sXExpr = vsTok[1]
Tras.sYExpr = vsTok[2]
Tras.sZExpr = vsTok[3]
Tras.dX = 0
Tras.dY = 0
Tras.dZ = 0
return Tras
end
-----------------------------------------------------------------
local function ParseRotaz( sParam)
local Rotaz = {}
Rotaz.Type = 2
local vsTok = EgtSplitString( sParam, ' ')
if #vsTok < 3 then return nil end
Rotaz.sAx = vsTok[1]
Rotaz.sMode = vsTok[2]
Rotaz.sAngExpr = vsTok[3]
Rotaz.dAng = 0
return Rotaz
end
-----------------------------------------------------------------
local function GetRawRef()
local sLine = EGB.GetLine()
if not sLine then return false end
if not sLine:find( '#RIF_GRE', 1, true) then return false end
sLine = EGB.GetLine()
if not sLine then return false end
while not sLine:find( '#END_RIF', 1, true) do
if sLine:find( '#TRAS', 1, true) then
local sParam = EgtTrim( sLine:gsub( '#TRAS', ''))
local Tras = ParseTras( sParam)
if not Tras then return false end
table.insert( m_vRawRef, Tras)
elseif sLine:find( '#ROTAZ', 1, true) then
local sParam = EgtTrim( sLine:gsub( '#ROTAZ', ''))
local Rotaz = ParseRotaz( sParam)
if not Rotaz then return false end
table.insert( m_vRawRef, Rotaz)
else
return false
end
sLine = EGB.GetLine()
if not sLine then return false end
end
return true
end
-----------------------------------------------------------------
local function GetGunRef()
local sLine = EGB.GetLine()
if not sLine then return false end
if not sLine:find( '#RIF_FUCILE', 1, true) then return false end
sLine = EGB.GetLine()
if not sLine then return false end
while not sLine:find( '#END_RIF', 1, true) do
if sLine:find( '#TRAS', 1, true) then
local sParam = EgtTrim( sLine:gsub( '#TRAS', ''))
local Tras = ParseTras( sParam)
if not Tras then return false end
table.insert( m_vGunRef, Tras)
elseif sLine:find( '#ROTAZ', 1, true) then
local sParam = EgtTrim( sLine:gsub( '#ROTAZ', ''))
local Rotaz = ParseRotaz( sParam)
if not Rotaz then return false end
table.insert( m_vGunRef, Rotaz)
else
return false
end
sLine = EGB.GetLine()
if not sLine then return false end
end
return true
end
-----------------------------------------------------------------
local function GetMachining( bBeretta)
-- inizio lavorazione
local sLine = EGB.GetLine()
if not sLine then return false end
if not sLine:find( '#LAV', 1, true) then return false end
local vMach = {}
vMach.sInfo = EGB.GetLastRem()
vMach.sName = EgtTrim( sLine:gsub( '#LAV', ''))
sLine = EGB.GetLine()
if not sLine then return false end
while not sLine:find( '#END_SING_LAV', 1, true) do
if sLine:find( '#TRAS', 1, true) then
local sParam = EgtTrim( sLine:gsub( '#TRAS', ''))
local Tras = ParseTras( sParam)
if not Tras then return false end
table.insert( vMach, Tras)
elseif sLine:find( '#ROTAZ', 1, true) then
local sParam = EgtTrim( sLine:gsub( '#ROTAZ', ''))
local Rotaz = ParseRotaz( sParam)
if not Rotaz then return false end
table.insert( vMach, Rotaz)
elseif sLine:find( '#ANG', 1, true) then
local sParam = EgtTrim( sLine:gsub( '#ANG', ''))
local vsTok = EgtSplitString( sParam, ' ')
if #vsTok < 2 then return false end
local Ang = {}
Ang.sR1Expr = vsTok[1]
Ang.dR1 = 0
Ang.sR2Expr = vsTok[2]
Ang.dR2 = 0
vMach.Ang = Ang
elseif sLine:find( '#TESTA_USCITA', 1, true) then
--
elseif sLine:find( '#PREP_ROT', 1, true) then
if not bBeretta then
local sParam = EgtTrim( sLine:gsub( '#PREP_ROT', ''))
local vsTok = EgtSplitString( sParam, ' ')
if #vsTok < 2 then return false end
local PrepRot = {}
PrepRot.sR1Expr = vsTok[1]
PrepRot.dR1 = 0
PrepRot.sR2Expr = vsTok[2]
PrepRot.dR2 = 0
PrepRot.sFeedExpr = vsTok[3]
PrepRot.dFeed = 0
vMach.PrepRot = PrepRot
end
else
return false
end
sLine = EGB.GetLine()
if not sLine then return false end
end
table.insert( m_vMachs, vMach)
return true
end
-----------------------------------------------------------------
-- *** Evaluate MOD expression ***
-----------------------------------------------------------------
local function AdjustFunction( sTmp, sOri, sNewS, sNewE)
local nEnd = sTmp:find( sOri, 1, true)
while nEnd do
-- ricerca corrispondente parentesi aperta
local nSta = nEnd - 1
local nCount = 1
while sTmp:sub(nSta,nSta) ~= '(' or nCount > 1 do
if sTmp:sub(nSta,nSta) == ')' then
nCount = nCount + 1
elseif sTmp:sub(nSta,nSta) == '(' then
nCount = nCount - 1
end
nSta = nSta - 1
if nSta == 0 then
return nil
end
end
-- sostituzioni
sTmp = sTmp:sub( 1, nEnd - 1) .. sNewE .. sTmp:sub( nEnd + sOri:len())
sTmp = sTmp:sub( 1, nSta - 1) .. sNewS .. sTmp:sub( nSta + 1)
-- nuova ricerca
nEnd = sTmp:find( sOri, 1, true)
end
return sTmp
end
-----------------------------------------------------------------
local function EvaluateExpr( sExpr)
local sTmp = sExpr or ''
-- sostituzione valori dei parametri
for i = 1, #m_vParams do
local Param = m_vParams[i]
if Param.dVal >= 0 then
sTmp = sTmp:gsub( '@'..Param.sName, EgtNumToString( Param.dVal, 3))
else
sTmp = sTmp:gsub( '@'..Param.sName, '('..EgtNumToString( Param.dVal, 3)..')')
end
end
-- sostituzione valori delle variabili
for i = 1, #m_vVars do
local Var = m_vVars[i]
if Var.dVal then
if Var.dVal >= 0 then
sTmp = sTmp:gsub( '@'..Var.sName, EgtNumToString( Var.dVal, 3))
else
sTmp = sTmp:gsub( '@'..Var.sName, '('..EgtNumToString( Var.dVal, 3)..')')
end
end
end
-- sostituzione costanti
sTmp = sTmp:gsub( 'P', 'pi')
-- sistemazione funzioni
sTmp = AdjustFunction( sTmp, ')Q', 'pow(', ',2)')
sTmp = AdjustFunction( sTmp, ')R', 'sqrt(', ')')
sTmp = AdjustFunction( sTmp, ')S', 'sin(', ')')
sTmp = AdjustFunction( sTmp, 'S)', 'sin(', ')')
sTmp = AdjustFunction( sTmp, ')C', 'cos(', ')')
sTmp = AdjustFunction( sTmp, 'C)', 'cos(', ')')
sTmp = AdjustFunction( sTmp, ')T', 'tan(', ')')
sTmp = AdjustFunction( sTmp, 'T)', 'tan(', ')')
sTmp = AdjustFunction( sTmp, ')AS', 'asin(', ')')
sTmp = AdjustFunction( sTmp, ')AC', 'acos(', ')')
sTmp = AdjustFunction( sTmp, ')AT', 'atan(', ')')
-- valutazione espressione
return EgtEvalNumExpr( sTmp)
end
-----------------------------------------------------------------
local function EvaluateVars()
for i = 1, #m_vVars do
-- eseguo valutazione
local Var = m_vVars[i]
Var.dVal = EvaluateExpr( Var.sExpr)
if not Var.dVal then
EGB.WriteErrLine( 'ERR=106\nErrore nella valutazione della variabile '.. Var.sName)
GGD.ERR = 106
return
end
-- ordino le valutate in ordine decrescente di lunghezza del nome
for j = 1, i do
for k = j + 1, i do
local VarJ = m_vVars[j]
local VarK = m_vVars[k]
if #( VarK.sName) > #( VarJ.sName) then
m_vVars[j], m_vVars[k] = m_vVars[k], m_vVars[j]
end
end
end
end
for i = 1, #m_vVars do
local Var = m_vVars[i]
EgtOutLog( 'Var = ' .. Var.sName .. ' ' .. Var.sExpr .. ' -> ' .. EgtNumToString( Var.dVal, 3))
end
end
-----------------------------------------------------------------
local function EvaluateRawDim()
m_vRaw.dLen = EvaluateExpr( m_vRaw.sLenExpr)
m_vRaw.dLar = EvaluateExpr( m_vRaw.sLarExpr)
m_vRaw.dAlt = EvaluateExpr( m_vRaw.sAltExpr)
if not m_vRaw.dLen or not m_vRaw.dLar or not m_vRaw.dAlt then
EGB.WriteErrLine( 'ERR=108\nErrore nella valutazione delle dimensioni del grezzo')
GGD.ERR = 108
return
end
EgtOutLog( 'RawLen = ' .. m_vRaw.sLenExpr .. ' -> ' .. EgtNumToString( m_vRaw.dLen, 3))
EgtOutLog( 'RawLar = ' .. m_vRaw.sLarExpr .. ' -> ' .. EgtNumToString( m_vRaw.dLar, 3))
EgtOutLog( 'RawAlt = ' .. m_vRaw.sAltExpr .. ' -> ' .. EgtNumToString( m_vRaw.dAlt, 3))
if m_vSboMove then
m_vSboMove.dX = EvaluateExpr( m_vSboMove.sX)
m_vSboMove.dY = EvaluateExpr( m_vSboMove.sY)
m_vSboMove.dR = EvaluateExpr( m_vSboMove.sR)
EgtOutLog( 'MoveSbo X = ' .. m_vSboMove.sX .. ' -> ' .. EgtNumToString( m_vSboMove.dX, 3))
EgtOutLog( 'MoveSbo Y = ' .. m_vSboMove.sY .. ' -> ' .. EgtNumToString( m_vSboMove.dY, 3))
EgtOutLog( 'MoveSbo R = ' .. m_vSboMove.sR .. ' -> ' .. EgtNumToString( m_vSboMove.dR, 3))
end
end
-----------------------------------------------------------------
local function WriteOutLineFromIni( sSec, sKey, sDef, sIniFile)
local sLine = EgtGetStringFromIni( sSec, sKey, sDef, sIniFile)
if #sLine == 0 then return end
EGB.WriteOutLine( sLine:gsub( '<br/>', '\n'))
end
-----------------------------------------------------------------
local function CncSplit( sCncFile, sSubDir)
local CncFh = io.open( sCncFile, 'r')
if not CncFh then
EgtOutLog( 'Errore nell\'apertura del file di input ' .. sCncFile)
return false
end
local SubFh
local sLine = CncFh:read( '*l')
while sLine do
if not string.find( sLine, '%', 1, true) then
if string.find( sLine, '(DIS,"CODICE=SUB', 1, true) then
if SubFh then
SubFh:close()
SubFh = nil
end
local sSubName = string.sub( sLine, 14, -3)
local sSubFile = sSubDir..sSubName
SubFh = io.open( sSubFile, 'w')
if not SubFh then
EgtOutLog( 'Errore nell\'apertura del file di output ' .. sSubFile)
CncFh:close()
return false
end
end
if SubFh then
-- se chiamata di testa
if string.find( sLine, 'T', 1, true) and string.find( sLine, 'M06', 1, true) then
-- leggo numero di testa
local vTok = EgtSplitStringPlus( sLine, 'TMD.')
local nT = 0
for i = 1, #vTok do
if vTok[i]:sub( 1, 1) == 'T' then
nT = tonumber( vTok[i]:sub( 2))
break
end
end
if nT == 0 then
EgtOutLog( 'Errore lettura richiamo testa nel file ' .. sCncFile..' alla linea '..sLine)
CncFh:close()
SubFh:close()
return false
end
-- verifico presenza richiamo correttore
local bCorr = false
for i = 1, #vTok do
if vTok[i]:sub( 1, 1) == '.' then
bCorr = true
break
end
end
-- conversione numero di testa
local vConv = { [31] = 11, [32] = 18, [33] = 17}
if vConv[nT] then nT = vConv[nT] end
-- scrivo nuove linee
local sT = EgtNumToString( nT)
if #sT == 1 then sT = '0'..sT end
SubFh:write( 'T'..sT..' M06\n')
if bCorr then
SubFh:write( 'h'..EgtNumToString( nT)..'\n')
end
-- altrimenti conversioni
else
sLine = sLine:gsub( 'T21', '')
sLine = sLine:gsub( 'T41', '')
sLine = sLine:gsub( 'T42', '')
sLine = sLine:gsub( 'T43', '')
sLine = sLine:gsub( 'M60', '')
sLine = sLine:gsub( 'U0', 'C0')
-- se non vuota, scrittura linea
if #sLine > 0 then
SubFh:write( sLine .. '\n')
end
end
end
end
sLine = CncFh:read( '*l')
end
if SubFh then SubFh:close() end
CncFh:close()
return true
end
-----------------------------------------------------------------
-- *** Read MOD params ***
-----------------------------------------------------------------
function GGD.ReadModParams()
-- Path completa file MOD
local sModFile = GGD.MODFILE
-- Apertura file MOD
if not EGB.OpenFile( sModFile) then
EgtOutLog( 'ERR=102\nErrore nell\'apertura del file ' .. sModFile)
GGD.ERR = 102
return
end
-- Recupero header modello
if not GetHeader() then
EgtOutLog( 'ERR=103\nErrore in lettura NOME o MACH')
GGD.ERR = 103
return
end
GGD.MODNAME = m_sModName
EgtOutLog( 'Name = ' .. m_sModName .. ' Mach = ' .. m_sMachName .. ' Attr = ' .. m_sAttr)
-- Recupero parametri (opzionali)
if not GetParams() then
EgtOutLog( 'ERR=104\nErrore in lettura PARAM')
GGD.ERR = 104
return
end
GGD.PARTOT = #m_vParams
for i = 1, #m_vParams do
local Param = m_vParams[i]
EgtOutLog( 'Param = '..Param.sName..' '..EgtNumToString( Param.dMin, 1)..' '..EgtNumToString( Param.dMax, 1)..
' '..EgtNumToString( Param.dDef, 1) .. ' ' .. Param.sVar)
local sParNameI = 'PARNAME' .. tostring(i)
GGD[sParNameI] = Param.sName
local sParMinI = 'PARMIN' .. tostring(i)
GGD[sParMinI] = Param.dMin
local sParMaxI = 'PARMAX' .. tostring(i)
GGD[sParMaxI] = Param.dMax
local sParDefI = 'PARDEF' .. tostring(i)
GGD[sParDefI] = Param.dDef
local sParVarI = 'PARVAR' .. tostring(i)
GGD[sParVarI] = Param.sVar
end
for i = 1, #m_vParams do
local Param = m_vParams[i]
Param.dVal = Param.dDef
end
-- Recupero variabili (come espressioni)
if not GetVars() then
EGB.WriteErrLine( 'ERR=105\nErrore in lettura VAR')
GGD.ERR = 105
return
end
-- Recupero dimensioni grezzo (come espressioni)
if not GetRawDim() then
EGB.WriteErrLine( 'ERR=107\nErrore in lettura DIM_GREZZO')
GGD.ERR = 107
return
end
-- Chiusura file MOD
EGB.CloseFile()
GGD.ERR = 0
end
-----------------------------------------------------------------
-- *** Read PEZ params ***
-----------------------------------------------------------------
function GGD.ReadPezParams()
-- Path completa file PEZ
local sPezFile = GGD.PEZFILE
-- Direttorio del modello
local sPezDir = EgtSplitPath( sPezFile)
local sModDir = sPezDir:sub( 1, -5) .. 'MOD\\'
--EgtOutLog( 'ModDir='..sModDir)
-- Apertura file PEZ
local PezFh = io.open( sPezFile, 'r')
if not PezFh then
EgtOutLog( 'ERR=117\nErrore nell\'apertura del file ' .. sPezFile)
GGD.ERR = 117
return
end
-- Lettura parametri generali
local sLine = PezFh:read( '*l')
-- identificativo, non interessa
sLine = PezFh:read( '*l')
if sLine then
GGD.DESCR = EgtTrim( sLine:gsub( 'Descrizione :', '') or '')
end
sLine = PezFh:read( '*l')
if sLine then
local sModFile = EgtTrim( sLine:gsub( 'Modello :', '' ) or '')
local _, sModName, sModExt = EgtSplitPath( sModFile)
GGD.MODFILE = sModDir .. sModName .. sModExt
else
EgtOutLog( 'ERR=118\nErrore nella lettura del nome del modello da ' .. sPezFile)
GGD.ERR = 118
return
end
sLine = PezFh:read( '*l')
if sLine then
GGD.DIMGREZ = EgtTrim( sLine:gsub( 'Dim. Grezzo :', '' ) or '')
end
-- Lettura parametri modello
GGD.ReadModParams()
if GGD.ERR ~= 0 then
return
end
-- Continuo lettura parametri generici pezzo
for i = 1, #m_vParams do
sLine = PezFh:read( '*l')
if sLine then
local sVal = EgtTrim( sLine:gsub( m_vParams[i].sName .. ' :', '' ) or '')
m_vParams[i].dVal = tonumber( sVal)
end
end
-- Chiusura file PEZ
PezFh:close()
-- Assegno valori letti
for i = 1, #m_vParams do
local sParValI = 'PARVAL' .. tostring(i)
GGD[sParValI] = m_vParams[i].dVal
end
GGD.ERR = 0
end
-----------------------------------------------------------------
-- *** Write PEZ params ***
-----------------------------------------------------------------
function GGD.WritePezParams()
-- Assegnazione parametri
for i = 1, #m_vParams do
local sParValI = 'PARVAL' .. tostring(i)
m_vParams[i].dVal = GGD[sParValI]
m_vVals[i] = m_vParams[i].dVal
end
-- Valutazione variabili
EvaluateVars()
if GGD.ERR ~= 0 then
return
end
-- Valutazione dimensioni grezzo
EvaluateRawDim()
if GGD.ERR ~= 0 then
return
end
GGD.DIMGREZ = EgtNumToString( m_vRaw.dLen, 3) .. ' x ' ..
EgtNumToString( m_vRaw.dLar, 3) .. ' x ' ..
EgtNumToString( m_vRaw.dAlt, 3)
-- Path completa file PEZ
local sPezFile = GGD.PEZFILE
local sPezDir, sPezName, sPezExt = EgtSplitPath( sPezFile)
-- Apertura file PEZ
local PezFh = io.open( sPezFile, 'w')
if not PezFh then
EgtOutLog( 'ERR=116\nErrore nell\'apertura del file ' .. sPezFile)
GGD.ERR = 116
return
end
-- Scrittura parametri
PezFh:write( 'Identificativo : ' .. sPezName .. '\n')
PezFh:write( 'Descrizione : ' .. GGD.DESCR .. '\n')
PezFh:write( 'Modello : ' .. GGD.MODFILE .. '\n')
PezFh:write( 'Dim. Grezzo : ' .. GGD.DIMGREZ .. '\n')
for i = 1, #m_vParams do
PezFh:write( m_vParams[i].sName .. ' : ' .. EgtNumToString( m_vParams[i].dVal, 3) .. '\n')
end
-- Chiusura file PEZ
PezFh:close()
GGD.ERR = 0
end
-----------------------------------------------------------------
-- *** GUNSTOCK creation with MOD parse ***
-----------------------------------------------------------------
function GGD.CreateGunstock()
local bOk = true
local sModFile = GGD.MODFILE
local sPezFile = GGD.PEZFILE
local sModDir, sModName, sModExt = EgtSplitPath( sModFile)
local sPezDir, sPezName, sPezExt = EgtSplitPath( sPezFile)
local sBaseDir = sPezDir:sub( 1, -5)
local sSboDir = sBaseDir .. 'SBO\\'
local sSubDir = sBaseDir .. 'SUB\\'
local sTmpDir = sBaseDir .. 'TMP\\'
local sErrFile = sPezDir .. sPezName .. '.txt'
local sCncFile = sBaseDir .. 'CNC\\' .. sPezName
local sCncMazFile = sCncFile..'.EIA'
local sNgeFile = sPezDir .. sPezName .. '.nge'
-- Messaggi di inizio
EgtOutLog( 'Pez = ' .. sPezFile .. ' Model = ' .. sModFile)
-- Cancello tutti i file di output
EgtEraseFile( sErrFile)
EgtEraseFile( sCncFile)
EgtEraseFile( sCncMazFile)
EgtEraseFile( sNgeFile)
-- Pulisco il direttorio temporaneo
EgtEmptyDirectory( sTmpDir)
-- Apertura file errori
if not EGB.OpenErrFile( sErrFile) then
EgtOutLog( '(ERR=101) Errore nell\'apertura del file degli errori' .. sErrFile)
GGD.ERR = 101
return
end
-- Apertura file MOD
if not EGB.OpenFile( sModFile) then
EGB.WriteErrLine( 'ERR=102\nErrore nell\'apertura del file ' .. sModFile)
GGD.ERR = 102
return
end
-- Recupero header modello
if not GetHeader() then
EGB.WriteErrLine( 'ERR=103\nErrore in lettura NOME o MACH')
GGD.ERR = 103
return
end
EgtOutLog( 'Name = ' .. m_sModName .. ' Mach = ' .. m_sMachName .. ' Attr = ' .. m_sAttr)
if not EgtSetCurrMachine( m_sMachName) then
EGB.WriteErrLine( 'ERR=119\nErrore impostando la macchina corrente ' .. m_sMachName)
GGD.ERR = 119
return
end
local sMachIni = EgtGetCurrMachineDir() .. '\\' .. m_sMachName .. '.ini'
local bTwoHeads = ( EgtGetStringFromIni( 'Gunstock', 'TwoHeads', '0', sMachIni) == '1')
local bAddM6ToT3x = ( EgtGetStringFromIni( 'Gunstock', 'AddM6ToT3x', '1', sMachIni) == '1')
local sType = EgtGetStringFromIni( 'Gunstock', 'Type', 'Cms', sMachIni)
local bBeretta = false
local bMazak = false
if sType == 'Beretta' then
bBeretta = true
elseif sType == 'Mazak' then
bMazak = true
end
-- In modalità Beretta recupero SUB dal file CNC omonimo di MOD
if bBeretta then
EgtEmptyDirectory( sSubDir)
local sCncFile = EgtChangePathExtension( sModFile, 'CNC')
if not CncSplit( sCncFile, sSubDir) then
EGB.WriteErrLine( 'ERR=120\nErrore in CNC file split')
GGD.ERR = 120
return
end
end
-- Recupero parametri (opzionali)
if not GetParams() then
EGB.WriteErrLine( 'ERR=104\nErrore in lettura PARAM')
GGD.ERR = 104
return
end
-- assegno i valori dal pezzo
for i = 1, #m_vParams do
local Param = m_vParams[i]
Param.dVal = m_vVals[i]
end
for i = 1, #m_vParams do
local Param = m_vParams[i]
EgtOutLog( 'Param = ' .. Param.sName ..
' ' .. EgtNumToString( Param.dMin, 1) .. ' ' .. EgtNumToString( Param.dMax, 1) ..
' ' .. EgtNumToString( Param.dDef, 1) .. ' ' .. Param.sVar ..
' -> ' .. EgtNumToString( Param.dVal, 1))
end
-- Recupero variabili e ne valuto le espressioni
if not GetVars() then
EGB.WriteErrLine( 'ERR=105\nErrore in lettura VAR')
GGD.ERR = 105
return
end
EvaluateVars()
if GGD.ERR ~= 0 then
return
end
-- Recupero dimensioni grezzo e ne valuto le espressioni
if not GetRawDim() then
EGB.WriteErrLine( 'ERR=107\nErrore in lettura DIM_GREZZO')
GGD.ERR = 107
return
end
EvaluateRawDim()
if GGD.ERR ~= 0 then
return
end
-- Inizio lavorazioni piane
if not GetStartStdMachining() then
EGB.WriteErrLine( 'ERR=109\nErrore in lettura LAV_PIA_1')
GGD.ERR = 109
return
end
-- Recupero posizione grezzo e ne valuto le espressioni
if not GetRawRef() then
EGB.WriteErrLine( 'ERR=110\nErrore in lettura RIF_GRE')
GGD.ERR = 110
return
end
local bRawRefEval = true
for i = 1, #m_vRawRef do
local RawRef = m_vRawRef[i]
if RawRef.Type == 1 then
RawRef.dX = EvaluateExpr( RawRef.sXExpr)
RawRef.dY = EvaluateExpr( RawRef.sYExpr)
RawRef.dZ = EvaluateExpr( RawRef.sZExpr)
if not RawRef.dX or not RawRef.dY or not RawRef.dZ then bRawRefEval = false end
elseif RawRef.Type == 2 then
RawRef.dAng = EvaluateExpr( RawRef.sAngExpr)
if ( not RawRef.dAng or
( RawRef.sAx ~= 'X' and RawRef.sAx ~= 'Y' and RawRef.sAx ~= 'Z') or
( RawRef.sMode ~= 'F' and RawRef.sMode ~= 'M')) then bRawRefEval = false end
end
end
if not bRawRefEval then
EGB.WriteErrLine( 'ERR=111\nErrore nella valutazione del riferimento del grezzo')
GGD.ERR = 111
return
end
EgtOutLog( 'RawRef')
for i = 1, #m_vRawRef do
local RawRef = m_vRawRef[i]
if RawRef.Type == 1 then
EgtOutLog( 'Tras = X'..EgtNumToString( RawRef.dX, 3)..' Y'..EgtNumToString( RawRef.dY, 3)..
' Z'..EgtNumToString( RawRef.dZ, 3))
elseif RawRef.Type == 2 then
EgtOutLog( 'Rotaz = '..RawRef.sAx..' '..RawRef.sMode..' '..EgtNumToString( RawRef.dAng, 3))
end
end
-- Recupero posizione finito e ne valuto le espressioni
if not GetGunRef() then
EGB.WriteErrLine( 'ERR=112\nErrore in lettura RIF_FUCILE')
GGD.ERR = 112
return
end
local bGunRefEval = true
for i = 1, #m_vGunRef do
local GunRef = m_vGunRef[i]
if GunRef.Type == 1 then
GunRef.dX = EvaluateExpr( GunRef.sXExpr)
GunRef.dY = EvaluateExpr( GunRef.sYExpr)
GunRef.dZ = EvaluateExpr( GunRef.sZExpr)
if not GunRef.dX or not GunRef.dY or not GunRef.dZ then bGunRefEval = false end
elseif GunRef.Type == 2 then
GunRef.dAng = EvaluateExpr( GunRef.sAngExpr)
if ( not GunRef.dAng or
( GunRef.sAx ~= 'X' and GunRef.sAx ~= 'Y' and GunRef.sAx ~= 'Z') or
( GunRef.sMode ~= 'F' and GunRef.sMode ~= 'M')) then bGunRefEval = false end
end
end
if not bGunRefEval then
EGB.WriteErrLine( 'ERR=113\nErrore nella valutazione del riferimento del pezzo')
GGD.ERR = 113
return
end
EgtOutLog( 'GunRef')
for i = 1, #m_vGunRef do
local GunRef = m_vGunRef[i]
if GunRef.Type == 1 then
EgtOutLog( 'Tras = X'..EgtNumToString( GunRef.dX, 3)..' Y'..EgtNumToString( GunRef.dY, 3)..
' Z'..EgtNumToString( GunRef.dZ, 3))
elseif GunRef.Type == 2 then
EgtOutLog( 'Rotaz = '..GunRef.sAx..' '..GunRef.sMode..' '..EgtNumToString( GunRef.dAng, 3))
end
end
-- Recupero dati di lavorazione
while not GetEndStdMachining() do
if not GetMachining( bBeretta) then
EGB.WriteErrLine( 'ERR=114\nErrore in lettura Lavorazione (linea ' .. tostring( EGB.GetLineNumber()) ..')')
GGD.ERR = 114
return
end
local bStdMachEval = true
local vMach = m_vMachs[#m_vMachs]
if vMach.Ang then
vMach.Ang.dR1 = EvaluateExpr( vMach.Ang.sR1Expr)
vMach.Ang.dR2 = EvaluateExpr( vMach.Ang.sR2Expr)
if not vMach.Ang.dR1 or not vMach.Ang.dR2 then bStdMachEval = false end
end
if vMach.PrepRot then
vMach.PrepRot.dR1 = EvaluateExpr( vMach.PrepRot.sR1Expr)
vMach.PrepRot.dR2 = EvaluateExpr( vMach.PrepRot.sR2Expr)
vMach.PrepRot.dFeed = EvaluateExpr( vMach.PrepRot.sFeedExpr)
if not vMach.PrepRot.dR1 or not vMach.PrepRot.dR2 or not vMach.PrepRot.dFeed then bStdMachEval = false end
end
for i = 1, #vMach do
local Data = vMach[i]
if Data.Type == 1 then
Data.dX = EvaluateExpr( Data.sXExpr)
Data.dY = EvaluateExpr( Data.sYExpr)
Data.dZ = EvaluateExpr( Data.sZExpr)
if not Data.dX or not Data.dY or not Data.dZ then bStdMachEval = false end
elseif Data.Type == 2 then
Data.dAng = EvaluateExpr( Data.sAngExpr)
if ( not Data.dAng or
( Data.sAx ~= 'X' and Data.sAx ~= 'Y' and Data.sAx ~= 'Z') or
( Data.sMode ~= 'F' and Data.sMode ~= 'M')) then bStdMachEval = false end
end
end
if not bStdMachEval then
EGB.WriteErrLine( 'ERR=115\nErrore nella valutazione della lavorazione '.. vMach.sName)
GGD.ERR = 115
return
end
EgtOutLog( 'Mach ' .. vMach.sName)
EgtOutLog( 'Info = ' .. vMach.sInfo)
if vMach.Ang then
EgtOutLog( 'Ang = '..EgtNumToString( vMach.Ang.dR1, 3)..' '..EgtNumToString( vMach.Ang.dR2, 3))
end
if vMach.PrepRot then
EgtOutLog( 'PrepRot = '..EgtNumToString( vMach.PrepRot.dR1, 3)..' '..EgtNumToString( vMach.PrepRot.dR2, 3)..
' '..EgtNumToString( vMach.PrepRot.dFeed, 3))
end
for i = 1, #vMach do
local Data = vMach[i]
if Data.Type == 1 then
EgtOutLog( 'Tras = X'..EgtNumToString( Data.dX, 3)..' Y'..EgtNumToString( Data.dY, 3)..
' Z'..EgtNumToString( Data.dZ, 3))
elseif Data.Type == 2 then
EgtOutLog( 'Rotaz = '..Data.sAx..' '..Data.sMode..' '..EgtNumToString( Data.dAng, 3))
end
end
end
-- Chiusura file MOD
EGB.CloseFile()
-- Creazione grezzo
EgtNewFile()
local Pz = EgtGroup( GDB_ID.ROOT)
EgtSetName( Pz, 'GUNSTOCK')
local Ly = EgtGroup( Pz)
EgtSetName( Ly, 'SOLID')
local Sol
-- se definito sbozzato
if m_sSboName then
-- Inserimento file
local sSboFile = sSboDir .. m_sSboName
if EgtInsertFile( sSboFile) then
-- Spostamento contorno nel layer del solido
local nPz = EgtGetLastPart()
local nLay = EgtGetFirstLayer( nPz)
local nId = EgtGetFirstInGroup( nLay or GDB_ID.NULL)
EgtRelocate( nId, Ly)
EgtErase( nPz)
-- Lo spiano a Z=0
EgtScale( nId, GLOB_FRM(), 1, 1, 0, GDB_RT.GLOB)
-- Eventuale rototraslazione
if m_vSboMove then
EgtRotate( nId, ORIG(), Z_AX(), m_vSboMove.dR, GDB_RT.GLOB)
EgtMove( nId, Vector3d( m_vSboMove.dX, m_vSboMove.dY, 0))
end
-- Creazione del solido
Sol = EgtSurfTmByRegionExtrusion( Ly, nId, Z_AX() * m_vRaw.dAlt * m_dCoeffAlt)
else
EgtOutLog( 'Error in InsertFile ' .. sSboFile)
end
end
-- creo parallelepipedo
if not Sol then
Sol = EgtSurfTmBox( Ly, ORIG(), Point3d( m_vRaw.dLen, -m_vRaw.dLar, 0), Point3d(10,0,0), m_vRaw.dAlt * m_dCoeffAlt, GDB_RT.GLOB)
end
EgtSetName( Sol, 'SOLID')
EgtSetColor( Sol, ORANGE())
EgtSetAlpha( Sol, 30)
-- calcolo delta tra Zero solido (sbozzato) e Zero teorico del grezzo
local b3Sol = EgtGetBBoxGlob( Sol, GDB_BB.EXACT)
local vtSolDelta = Vector3d( b3Sol:getMin():getX(), b3Sol:getMax():getY(), 0)
-- Calcolo riferimento del fucile
local frGun = Frame3d( GLOB_FRM())
for i = 1, #m_vGunRef do
local GunRef = m_vGunRef[i]
if GunRef.Type == 1 then
local vtMove = GunRef.dX * frGun:getVersX() + GunRef.dY * frGun:getVersY() + GunRef.dZ * frGun:getVersZ()
frGun:move( vtMove)
elseif GunRef.Type == 2 then
local vtAx
if GunRef.sAx == 'X' then
if GunRef.sMode == 'F' then vtAx = X_AX() else vtAx = frGun:getVersX() end
elseif GunRef.sAx == 'Y' then
if GunRef.sMode == 'F' then vtAx = Y_AX() else vtAx = frGun:getVersY() end
else -- 'Z'
if GunRef.sMode == 'F' then vtAx = Z_AX() else vtAx = frGun:getVersZ() end
end
frGun:rotate( frGun:getOrigin(), vtAx, GunRef.dAng)
end
end
-- Elaborazione delle lavorazioni
for i = 1, #m_vMachs do
-- lavorazione i-esima
local vMach = m_vMachs[i]
-- riferimento della lavorazione
local frMach = Frame3d( frGun)
for i = 1, #vMach do
local Data = vMach[i]
if Data.Type == 1 then
local vtMove = Data.dX * frMach:getVersX() + Data.dY * frMach:getVersY() + Data.dZ * frMach:getVersZ()
frMach:move( vtMove)
elseif Data.Type == 2 then
local vtAx
if Data.sAx == 'X' then
if Data.sMode == 'F' then vtAx = frGun:getVersX() else vtAx = frMach:getVersX() end
elseif Data.sAx == 'Y' then
if Data.sMode == 'F' then vtAx = frGun:getVersY() else vtAx = frMach:getVersY() end
else -- 'Z'
if Data.sMode == 'F' then vtAx = frGun:getVersZ() else vtAx = frMach:getVersZ() end
end
frMach:rotate( frMach:getOrigin(), vtAx, Data.dAng)
end
end
-- creo il layer
local Lm = EgtGroup( Pz, frMach)
EgtSetName( Lm, vMach.sName)
vMach.nLay = Lm
-- inserisco riferimento
local l = EgtFrame( Lm, Frame3d( ORIG()))
EgtSetName( l, 'Ref')
-- inserimento lavorazione (in ordine crecente di E)
local vSubst
local sSubName
local sSubExt
if bMazak then
sSubName = vMach.sName
sSubExt = '.EIA'
else
vSubst = { {'E1', '25.5'}, {'E2', '25.5'}, {'E101', '25.5'}, {'E102', '25.5'}}
sSubName = 'Sub'..vMach.sName
end
if not EGB.ImportCnc( sSubDir, sTmpDir, sSubName, sSubExt, vSubst, bAddM6ToT3x, vMach.nLay) then
EgtOutLog( 'Errore inserimento percorso di lavorazione ' .. vMach.sName)
end
end
EgtSetGridFrame()
-- Gestione macchina
local sMachineName = EgtGetCurrMachineName()
if not sMachineName then
EGB.WriteErrLine( 'ERR=201\nErrore : non esiste una macchina corrente')
GGD.ERR = 201
return
end
-- Gestione tavola macchina
local nMchId = EgtAddMachGroup( 'Mach01')
EgtSetTable( 'Tab')
local tabOri = EgtGetTableRef( 1)
-- Posizionamento delle morse per calcio
local nFix
if bBeretta then
if m_vRaw.dLen < LEN_MAX_ASTA then
nFix = EgtAddFixture( 'ViseH75_ASTA', Vector3d( 600, 345.1, 0), 0, m_vRaw.dAlt * m_dCoeffAlt)
else
nFix = EgtAddFixture( 'ViseH75_CALC', Vector3d( 600, 345.1, 0), 0, m_vRaw.dAlt * m_dCoeffAlt)
end
elseif bMazak then
nFix = EgtAddFixture( 'ViseNew', Vector3d( 350, 250, 0), 0, m_vRaw.dAlt * m_dCoeffAlt)
else
if m_vRaw.dLen < LEN_MIN_RIFLE then
nFix = EgtAddFixture( 'Vise2H85', Vector3d( 629, 350-1.49, 0), 0, m_vRaw.dAlt * m_dCoeffAlt)
else
nFix = EgtAddFixture( 'ViseRifle', Vector3d( 600, 350-1.49, 0), 0, m_vRaw.dAlt * m_dCoeffAlt)
end
end
-- Allargo area utile per movimenti grezzo per non avere problemi nelle fasi intermedie del movimento
EgtSetTableAreaOffset( 500, 500, 500, 500)
-- Posizionamento del grezzo in macchina
local ColA = Color3d( 255, 165, 0, 30)
local nRaw = EgtAddRawPartWithPart( Pz, Sol, 0, ColA) or GDB_ID.NULL
EgtSetStatus( Sol, GDB_ST.ON)
local b3Raw = EgtGetBBoxGlob( Sol, GDB_BB.EXACT)
local ptRawCen = EgtGetRawPartCenter( nRaw)
--EgtOutLog( 'RawBox=' .. tostring( b3Raw))
--EgtOutLog( 'RawCen=' .. tostring( ptRawCen))
local ptPosTL = Point3d( 0, b3Raw:getDimY(), 0)
local bRawPartOk = EgtMoveToCornerRawPart( nRaw, ptPosTL, MCH_CR.TL)
local ptRef = Point3d( b3Raw:getMin():getX() - ptRawCen:getX(), b3Raw:getMax():getY() - ptRawCen:getY(), 0) - vtSolDelta
local ptNewRef = Point3d( ptRef)
for i = 1, #m_vRawRef do
local RawRef = m_vRawRef[i]
if RawRef.Type == 1 then
local vtMove = Point3d( RawRef.dX, RawRef.dY, RawRef.dZ) - ( tabOri + ptPosTL - vtSolDelta)
EgtOutLog( 'MoveRawPart=' .. tostring( vtMove))
if not EgtMoveRawPart( nRaw, Point3d( RawRef.dX, RawRef.dY, RawRef.dZ) - ( tabOri + ptPosTL - vtSolDelta)) then
bRawPartOk = false
end
elseif RawRef.Type == 2 then
local vtAx
if RawRef.sAx == 'X' then
vtAx = X_AX()
elseif RawRef.sAx == 'Y' then
vtAx = Y_AX()
else -- 'Z'
vtAx = Z_AX()
end
if not EgtRotateRawPart( nRaw, vtAx, RawRef.dAng) then
bRawPartOk = false
end
ptNewRef:rotate( ORIG(), vtAx, RawRef.dAng)
end
end
-- per compensare rotazione su centroide anzichè su angolo TL
--EgtOutLog( 'CompRot : ptRef='..tostring( ptRef)..' ptNewRef='..tostring( ptNewRef))
if not EgtMoveRawPart( nRaw, ptRef - ptNewRef) then
bRawPartOk = false
end
if not bRawPartOk then
EGB.WriteErrLine( 'ERR=202\nErrore : in creazione o posizionamento grezzo')
GGD.ERR = 202
return
end
-- Generazione programma principale
if not EGB.OpenOutFile( EgtIf( bMazak, sCncMazFile, sCncFile)) then
EGB.WriteErrLine( 'ERR=203\nErrore nell\'apertura del file cnc ' .. EgtIf( bMazak, sCncMazFile, sCncFile))
GGD.ERR = 203
return
end
-- se macchina Mazak
if bMazak then
-- emissione intestazione
EGB.WriteOutLine( '(' .. EgtGetCurrMachineName():upper() .. ')')
EGB.WriteOutLine( '(' .. sPezName:upper() .. sPezExt:upper() .. '-' .. sModName:upper() .. sModExt:upper() .. ')')
EGB.WriteOutLine( '(' .. GGD.DESCR:upper() .. ')')
EGB.WriteOutLine( '(' .. m_sAttr:upper() .. ')')
-- emissioni iniziali opzionali
local sStart1Def = ''
if m_vRaw.dLen < LEN_MIN_RIFLE then
WriteOutLineFromIni( 'Gunstock', 'Start1', sStart1Def, sMachIni)
else
WriteOutLineFromIni( 'Gunstock', 'Start1_R', sStart1Def, sMachIni)
end
-- emissione inizializzazioni
EGB.WriteOutLine( '')
EGB.WriteOutLine( '(INIZIO)')
EGB.WriteOutLine( '#5241=0')
EGB.WriteOutLine( '#5242=0')
EGB.WriteOutLine( '#5243=0')
EGB.WriteOutLine( '#5244=0')
EGB.WriteOutLine( '#5245=0')
EGB.WriteOutLine( 'G0 G17 G40 G49 G80 G90 G94')
EGB.WriteOutLine( 'G0 G53 Z0')
EGB.WriteOutLine( 'G0 G53 X0')
EGB.WriteOutLine( 'G0 G53 Y0')
EGB.WriteOutLine( 'G0 G53 A0 C0')
EGB.WriteOutLine( 'G61.1')
-- seconde emissioni iniziali opzionali
local sStart2Def = ''
if m_vRaw.dLen < LEN_MIN_RIFLE then
WriteOutLineFromIni( 'Gunstock', 'Start2', sStart2Def, sMachIni)
else
WriteOutLineFromIni( 'Gunstock', 'Start2_R', sStart2Def, sMachIni)
end
-- emissione dei posizionamenti e dei richiami delle lavorazioni
if not EgtSetCalcTool( 'Calc', 'H1', 1) then
EGB.WriteErrLine( 'ERR=204\nErrore nell\'impostazione dell\'utensile di calcolo')
GGD.ERR = 204
return
end
local nNum = 0
local sTcPosPrev
local dPrevR1, dPrevR2 = 9999, 9999
for i = 1, #m_vMachs do
-- lavorazione i-esima
local vMach = m_vMachs[i]
local frMach = EgtFR( vMach.nLay, GDB_ID.ROOT)
-- emissione info di lavorazione
EGB.WriteOutLine( '')
nNum = nNum + 10
if vMach.sInfo then
EGB.WriteOutLine( 'N'..EgtNumToString(nNum,0)..' (' .. vMach.sInfo:upper() .. ')')
else
EGB.WriteOutLine( 'N'..EgtNumToString(nNum,0)..' ( *** )')
end
-- recupero dati utensile
local sTname = EgtGetInfo( vMach.nLay, 'TNAME')
local sTcPos = EgtGetInfo( vMach.nLay, 'TPOS')
if not sTcPos then
EGB.WriteOutLine( '(ERRORE MANCA TPOS IN ' .. vMach.sName .. ')')
EGB.WriteErrLine( 'ERR=211\nErrore manca TPOS in ' .. vMach.sName)
GGD.ERR = 211
return
end
-- se utensile cambiato
local bTdiff = ( sTcPos ~= sTcPosPrev)
if bTdiff then
-- posizionamento prima di cambio utensile
if i > 1 then
EGB.WriteOutLine( 'G0 G53 Z0')
EGB.WriteOutLine( 'G0 G53 Y-1000')
EGB.WriteOutLine( 'G0 G53 X0')
EGB.WriteOutLine( 'G0 G53 Y0')
end
-- emissione richiamo utensile
EGB.WriteOutLine( sTcPos .. ' M6' .. EgtIf( sTname, ' ('..EgtTrim( sTname)..')', ''))
end
-- preselezione prossimo utensile
if i < #m_vMachs then
local sTcPosNext = EgtGetInfo( m_vMachs[i+1].nLay, 'TPOS')
EGB.WriteOutLine( sTcPosNext or 'T0')
else
EGB.WriteOutLine( 'T0')
end
-- emissione speed
local sSpeed = EgtGetInfo( vMach.nLay, 'SPEED')
if not sSpeed then
EGB.WriteOutLine( '(ERRORE MANCA SPEED IN ' .. vMach.sName .. ')')
EGB.WriteErrLine( 'ERR=212\nErrore manca SPEED in ' .. vMach.sName)
GGD.ERR = 212
return
end
EGB.WriteOutLine( sSpeed)
-- se utensile cambiato, posizionamento dopo cambio utensile
if bTdiff then
EGB.WriteOutLine( 'G0 G53 Z0')
EGB.WriteOutLine( 'G0 G53 X0')
EGB.WriteOutLine( 'G0 G53 Y-1000')
end
-- calcolo angoli
local dNearR1, dNearR2 = 0, 0
if vMach.Ang then
dNearR1 = vMach.Ang.dR1
dNearR2 = vMach.Ang.dR2
end
local bRaOk, dR1, dR2 = EGB.GetAngMach( frMach:getVersZ(), dNearR1, dNearR2)
if not bRaOk then
EGB.WriteOutLine( '( ERRORE CALC ROTAX DI ' .. vMach.sName .. ')')
EGB.WriteErrLine( 'ERR=205\nErrore nel calcolo assi rotanti di ' .. vMach.sName)
GGD.ERR = 205
return
else
vMach.Ang.dR1N = dR1
vMach.Ang.dR2N = dR2
dPrevR1 = dR1
dPrevR2 = dR2
EGB.WriteOutLine( 'G55')
-- la posizione rimane inalterata
local dX = frMach:getOrigin():getX()
local dY = frMach:getOrigin():getY()
local dZ = frMach:getOrigin():getZ()
-- calcolo degli angoli di rotazione attorno agli assi fissi
local dA, dB, dC = GetFixedAxesRotABCFromFrame( frMach)
if not dA then
EGB.WriteOutLine( '; ERRORE CALC ANG DI ' .. vMach.sName)
EGB.WriteErrLine( 'ERR=207\nErrore nel calcolo ANG di ' .. vMach.sName)
GGD.Err = 207
return
end
-- emissione
EGB.WriteOutLine( '(ANGOLI ATTESI: A' .. EgtNumToString( dR2, 3) ..
' C' .. EgtNumToString( dR1, 3) ..')')
EGB.WriteOutLine( 'G68.2 P1 Q123 X' .. EgtNumToString( dX, 3) ..
' Y' .. EgtNumToString( dY, 3) ..
' Z' .. EgtNumToString( dZ, 3) ..
' I' .. EgtNumToString( dA, 3) ..
' J' .. EgtNumToString( dB, 3) ..
' K' .. EgtNumToString( dC, 3))
EGB.WriteOutLine( 'G53.1')
EGB.WriteOutLine( 'M98P' .. vMach.sName)
EGB.WriteOutLine( 'G69')
EGB.WriteOutLine( 'G49')
end
-- salvo utensile corrente come prossimo precedente
sTcPosPrev = sTcPos
end
-- emissione terminazione
EGB.WriteOutLine( '')
EGB.WriteOutLine( 'N9999 (FINE)')
EGB.WriteOutLine( 'G0 G53 Z0')
EGB.WriteOutLine( 'G0 G53 Y-1000')
EGB.WriteOutLine( 'G0 G53 X0')
EGB.WriteOutLine( 'G0 G53 Y0')
EGB.WriteOutLine( 'G0 G53 A0 C0')
EGB.WriteOutLine( 'M9')
EGB.WriteOutLine( 'M5')
EGB.WriteOutLine( 'T0 M6')
if #m_vMachs > 0 then
local sTcPosFirst = EgtGetInfo( m_vMachs[1].nLay, 'TPOS')
EGB.WriteOutLine( sTcPosFirst)
end
EGB.WriteOutLine( 'G64')
-- emissioni finali opzionali
-- emissione terminazione
local sEndDef = ''
if m_vRaw.dLen < LEN_MIN_RIFLE then
WriteOutLineFromIni( 'Gunstock', 'End', sEndDef, sMachIni)
else
WriteOutLineFromIni( 'Gunstock', 'End_R', sEndDef, sMachIni)
end
-- terminazione file
EGB.WriteOutLine( 'M30')
-- altrimenti macchina CMS in Beretta (tutto in un solo file)
elseif bBeretta then
-- posizione Origine1 rispetto Zero Macchina (punto intersezione assi rotanti)
local OffsX = -1598.00
local OffsY = -2126.10
local OffsZ = -670.65
-- emissione intestazione
EGB.WriteOutLine( '(DIS,"CODICE=PRG1")')
EGB.WriteOutLine( '; ' .. EgtGetCurrMachineName():upper())
EGB.WriteOutLine( '; ' .. sPezName:upper() .. sPezExt:upper() .. '-' .. sModName:upper() .. sModExt:upper())
EGB.WriteOutLine( '; ' .. GGD.DESCR:upper())
EGB.WriteOutLine( '; ' .. m_sAttr:upper())
local sStart1Def = 'M70<br/>"CICLI"'
if m_vRaw.dLen < LEN_MIN_RIFLE then
WriteOutLineFromIni( 'Gunstock', 'Start1', sStart1Def, sMachIni)
else
WriteOutLineFromIni( 'Gunstock', 'Start1_R', sStart1Def, sMachIni)
end
for i = 1, #m_vParams do
EGB.WriteOutLine( m_vParams[i].sVar .. '=' .. EgtNumToString( m_vParams[i].dVal, 3))
end
local sStart2Def = 'G79G0Z0<br/>G79X0Y0C0B0'
if m_vRaw.dLen < LEN_MIN_RIFLE then
WriteOutLineFromIni( 'Gunstock', 'Start2', sStart2Def, sMachIni)
else
WriteOutLineFromIni( 'Gunstock', 'Start2_R', sStart2Def, sMachIni)
end
EGB.WriteOutLine( '(UAO,0)')
EGB.WriteOutLine( '(UTO,0,X0,Y0,Z0)')
EGB.WriteOutLine( '(TCP)')
EGB.WriteOutLine( '(UPR)')
-- emissione dei posizionamenti e dei richiami delle lavorazioni
if not EgtSetCalcTool( 'Calc', 'H1', 1) then
EGB.WriteErrLine( 'ERR=204\nErrore nell\'impostazione dell\'utensile di calcolo')
GGD.ERR = 204
return
end
local dCalcLen = EgtTdbGetCurrToolParam( MCH_TP.LEN)
local nNum = 0
local dPrevR1, dPrevR2 = 9999, 9999
for i = 1, #m_vMachs do
-- lavorazione i-esima
local vMach = m_vMachs[i]
local frMach = EgtFR( vMach.nLay, GDB_ID.ROOT)
-- emissione info di lavorazione
EGB.WriteOutLine( ';')
nNum = nNum + 10
if vMach.sInfo then
EGB.WriteOutLine( 'N'..EgtNumToString(nNum,0)..' ; ' .. vMach.sInfo:upper())
else
EGB.WriteOutLine( 'N'..EgtNumToString(nNum,0)..' ; ***')
end
-- emissione info utensile
local sToolInfo = ''
local sTcPos = EgtGetInfo( vMach.nLay, 'TCPOS')
if sTcPos == 'T00' then
sToolInfo = sToolInfo .. 'T=PRECEDENTE'
elseif sTcPos then
sToolInfo = sToolInfo .. sTcPos:upper()
end
local sTcomp = EgtGetInfo( vMach.nLay, 'TCOMP')
if sTcomp then sToolInfo = sToolInfo .. ' H' .. sTcomp:upper() end
local sTname = EgtGetInfo( vMach.nLay, 'TNAME')
if sTname then sToolInfo = sToolInfo .. ' ' .. sTname:upper() end
EGB.WriteOutLine( '; ' .. sToolInfo)
-- calcolo angoli
local dNearR1, dNearR2 = 0, 0
if vMach.Ang then
dNearR1 = vMach.Ang.dR1
dNearR2 = vMach.Ang.dR2
end
local bRaOk, dR1, dR2 = EGB.GetAngMach( frMach:getVersZ(), dNearR1, dNearR2)
if not bRaOk then
EGB.WriteOutLine( '; ERRORE CALC ROTAX DI ' .. vMach.sName:upper())
EGB.WriteErrLine( 'ERR=205\nErrore nel calcolo assi rotanti di ' .. vMach.sName)
GGD.ERR = 205
return
else
vMach.Ang.dR1N = dR1
vMach.Ang.dR2N = dR2
if vMach.PrepRot and
( abs( dR1 - dPrevR1) > GEO.EPS_ANG_SMALL or abs( dR2 - dPrevR2) > GEO.EPS_ANG_SMALL) then
local sOut = 'G90G0'..'B'..EgtNumToString( dR1 - vMach.PrepRot.dR1, 3)..
'C'..EgtNumToString( dR2 - vMach.PrepRot.dR2, 3)
EGB.WriteOutLine( sOut)
sOut = 'G90G1'..'B'..EgtNumToString( dR1, 3)..'C'..EgtNumToString( dR2, 3)..
'F'..EgtNumToString( vMach.PrepRot.dFeed, 0)
EGB.WriteOutLine( sOut)
else
local sOut = 'G90G0'..'B'..EgtNumToString( dR1, 3)..'C'..EgtNumToString( dR2, 3)
EGB.WriteOutLine( sOut)
end
dPrevR1 = dR1
dPrevR2 = dR2
EGB.WriteOutLine( '(UAO,1)')
-- calcolo posizione
local bLa1Ok, _, dX1, dY1, dZ1 = EgtGetCalcPositions( frMach:getOrigin(), dR1, dR2)
if not bLa1Ok then
EGB.WriteOutLine( '; ERRORE CALC UTO DI ' .. vMach.sName:upper())
EGB.WriteErrLine( 'ERR=206\nErrore nel calcolo UTO di ' .. vMach.sName)
GGD.Err = 206
return
end
local dX = dX1
local dY = dY1
local dZ = dZ1 - dCalcLen
EGB.WriteOutLine( '(UTO,1,X' .. EgtNumToString( dX - OffsX, 3) ..
',Y' .. EgtNumToString( dY - OffsY, 3) ..
',Z' .. EgtNumToString( dZ - OffsZ, 3) .. ')')
-- calcolo rotazione
local bLa2Ok, _, dX2, dY2, dZ2 = EgtGetCalcPositions( frMach:getOrigin() + 100*frMach:getVersX(), dR1, dR2)
if not bLa2Ok then
EGB.WriteOutLine( '; ERRORE CALC ROT DI ' .. vMach.sName:upper())
EGB.WriteErrLine( 'ERR=207\nErrore nel calcolo ROT di ' .. vMach.sName)
GGD.Err = 207
return
end
local dAng = atan2( dY2 - dY1, dX2 - dX1)
if abs( dZ2 - dZ1) > GEO.EPS_SMALL then
EgtOutLog( 'Differenza sensibile in Z per ROT :'..EgtNumToString( dZ1, 6)..'/'..EgtNumToString( dZ2, 6))
end
EGB.WriteOutLine( 'G17')
EGB.WriteOutLine( '(AXO,-Z)')
EGB.WriteOutLine( '(ROT,' .. EgtNumToString( dAng, 3) .. ')')
EGB.WriteOutLine( '(GTO,SUB' .. vMach.sName .. ')')
EGB.WriteOutLine( '"END' .. vMach.sName .. '"')
EGB.WriteOutLine( '(UAO,0)')
EGB.WriteOutLine( '(ROT,0)')
end
end
-- emissione terminazione
local sEndDef = 'G79G0Z0<br/>G79X0Y0C0B0'
if m_vRaw.dLen < LEN_MIN_RIFLE then
WriteOutLineFromIni( 'Gunstock', 'End', sEndDef, sMachIni)
else
WriteOutLineFromIni( 'Gunstock', 'End_R', sEndDef, sMachIni)
end
EGB.WriteOutLine( 'M30')
-- accodamento subroutines
for i = 1, #m_vMachs do
-- lavorazione i-esima
local vMach = m_vMachs[i]
EGB.WriteOutLine( ';')
EGB.WriteOutLine( '"SUB' .. vMach.sName .. '"')
-- inserisco il corpo della sub
local sSubFile = sSubDir..'SUB'..vMach.sName
local SubFh = io.open( sSubFile, 'r')
if not SubFh then
EGB.WriteErrLine( 'ERR=213\nErrore mancata apertura subroutine '..sSubFile)
GGD.ERR = 213
return
end
local sLine = SubFh:read( '*l')
while sLine do
sLine = EgtTrimRight( sLine)
if #sLine > 0 then
EGB.WriteOutLine( sLine)
end
sLine = SubFh:read( '*l')
end
SubFh:close()
EGB.WriteOutLine( '(GTO,END' .. vMach.sName .. ')')
end
EGB.WriteOutLine( ';')
EGB.WriteOutLine( '; EOF')
-- altrimenti macchine CMS
else
-- emissione intestazione
EGB.WriteOutLine( '(DIS,"CODICE=PRG1")')
EGB.WriteOutLine( '; ' .. EgtGetCurrMachineName():upper())
EGB.WriteOutLine( '; ' .. sPezName:upper() .. sPezExt:upper() .. '-' .. sModName:upper() .. sModExt:upper())
EGB.WriteOutLine( '; ' .. GGD.DESCR:upper())
EGB.WriteOutLine( '; ' .. m_sAttr:upper())
local sStart1Def = 'M70<br/>"CICLI"'
if m_vRaw.dLen < LEN_MIN_RIFLE then
WriteOutLineFromIni( 'Gunstock', 'Start1', sStart1Def, sMachIni)
else
WriteOutLineFromIni( 'Gunstock', 'Start1_R', sStart1Def, sMachIni)
end
for i = 1, #m_vParams do
EGB.WriteOutLine( m_vParams[i].sVar .. '=' .. EgtNumToString( m_vParams[i].dVal, 3))
end
if ( bTwoHeads and #m_vMachs > 0) then
local sTcPos = EgtGetInfo( m_vMachs[1].nLay, 'TCPOS')
if not sTcPos then
EGB.WriteErrLine( 'ERR=208\nErrore non trovata posizione utensile in CU')
GGD.ERR = 208
return
end
local nTcPos = tonumber( sTcPos:sub( 2))
EGB.WriteOutLine( EgtIf( nTcPos <= 18, 'M41M52', 'M42M51'))
EGB.WriteOutLine( sTcPos .. ' M6')
end
local sStart2Def = 'G79G0Z0<br/>G79X-1500Y-1600C0B0'
if m_vRaw.dLen < LEN_MIN_RIFLE then
WriteOutLineFromIni( 'Gunstock', 'Start2', sStart2Def, sMachIni)
else
WriteOutLineFromIni( 'Gunstock', 'Start2_R', sStart2Def, sMachIni)
end
EGB.WriteOutLine( '(UAO,0)')
EGB.WriteOutLine( EgtIf( bTwoHeads, '(UOT,0,X0,U0,Y0,Z0,W0)', '(UOT,0,X0,Y0,Z0)'))
-- emissione dei posizionamenti e dei richiami delle lavorazioni
if not EgtSetCalcTool( 'Calc', 'H1', 1) then
EGB.WriteErrLine( 'ERR=204\nErrore nell\'impostazione dell\'utensile di calcolo')
GGD.ERR = 204
return
end
local dCalcLen = EgtTdbGetCurrToolParam( MCH_TP.LEN)
local nNum = 0
local dPrevR1, dPrevR2 = 9999, 9999
for i = 1, #m_vMachs do
-- lavorazione i-esima
local vMach = m_vMachs[i]
local frMach = EgtFR( vMach.nLay, GDB_ID.ROOT)
-- emissione info di lavorazione
nNum = nNum + 10
if vMach.sInfo then
EGB.WriteOutLine( 'N'..EgtNumToString(nNum,0)..' ; ' .. vMach.sInfo:upper())
else
EGB.WriteOutLine( 'N'..EgtNumToString(nNum,0)..' ; ***')
end
-- emissione info utensile
local sToolInfo = ''
local sTcPos = EgtGetInfo( vMach.nLay, 'TCPOS')
if sTcPos == 'T00' then
sToolInfo = sToolInfo .. 'T=PRECEDENTE'
elseif sTcPos then
sToolInfo = sToolInfo .. sTcPos:upper()
end
local sTcomp = EgtGetInfo( vMach.nLay, 'TCOMP')
if sTcomp then sToolInfo = sToolInfo .. ' H' .. sTcomp:upper() end
local sTname = EgtGetInfo( vMach.nLay, 'TNAME')
if sTname then sToolInfo = sToolInfo .. ' ' .. sTname:upper() end
EGB.WriteOutLine( '; ' .. sToolInfo)
-- calcolo angoli
local dNearR1, dNearR2 = 0, 0
if vMach.Ang then
dNearR1 = vMach.Ang.dR1
dNearR2 = vMach.Ang.dR2
end
local bRaOk, dR1, dR2 = EGB.GetAngMach( frMach:getVersZ(), dNearR1, dNearR2)
if not bRaOk then
EGB.WriteOutLine( '; ERRORE CALC ROTAX DI ' .. vMach.sName:upper())
EGB.WriteErrLine( 'ERR=205\nErrore nel calcolo assi rotanti di ' .. vMach.sName)
GGD.ERR = 205
return
else
vMach.Ang.dR1N = dR1
vMach.Ang.dR2N = dR2
if vMach.PrepRot and
( abs( dR1 - dPrevR1) > GEO.EPS_ANG_SMALL or abs( dR2 - dPrevR2) > GEO.EPS_ANG_SMALL) then
local sOut = 'G90G0'..'B'..EgtNumToString( dR1 - vMach.PrepRot.dR1, 3)..
'C'..EgtNumToString( dR2 - vMach.PrepRot.dR2, 3)
EGB.WriteOutLine( sOut)
sOut = 'G90G1'..'B'..EgtNumToString( dR1, 3)..'C'..EgtNumToString( dR2, 3)..
'F'..EgtNumToString( vMach.PrepRot.dFeed, 0)
EGB.WriteOutLine( sOut)
else
local sOut = 'G90G0'..'B'..EgtNumToString( dR1, 3)..'C'..EgtNumToString( dR2, 3)
EGB.WriteOutLine( sOut)
end
dPrevR1 = dR1
dPrevR2 = dR2
if bTwoHeads then EGB.WriteOutLine( 'G400') end
EGB.WriteOutLine( '(UAO,0)')
-- calcolo posizione
local bLa1Ok, _, dX1, dY1, dZ1 = EgtGetCalcPositions( frMach:getOrigin(), dR1, dR2)
if not bLa1Ok then
EGB.WriteOutLine( '; ERRORE CALC UOT DI ' .. vMach.sName:upper())
EGB.WriteErrLine( 'ERR=206\nErrore nel calcolo UOT di ' .. vMach.sName)
GGD.Err = 206
return
end
local dX = dX1
local dY = dY1
local dZ = dZ1 - dCalcLen
if bTwoHeads then
EGB.WriteOutLine( '(UOT,0,X' .. EgtNumToString( dX, 3) .. ',U' .. EgtNumToString( dX, 3) ..
',Y' .. EgtNumToString( dY, 3) ..
',Z' .. EgtNumToString( dZ, 3) .. ',W' .. EgtNumToString( dZ, 3) .. ')')
else
EGB.WriteOutLine( '(UOT,0,X' .. EgtNumToString( dX, 3) ..
',Y' .. EgtNumToString( dY, 3) ..
',Z' .. EgtNumToString( dZ, 3) .. ')')
end
-- calcolo rotazione
local bLa2Ok, _, dX2, dY2, dZ2 = EgtGetCalcPositions( frMach:getOrigin() + 100*frMach:getVersX(), dR1, dR2)
if not bLa2Ok then
EGB.WriteOutLine( '; ERRORE CALC URT DI ' .. vMach.sName:upper())
EGB.WriteErrLine( 'ERR=207\nErrore nel calcolo URT di ' .. vMach.sName)
GGD.Err = 207
return
end
local dAng = atan2( dY2 - dY1, dX2 - dX1)
if abs( dZ2 - dZ1) > GEO.EPS_SMALL then
EgtOutLog( 'Differenza sensibile in Z per URT :'..EgtNumToString( dZ1, 6)..'/'..EgtNumToString( dZ2, 6))
end
EGB.WriteOutLine( '(URT,' .. EgtNumToString( dAng, 3) .. ')')
EGB.WriteOutLine( '(CLS,SUB' .. vMach.sName .. ')')
EGB.WriteOutLine( '(UAO,0)')
EGB.WriteOutLine( '(URT,0)')
end
end
-- emissione terminazione
local sEndDef = 'G79G0Z0<br/>G79X-500Y-600C0B0<br/>M63<br/>M70<br/>(GTO,CICLI,@SINGOLO=0)'
if m_vRaw.dLen < LEN_MIN_RIFLE then
WriteOutLineFromIni( 'Gunstock', 'End', sEndDef, sMachIni)
else
WriteOutLineFromIni( 'Gunstock', 'End_R', sEndDef, sMachIni)
end
EGB.WriteOutLine( 'M30')
end
-- chiusura file CNC
EGB.CloseOutFile()
-- Inserimento lavorazioni equivalenti
for i = 1, #m_vMachs do
-- lavorazione i-esima
local vMach = m_vMachs[i]
-- aggiungo lavorazione
local MachId = EgtAddMachining( vMach.sName, 'Calc')
if not MachId then
EGB.WriteErrLine( 'ERR=302\nErrore nel caricamento della lavorazione Calc')
GGD.ERR = 302
return
end
-- assegno i percorsi di lavorazione (pescandoli nel layer)
local vGeo = {}
local nId = EgtGetFirstInGroup( vMach.nLay)
while nId do
local nType = EgtGetType( nId)
if nType == GDB_TY.CRV_LINE or nType == GDB_TY.CRV_ARC or
nType == GDB_TY.CRV_BEZ or nType == GDB_TY.CRV_COMPO then
table.insert( vGeo, nId)
end
nId = EgtGetNext( nId)
end
EgtSetMachiningGeometry( vGeo)
-- assegno eventuali Hint sugli angoli
if vMach.Ang then
local sNotes = 'Hint:B=' .. EgtNumToString( vMach.Ang.dR1N, 3) .. ',C=' .. EgtNumToString( vMach.Ang.dR2N, 3) .. ';'
EgtOutLog( sNotes)
EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes)
end
-- applico
-- per ora lascio all'utente
-- la disabilito
EgtSetOperationMode( MachId, false)
end
-- Salvo il progetto
if not EgtSaveFile( sNgeFile) then
EGB.WriteErrLine( 'ERR=301\nErrore nel salvataggio del progetto ' .. sNgeFile)
GGD.ERR = 301
return
end
-- Messaggi di conclusione (con chiusura file errori)
EGB.WriteErrLine( 'ERR=0\nCompletato con successo')
GGD.ERR = 0
end
-----------------------------------------------------------------
-- *** GUNSTOCK copy PartProgram (main + subs) ***
-----------------------------------------------------------------
function GGD.CopyPartProgram()
local bOk = true
local sPezFile = GGD.PEZFILE
local sPezDir, sPezName, sPezExt = EgtSplitPath( sPezFile)
local sBaseDir = sPezDir:sub( 1, -5)
local sCncFile = sBaseDir .. 'CNC\\' .. sPezName
local sDestDir = GGD.COPYDIR
-- Messaggi di inizio
EgtOutLog( 'Pez = ' .. sPezFile .. ' DestDir = ' .. sDestDir)
-- Verifico il direttorio destinazione
if not EgtExistsDirectory( sDestDir) then
GGD.ERR = 401
return
end
-- Copio il file main
if not EgtCopyFile( sCncFile, sDestDir..'\\'..sPezName) then
GGD.ERR = 402
return
end
-- Messaggi di conclusione
EgtOutLog( 'Completato con successo')
GGD.ERR = 0
end
Reference in New Issue View Git Blame Copy Permalink