From ab82e63af3f9b6d1ca78fb99b4b9f199db3dd601 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Fri, 6 Sep 2024 10:06:32 +0200 Subject: [PATCH 01/11] In BeamData aggiunte costanti MIN_HEIGHT_ADDED_CUTS, PRECUT_HEAD, PRECUT_TAIL, configurabili da offsets Ts3v7 --- Beam/BeamData.lua | 7 +++++-- Essetre-FAST.mlde | 3 ++- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/Beam/BeamData.lua b/Beam/BeamData.lua index 4c5ac8e..9b3cd47 100644 --- a/Beam/BeamData.lua +++ b/Beam/BeamData.lua @@ -69,9 +69,9 @@ local BeamData = { MAX_DIST_BH_FROM_BOTTOM = 395, -- massima distanza tra naso mandrino e sopra della trave senza collisione BH_MACHINE = false, -- flag che indica la tipologia di macchina configurata BlockHaus ANG_TRASM = false, -- presenza rinvio angolare per lavorazioni da sotto - MIN_HEIGHT_ADDED_CUTS = 199, -- altezza minima pezzo per effettuare tagli orizzontali aggiuntivi in testa e coda PRECUT_HEAD = true, -- flag abilitazione pretaglio grezzo a zero in testa - PRECUT_TAIL = true -- flag abilitazione pretaglio grezzo a zero in coda + PRECUT_TAIL = true, -- flag abilitazione pretaglio grezzo a zero in coda + MIN_HEIGHT_ADDED_CUTS = 400, -- altezza minima pezzo per effettuare tagli orizzontali aggiuntivi in testa e coda } -- Aggiornamento con dati da TechnoEssetre7 @@ -96,6 +96,9 @@ if EgtExistsFile( sData) then BeamData.DIM_STRIP_SMALL = Machine.Offsets.DIM_STRIP_SMALL or BeamData.DIM_STRIP_SMALL BeamData.DIM_TO_CENTER_STRIP = Machine.Offsets.DIM_TO_CENTER_STRIP or BeamData.DIM_TO_CENTER_STRIP BeamData.MAXDIAM_POCK_CORNER = Machine.Offsets.MAXDIAM_POCK_CORNER or BeamData.MAXDIAM_POCK_CORNER + if Machine.Offsets.PRECUT_HEAD_DISABLE then BeamData.PRECUT_HEAD = ( Machine.Offsets.PRECUT_HEAD_DISABLE == 0) end + if Machine.Offsets.PRECUT_TAIL_DISABLE then BeamData.PRECUT_TAIL = ( Machine.Offsets.PRECUT_TAIL_DISABLE == 0) end + if Machine.Offsets.MIN_HEIGHT_ADDED_CUTS then BeamData.MIN_HEIGHT_ADDED_CUTS = min( Machine.Offsets.MIN_HEIGHT_ADDED_CUTS, BeamData.MIN_HEIGHT_ADDED_CUTS) end end if Machine.Trave then BeamData.MIN_WIDTH = Machine.Trave.XMIN or BeamData.MIN_WIDTH diff --git a/Essetre-FAST.mlde b/Essetre-FAST.mlde index 2bd5f99..59dc761 100644 --- a/Essetre-FAST.mlde +++ b/Essetre-FAST.mlde @@ -62,11 +62,12 @@ -- 2024/09/02 AV ver 2.6i1 Allineamento con common ver. 2.6i1, Rimossi file "Common-" -- 2024/09/02 AV ver 2.6i2 Corretto file YML per compilare file "Common_" -- 2024/09/05 LM ver 2.6i3 In BeamData aggiunte costanti MIN_HEIGHT_ADDED_CUTS, PRECUT_HEAD, PRECUT_TAIL +-- 2024/09/06 LM ver 2.6i4 In BeamData le costanti sopra sono configurabili anche da offsets Ts3v7 require( 'EmtGenerator') EgtEnableDebug( false) -PP_VER = '2.6i3' +PP_VER = '2.6i4' MIN_MACH_VER = '2.5k1' MACH_NAME = 'Essetre-FAST' From 37952d64d4d170e87293ab66d238aad3ebaca2b4 Mon Sep 17 00:00:00 2001 From: "andrea.villa" Date: Mon, 16 Sep 2024 10:42:36 +0200 Subject: [PATCH 02/11] - Allineamento con common ver. 2.6i2 --- Common_FAST.NUM.mlpe | 4 ++-- Common_FAST.NUM_PLUS.mlpe | 4 ++-- Common_FAST.TPA.mlpe | 4 ++-- Common_FAST.mlpe | 2 +- Common_FAST.mlse | 4 ++-- Essetre-FAST.mlde | 3 ++- UpdateLog.txt | 4 ++++ Version.lua | 2 +- 8 files changed, 16 insertions(+), 11 deletions(-) diff --git a/Common_FAST.NUM.mlpe b/Common_FAST.NUM.mlpe index 8737654..02e1f11 100644 --- a/Common_FAST.NUM.mlpe +++ b/Common_FAST.NUM.mlpe @@ -627,7 +627,7 @@ function OnRapid() local MyZHome = EgtGetAxisHomePos( 'Z') local bZmax = ( #EMT.AUXSTR > 0 or EMT.TOOL ~= EMT.PREVTOOL or EMT.L3 > -1) -- se avevo motosega, torno in zona sicura senza ruotare assi rotanti - if EMT.PREVHEAD == 'H3' and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then + if ( EMT.PREVHEAD == 'H3' or EMT.TTOTLEN > 200) and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then local sOutPreMove = 'G101' .. ' X' .. EmtLenToString( -SafeXRotAxes, 3) .. ' Z' .. EmtLenToString( MyZHome, 3) .. ' B' .. EmtLenToString( EMT.R2pp, 3) .. ' C' .. EmtLenToString( EMT.R1pp, 3) .. ' EE' .. EgtIf( bZmax, '3', '4') .. EMT.PREVsEL .. EMT.PREVsER .. EMT.PREVsET .. EMT.PREVsES @@ -649,7 +649,7 @@ function OnRapid() local sES = ' ES'..EgtNumToString( EMT.S, 0) -- se carico motosega, ruoto in zona sicura prima di approcciare la lavorazione - if EMT.HEAD == 'H3' and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then + if ( EMT.HEAD == 'H3' or EMT.TTOTLEN > 200) and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then local sEEPreMove = ' EE' .. EgtIf( bZmax, '3', '4') local sOutPreMove = 'G101' .. ' X' .. EmtLenToString( -SafeXRotAxes, 3) .. ' Z' .. EmtLenToString( MyZHome, 3) .. EmtGetAxis( 'R2') .. EmtGetAxis( 'R1') .. sEE .. sEL .. sER .. sET .. sES diff --git a/Common_FAST.NUM_PLUS.mlpe b/Common_FAST.NUM_PLUS.mlpe index 89d04f3..23be211 100644 --- a/Common_FAST.NUM_PLUS.mlpe +++ b/Common_FAST.NUM_PLUS.mlpe @@ -668,7 +668,7 @@ function OnRapid() local MyZHome = EgtGetAxisHomePos( 'Z') local bZmax = ( #EMT.AUXSTR > 0 or EMT.TOOL ~= EMT.PREVTOOL or EMT.L3 > -1) -- se avevo motosega, torno in zona sicura senza ruotare assi rotanti - if EMT.PREVHEAD == 'H3' and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then + if ( EMT.PREVHEAD == 'H3' or EMT.TTOTLEN > 200) and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then local sOutPreMove = 'G101' .. ' X' .. EmtLenToString( -SafeXRotAxes, 3) .. ' Z' .. EmtLenToString( MyZHome, 3) .. ' B' .. EmtLenToString( EMT.R2pp, 3) .. ' C' .. EmtLenToString( EMT.R1pp, 3) .. ' EE' .. EgtIf( bZmax, '3', '4') .. EMT.PREVsEL .. EMT.PREVsER .. EMT.PREVsET .. EMT.PREVsES @@ -713,7 +713,7 @@ function OnRapid() local sES = ' ES'..EgtNumToString( EMT.S, 0) -- se carico motosega, ruoto in zona sicura prima di approcciare la lavorazione - if EMT.HEAD == 'H3' and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then + if ( EMT.HEAD == 'H3' or EMT.TTOTLEN > 200) and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then local sEEPreMove = ' EE' .. EgtIf( bZmax, '3', '4') local sOutPreMove = 'G101' .. ' X' .. EmtLenToString( -SafeXRotAxes, 3) .. ' Z' .. EmtLenToString( MyZHome, 3) .. EmtGetAxis( 'R2') .. EmtGetAxis( 'R1') .. sEE .. sEL .. sER .. sET .. sES diff --git a/Common_FAST.TPA.mlpe b/Common_FAST.TPA.mlpe index f147571..c3acb1d 100644 --- a/Common_FAST.TPA.mlpe +++ b/Common_FAST.TPA.mlpe @@ -647,7 +647,7 @@ function OnRapid() local MyZHome = EgtGetAxisHomePos( 'Z') local bZmax = ( #EMT.AUXSTR > 0 or EMT.TOOL ~= EMT.PREVTOOL or EMT.L3 > -1) -- se avevo motosega, torno in zona sicura senza ruotare assi rotanti - if EMT.PREVHEAD == 'H3' and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then + if ( EMT.PREVHEAD == 'H3' or EMT.TTOTLEN > 200) and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then local sOutPreMove = 'M101 P1=1' .. ' P2=' .. EmtLenToString( -SafeXRotAxes, 3) .. ' P3=' .. EmtLenToString( MyZHome, 3) .. ' P4=' .. EgtNumToString( EMT.R2pp, 3) .. ' P5=' .. EgtNumToString( EMT.R1pp, 3) .. ' P6=' .. EgtNumToString( EMT.PREVTCPOS, 3) .. ' P7=' .. EgtNumToString( EMT.PREVS, 0) .. @@ -663,7 +663,7 @@ function OnRapid() end -- se carico motosega, ruoto in zona sicura prima di approcciare la lavorazione - if EMT.HEAD == 'H3' and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then + if ( EMT.HEAD == 'H3' or EMT.TTOTLEN > 200) and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then local sOutPreMove = 'M101 P1=1' .. ' P2=' .. EmtLenToString( -SafeXRotAxes, 3) .. ' P3=' .. EmtLenToString( MyZHome, 3) .. ' P4=' .. EgtNumToString( EMT.R2, 3) .. ' P5=' .. EgtNumToString( EMT.R1, 3) .. ' P6=' .. AdjustTcPos( false) .. ' P7=' .. EgtNumToString( EMT.S, 0) .. diff --git a/Common_FAST.mlpe b/Common_FAST.mlpe index 20e370c..2594db7 100644 --- a/Common_FAST.mlpe +++ b/Common_FAST.mlpe @@ -752,7 +752,7 @@ function OnSimulMoveStart() -- con pezzi alti aggiorno gli assi rotanti prima di muovermi sopra il pezzo if not EMT.LOAD and EMT.MOVE == 0 and EMT.HB > BeamHeightForFixRot and EMT.FLAG2 == 1 then -- se motosega mi muovo a X di sicurezza per ruotare - if EMT.HEAD == 'H3'then + if EMT.HEAD == 'H3' or EMT.TOTLEN > 200 then SimulMoveAxes( 'X', SafeXRotAxes, MCH_SIM_STEP.RAPID, 'C', EMT.R1, MCH_SIM_STEP.COLLROT, 'B', EMT.R2, MCH_SIM_STEP.COLLROT) end end diff --git a/Common_FAST.mlse b/Common_FAST.mlse index d001976..c9437d9 100644 --- a/Common_FAST.mlse +++ b/Common_FAST.mlse @@ -917,7 +917,7 @@ function SpecCalcEncumbrance( vtTool, vtArm, ptMin, ptMax, bSaw, bChain, dTLen, elseif vtTool:getX() > -0.8667 then dHeadBack = 450 else - dHeadBack = 650 + dHeadBack = 660 end else dHeadBack = 50 + 0.5 * dTDiam * sqrt( 1 - vtTool:getX() * vtTool:getX()) @@ -1008,7 +1008,7 @@ function SpecCalcEncumbrance( vtTool, vtArm, ptMin, ptMax, bSaw, bChain, dTLen, elseif vtTool:getX() < 0.8667 then dHeadFront = 450 else - dHeadFront = 650 + dHeadFront = 660 end else dHeadFront = 50 + 0.5 * dTDiam * sqrt( 1 - vtTool:getX() * vtTool:getX()) diff --git a/Essetre-FAST.mlde b/Essetre-FAST.mlde index 59dc761..f015d40 100644 --- a/Essetre-FAST.mlde +++ b/Essetre-FAST.mlde @@ -63,11 +63,12 @@ -- 2024/09/02 AV ver 2.6i2 Corretto file YML per compilare file "Common_" -- 2024/09/05 LM ver 2.6i3 In BeamData aggiunte costanti MIN_HEIGHT_ADDED_CUTS, PRECUT_HEAD, PRECUT_TAIL -- 2024/09/06 LM ver 2.6i4 In BeamData le costanti sopra sono configurabili anche da offsets Ts3v7 +-- 2024/09/16 AV ver 2.6i5 Allineamento con common ver. 2.6i2 require( 'EmtGenerator') EgtEnableDebug( false) -PP_VER = '2.6i4' +PP_VER = '2.6i5' MIN_MACH_VER = '2.5k1' MACH_NAME = 'Essetre-FAST' diff --git a/UpdateLog.txt b/UpdateLog.txt index 8de1215..cf244d4 100644 --- a/UpdateLog.txt +++ b/UpdateLog.txt @@ -1,5 +1,9 @@ ==== Common_FAST Update Log ==== +Versione 2.6i2 (16/09/2024) +- (SIM-GEN) Se utensili più lunghi di 200mm, si ruota in home e poi si approccia il pezzo. Ticket#2038 +- (SIM-GEN) Aumentata distanza ingombro da 650mm a 660mm. In casi di utensile abbastanza lungo poteva andare in colisione. Ticket#2041 + Versione 2.6i1 (02/09/2024) - (MLDE-SIM-GEN) Rinominato file da "Common-" a "Common_" per uniformità con i file common delle altre macchine. Serve modifica a MLDE macchina. diff --git a/Version.lua b/Version.lua index 3596be2..75b5963 100644 --- a/Version.lua +++ b/Version.lua @@ -3,7 +3,7 @@ local InfoCommon_STD_PP = { NAME = 'Common_FAST', -- nome script PP standard - VERSION = '2.6i1', -- versione script + VERSION = '2.6i2', -- versione script MIN_MACH_VER_PP_COMMON = '2.5k1' -- versione minima kernel } From 6a68e0484a367cac1235404763d6f7e56eceffec Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Wed, 18 Sep 2024 12:59:46 +0200 Subject: [PATCH 03/11] - Modificato YAML per comunicazione versioni a LiMan. - Aggiunta PP_NVER, versione macchina in formato numerico. --- .gitlab-ci.yml | 71 ++++++++++++++++++++++++++++++++++++++++++++--- Essetre-FAST.mlde | 4 ++- 2 files changed, 70 insertions(+), 5 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index d3c4a56..456e30a 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -7,14 +7,21 @@ variables: NET_SHARE_Z: '\\10.74.82.201\Artifacts' NET_SHARE_S: '\\10.74.82.201\Scambio' NET_SHARE_R: '\\10.74.82.201\EgwTech' + NET_SHARE_H: '\\10.74.82.252\team drives' NET_USERQ: 'steamw\egalware' + NET_USER_SERVICES: 'steamw\services' MACH_VERS: '0.0.0.0' TEMP_PATH: 'C:\MachinesDeploy' MACHINES_PATH_R: 'R:\EgtData\Machines' DEST_MACHINES_PATH_R: 'R:\EgtData\Machines\zTestYAML' + DEST_MACHINES_PATH_H: 'H:\Beam & Wall - Essetre\test' SRC_PATH: '' BASE_PATH: '' TEST_PATH: '' + URL_VERSIONS_LOG: "https://liman.egalware.com/ELM.API/api/release/save" + MACH_VERS_NUM: '0.0.0.0' + CRITICAL_STRING: "#critical#" + #Note compilazione LUA: # lua54 -o bin\$FileName -s $FileName: -o = output, -s = NON include i debug symbols @@ -44,6 +51,22 @@ variables: SLEEP 2 net use R: /delete +# helper copia script verso drive condiviso +.ReplicaStor01: &ReplicaStor01 + - | + net use H: /delete + SLEEP 2 + net use H: $env:NET_SHARE_H /u:$env:NET_USER_SERVICES $SRVCS_PASSWD + echo "-----------------------" + echo " Copia macchina su stor01" + echo "-----------------------" + SLEEP 2 + $destinationPath = "$env:DEST_MACHINES_PATH_H\$env:MACH_NAME" + "\" + echo $destinationPath + ROBOCOPY "$env:BASE_PATH" "$destinationPath\" *.zip + SLEEP 2 + net use H: /delete + # helper copia script verso cartella di rete R:\ per develop .ReplicaR_DEV: &ReplicaR_DEV - | @@ -109,12 +132,22 @@ variables: echo "-----------------------" echo " Calcolo versione" echo "-----------------------" + + # calcolo versione formato stringa $fPath = "$env:MACH_NAME.mlde"; $vLine = Select-String -path $fPath -Pattern 'PP_VER'; $comp = $vLine -split "="; $env:MACH_VERS = $comp[1].Replace("'","").Trim() - # display versione - Write-Output $env:MACH_VERS; + # display versione formato stringa + Write-Output $env:MACH_VERS + + # calcolo versione formato numerico + $fPath = "$env:MACH_NAME.mlde"; + $vLine = Select-String -path $fPath -Pattern 'PP_NVER'; + $comp = $vLine -split "="; + $env:MACH_VERS_NUM = $comp[1].Replace("'","").Trim() + # display versione formato numerico + Write-Output $env:MACH_VERS_NUM # helper calcolo versione se develop .version-fix_DEV: &version-fix_DEV @@ -126,7 +159,7 @@ variables: $commitAuthor = $commitAuthor[0].Trim() $env:MACH_VERS = $commitAuthor # display versione - Write-Output $env:MACH_VERS; + Write-Output $env:MACH_VERS # helper creazione folders .folder-fix: &folder-fix @@ -158,6 +191,33 @@ variables: 7zip a -tzip $Target $Source Write-Output "called ZIP $Source --> $Target" +# helper invio notifica a log versioni online (LiMan) +.SendToVersionsLog: &SendToVersionsLog + - | + echo "-----------------------" + echo " Invio versione a log online" + echo "-----------------------" + $tags = "" + # se critico scrive tag + if ( $CI_COMMIT_MESSAGE | Select-String -Pattern $env:CRITICAL_STRING) { + $tags = "CRITICAL" + } + $body = + @{ + codInst = "EgalWare" + codApp = $env:MACH_NAME + uplAppId = "UpdateManager" + masterKey = $LiMan_Key + tipo = "Machine" + versNum = $env:MACH_VERS_NUM + versText = $env:MACH_VERS + releaseDate = (Get-Date).toString("yyyy-MM-ddTHH:mm:ss.fffZ") + relTags = $tags + } + $jsonBody = ConvertTo-Json -InputObject $body + echo $jsonBody + Invoke-WebRequest -Method Post -URI $env:URL_VERSIONS_LOG -ContentType "application/json" -Body $jsonBody -UseBasicParsing + # helper esecuzione test .RunTest: &RunTest @@ -186,6 +246,8 @@ LuaCompile:build: - *LuaCompile - *ZipClean - *ReplicaR + - *ReplicaStor01 + - *SendToVersionsLog LuaCompileDev:build: stage: build @@ -233,4 +295,5 @@ LuaCompileDev:build: # script: # - *LuaCompile # - *ZipClean -# - *ReplicaR \ No newline at end of file +# - *ReplicaR + diff --git a/Essetre-FAST.mlde b/Essetre-FAST.mlde index f015d40..0c40120 100644 --- a/Essetre-FAST.mlde +++ b/Essetre-FAST.mlde @@ -64,11 +64,13 @@ -- 2024/09/05 LM ver 2.6i3 In BeamData aggiunte costanti MIN_HEIGHT_ADDED_CUTS, PRECUT_HEAD, PRECUT_TAIL -- 2024/09/06 LM ver 2.6i4 In BeamData le costanti sopra sono configurabili anche da offsets Ts3v7 -- 2024/09/16 AV ver 2.6i5 Allineamento con common ver. 2.6i2 +-- 2024/09/18 LM ver 2.6i6 Modificato YAML per comunicazione versioni a LiMan. Aggiunta PP_NVER, versione in formato numerico. require( 'EmtGenerator') EgtEnableDebug( false) -PP_VER = '2.6i5' +PP_VER = '2.6i6' +PP_NVER = '2.6.9.6' MIN_MACH_VER = '2.5k1' MACH_NAME = 'Essetre-FAST' From 6cf09ac6a536e65532cc92f37631b4fcfa1ca6c5 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Wed, 18 Sep 2024 14:34:26 +0200 Subject: [PATCH 04/11] - YAML modifiche per calcolo versione numerica --- .gitlab-ci.yml | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 456e30a..3de2395 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -142,10 +142,13 @@ variables: Write-Output $env:MACH_VERS # calcolo versione formato numerico - $fPath = "$env:MACH_NAME.mlde"; - $vLine = Select-String -path $fPath -Pattern 'PP_NVER'; - $comp = $vLine -split "="; - $env:MACH_VERS_NUM = $comp[1].Replace("'","").Trim() + $fPath2 = "$env:MACH_NAME.mlde"; + echo fPath2 + $vLine2 = Select-String -path $fPath -Pattern 'PP_NVER'; + echo $vLine2 + $comp2 = $vLine -split "="; + echo $comp2 + $env:MACH_VERS_NUM = $comp2[1].Replace("'","").Trim() # display versione formato numerico Write-Output $env:MACH_VERS_NUM From c7e7afd93a81376b4be69b922508d4d0437fe915 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Wed, 18 Sep 2024 14:37:30 +0200 Subject: [PATCH 05/11] - YAML mofiche per calcolo versione numerica --- .gitlab-ci.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 3de2395..89d8670 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -143,10 +143,10 @@ variables: # calcolo versione formato numerico $fPath2 = "$env:MACH_NAME.mlde"; - echo fPath2 - $vLine2 = Select-String -path $fPath -Pattern 'PP_NVER'; + echo $fPath2 + $vLine2 = Select-String -path $fPath2 -Pattern 'PP_NVER'; echo $vLine2 - $comp2 = $vLine -split "="; + $comp2 = $vLine2 -split "="; echo $comp2 $env:MACH_VERS_NUM = $comp2[1].Replace("'","").Trim() # display versione formato numerico From 2acf712f2866fe6601a0e374daaff470861ab7a3 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Wed, 18 Sep 2024 14:41:17 +0200 Subject: [PATCH 06/11] - in YAML PP_VER e PP_NVER si cercano solo all'inizio della riga --- .gitlab-ci.yml | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 89d8670..a38ef83 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -135,20 +135,17 @@ variables: # calcolo versione formato stringa $fPath = "$env:MACH_NAME.mlde"; - $vLine = Select-String -path $fPath -Pattern 'PP_VER'; + $vLine = Select-String -path $fPath -Pattern '^PP_VER'; $comp = $vLine -split "="; $env:MACH_VERS = $comp[1].Replace("'","").Trim() # display versione formato stringa Write-Output $env:MACH_VERS # calcolo versione formato numerico - $fPath2 = "$env:MACH_NAME.mlde"; - echo $fPath2 - $vLine2 = Select-String -path $fPath2 -Pattern 'PP_NVER'; - echo $vLine2 - $comp2 = $vLine2 -split "="; - echo $comp2 - $env:MACH_VERS_NUM = $comp2[1].Replace("'","").Trim() + $fPath = "$env:MACH_NAME.mlde"; + $vLine = Select-String -path $fPath -Pattern '^PP_NVER'; + $comp = $vLine -split "="; + $env:MACH_VERS_NUM = $comp[1].Replace("'","").Trim() # display versione formato numerico Write-Output $env:MACH_VERS_NUM From be5d362383f6144f2b0340fa88337f487de0af6c Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Mon, 23 Sep 2024 11:41:53 +0200 Subject: [PATCH 07/11] update YAML per cambio percorsi --- .gitlab-ci.yml | 29 +++++++++++++++++------------ 1 file changed, 17 insertions(+), 12 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index a38ef83..b4625bc 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -2,6 +2,7 @@ variables: VERS_MAIN: '1.0' MACH_NAME: '' MACH_NAME_TEST: '' + MANUFACTURER: '' NEW_REL: '' NET_SHARE_X: '\\10.74.82.201\EgwTech' NET_SHARE_Z: '\\10.74.82.201\Artifacts' @@ -12,9 +13,8 @@ variables: NET_USER_SERVICES: 'steamw\services' MACH_VERS: '0.0.0.0' TEMP_PATH: 'C:\MachinesDeploy' - MACHINES_PATH_R: 'R:\EgtData\Machines' - DEST_MACHINES_PATH_R: 'R:\EgtData\Machines\zTestYAML' - DEST_MACHINES_PATH_H: 'H:\Beam & Wall - Essetre\test' + MACHINES_PATH_R: 'R:\EgtData\Machines_GIT' + DEST_MACHINES_PATH_H: 'H:' SRC_PATH: '' BASE_PATH: '' TEST_PATH: '' @@ -45,9 +45,10 @@ variables: echo "-----------------------" echo " Copia macchina su R" echo "-----------------------" - ROBOCOPY /MIR "$env:SRC_PATH" "$env:DEST_MACHINES_PATH_R\$env:MACH_NAME\" /XD "bin" - ROBOCOPY "$env:TEST_PATH" "$env:DEST_MACHINES_PATH_R\$env:MACH_NAME_TEST\" /E /XD "bin" - ROBOCOPY /MIR "$env:BASE_PATH" "$env:DEST_MACHINES_PATH_R\Deploy\$env:MACH_NAME\$env:MACH_VERS\" /XD "bin" /XD "$env:MACH_NAME_TEST" + $customerPathR = $env:MACHINES_PATH_R + "\" + $env:MANUFACTURER + ROBOCOPY /MIR "$env:SRC_PATH" "$customerPathR\$env:MACH_NAME\" /XD "bin" + ROBOCOPY "$env:TEST_PATH" "$customerPathR\$env:MACH_NAME_TEST\" /E /XD "bin" + ROBOCOPY /MIR "$env:BASE_PATH" "$customerPathR\Deploy\$env:MACH_NAME\$env:MACH_VERS\" /XD "bin" /XD "$env:MACH_NAME_TEST" SLEEP 2 net use R: /delete @@ -61,8 +62,8 @@ variables: echo " Copia macchina su stor01" echo "-----------------------" SLEEP 2 - $destinationPath = "$env:DEST_MACHINES_PATH_H\$env:MACH_NAME" + "\" - echo $destinationPath + $customerPathH = $env:DEST_MACHINES_PATH_H + "\" + $env:MANUFACTURER + "\test" + $destinationPath = "$customerPathH\$env:MACH_NAME" + "\" ROBOCOPY "$env:BASE_PATH" "$destinationPath\" *.zip SLEEP 2 net use H: /delete @@ -76,7 +77,8 @@ variables: echo "-----------------------" echo " Copia macchina su R - DEV" echo "-----------------------" - ROBOCOPY /MIR "$env:BASE_PATH" "$env:DEST_MACHINES_PATH_R\Deploy\$env:MACH_NAME\_DEV\$env:MACH_VERS\" /XD "bin" /XD "$env:MACH_NAME_TEST" + $customerPathR = $env:MACHINES_PATH_R + "\" + $env:MANUFACTURER + ROBOCOPY /MIR "$env:BASE_PATH" "$customerPathR\Deploy\$env:MACH_NAME\_DEV\$env:MACH_VERS\" /XD "bin" /XD "$env:MACH_NAME_TEST" SLEEP 2 net use R: /delete @@ -109,22 +111,25 @@ variables: echo "-----------------------" echo " Compilazione file *.lua 32/64bit" echo "-----------------------" - $FileList = Get-ChildItem("Common_*") + $FileList = Get-ChildItem * -Include( "*.mlpe", "*.mlse") ForEach ($File in $FileList) { $FileName = Split-Path $File -leaf lua54 -o $env:SRC_PATH\bin\$env:MACH_NAME\$FileName -s $FileName echo "lua54 -o bin\$FileName -s $FileName" } -# helper recupero nome macchina +# helper recupero nome macchina e costruttore .machName-fix: &machName-fix - | echo "-----------------------" - echo " Recupero nome macchina" + echo " Recupero nome macchina e costruttore" echo "-----------------------" $fileName = dir *.mlde $env:MACH_NAME = $fileName.BaseName $env:MACH_NAME_TEST = $env:MACH_NAME + ".TEST" + $comp = $fileName.BaseName -split "-" + $env:MANUFACTURER = $comp[0] + Write-Output $env:MANUFACTURER # helper calcolo versione .version-fix: &version-fix From f50132446bbbad1c23566d1310245e3e4a388688 Mon Sep 17 00:00:00 2001 From: "andrea.villa" Date: Mon, 23 Sep 2024 12:58:32 +0200 Subject: [PATCH 08/11] - Allineamento con common ver. 2.6i3 --- Common_FAST.mlse | 1011 ++++++++++++++++++++++++++++++++++++--------- Essetre-FAST.mlde | 5 +- UpdateLog.txt | 5 + Version.lua | 2 +- 4 files changed, 825 insertions(+), 198 deletions(-) diff --git a/Common_FAST.mlse b/Common_FAST.mlse index c9437d9..f4be8e6 100644 --- a/Common_FAST.mlse +++ b/Common_FAST.mlse @@ -1097,16 +1097,24 @@ function SpecCalcLoad( dPosT, dDistFront, dDistBack) local dNewVDelta = nil local dNewY = dPosT + TurnerOffs + dNewYDelta local vCmd = {} - EgtOutLog( ' *[L]', 1) - -- [L-1] - if dNewY - MaxY > 0 then - dNewYDelta = min( EMC.LB - MinJoin + AGG_LOAD, MaxY - dPosT - TurnerOffs) - EgtOutLog( ' *[L1]', 1) - end --[L-2] - if EMC.LB - dNewYDelta < MinJoin then - dNewYDelta = min( EMC.LB - MinJoin + AGG_LOAD, MaxY - dPosT - TurnerOffs) - EgtOutLog( ' *[L2]', 1) + + -- se flag attivo, vado a pinzare al massimo della corsa + if BD.FASTCLAMPING then + EgtOutLog( ' *[L]', 1) + -- [L-1] + if dNewY - MaxY > 0 then + dNewYDelta = min( EMC.LB - MinJoin + AGG_LOAD, MaxY - dPosT - TurnerOffs) + EgtOutLog( ' *[L1]', 1) + end --[L-2] + if EMC.LB - dNewYDelta < MinJoin then + dNewYDelta = min( EMC.LB - MinJoin + AGG_LOAD, MaxY - dPosT - TurnerOffs) + EgtOutLog( ' *[L2]', 1) + end + else + -- si pinza sempre a 1000mm massimo + dNewYDelta = min( dNewYDelta, 1000) end + -- Commento table.insert( vCmd, { 0, 'Loading'}) -- risalita testa a Zmax @@ -1131,9 +1139,71 @@ function SpecCalcLoad( dPosT, dDistFront, dDistBack) return vCmd end -- SpecAdjustLoad [L] + +--------------------------------------------------------------------- +function GetMachiningStartingPoint( idPath) + local idFirstObj = EgtGetFirstInGroup( idPath) + -- se esiste l'oggetto, recupero la coordinata del primo punto + if idFirstObj then + local vAxes = EmtGetAxesPos( idFirstObj) + if #vAxes > 0 then + return vAxes[1] + end + end + return nil +end + +--------------------------------------------------------------------- +local function AdjustPositionsForB( dNewYDelta, dNewVDelta, TCING, HCING, HOVM, bFixedDelta) + local REF_DIST = 1400 + local dYDelta = 0 + local dVDelta = 0 + -- incremento se possibile la distanza tra le due posizioni + if not bFixedDelta and ( dNewYDelta - dNewVDelta) < REF_DIST then + local dEffAddDist = ( REF_DIST - ( dNewYDelta - dNewVDelta)) / 2 + dYDelta = max( min( dEffAddDist, EMC.LB - dNewYDelta - MinJoin - TCING), 0) + dVDelta = max( min( dEffAddDist, dNewVDelta - MinJoin - HOVM - HCING), 0) + end + return dYDelta, dVDelta +end + +--------------------------------------------------------------------- +local function GetDeltaTol( dLenPresa, TCING, HCING, HOVM, Carr, bFixedDelta) + local dDeltaTolEff = DELTA_SIC + if Carr == 'Y' then + local dLenPreEff = dLenPresa - TCING + if dLenPreEff < MinJoin + DeltaTol then + dDeltaTolEff = max( DELTA_SIC, dLenPreEff - MinJoin + 10 * GEO.EPS_SMALL) + else + if BD.GO_FAST and BD.GO_FAST ~= 0 then + if bFixedDelta == false then + dDeltaTolEff = min( EMC.LB + 700, dLenPreEff, 3200) + else + dDeltaTolEff = 900 + end + else + dDeltaTolEff = DeltaTol + end + end + elseif Carr == 'V' then + local dLenPreEff = dLenPresa - HCING - HOVM + if dLenPreEff < MinJoin + DeltaTol then + dDeltaTolEff = max( DELTA_SIC, dLenPreEff - MinJoin + 10 * GEO.EPS_SMALL) + else + dDeltaTolEff = DeltaTol + end + end + return EgtIf( bFixedDelta, min( dDeltaTolEff, DELTA_TOL_FIXED), dDeltaTolEff) +end + --------------------------------------------------------------------- function SpecCalcCarriages( dDistFront, dDistBack, bFixedDelta, bFixedPos) + -- Abilitazione gestione vecchia dei riposizionamenti + if not BD.NEWCLAMPING then + return SpecCalcCarriagesOLD( dDistFront, dDistBack, bFixedDelta, bFixedPos) + end + local MinFrontJoin = MinJoin + EMC.HCING + EMC.HOVM local MinBackJoin = MinJoin + EgtIf( IsMid2Phase( EMC.PHASE) or IsEnd2Phase( EMC.PHASE), EMC.TCING, 0) local MyMinOther = MinOther + EgtIf( EMC.CNT == 1, AGG_LOAD, 0) @@ -1148,46 +1218,85 @@ function SpecCalcCarriages( dDistFront, dDistBack, bFixedDelta, bFixedPos) ' Front=' .. EgtNumToString( dDistFrontEff, 1) .. '/' .. EgtNumToString( MinFrontJoin, 1) .. ' Fixed : Delta=' .. EgtIf( bFixedDelta, 'T', 'F') .. ' Pos=' .. EgtIf( bFixedPos, 'T', 'F'), 3) + local dPosT = EMC.TPOS + local dYDelta = EMC.YDELTA + local dVDelta = EMC.VDELTA + local dNewPosT + -- se sono già settati, non calcolo posizione finale + if not EMC.YDELTANEXT and not EMC.VDELTANEXT then + dNewPosT = GetMachiningStartingPoint( EMC.PATHID) + end + local dNewYDelta = nil + local dNewVDelta = nil + -- [A] se posso mettere solo carrello Y if dDistFrontEff < MinFrontJoin and dDistBackEff > MinBackJoin - GEO.EPS_SMALL then + -- se Y non era in presa, mi ricalcolo la posizione + if not dYDelta then + dYDelta = dVDelta + ( MinY - MaxV) + end + dNewYDelta = EMC.LB - dDistBackEff + -- verifico se posso lasciare la morsa in posizione + local dYDeltaTol = GetDeltaTol( EMC.LB - dNewYDelta, EMC.TCING, EMC.HCING, EMC.HOVM, 'Y') + local bYDeltaS = ( dNewYDelta < dYDelta - dYDeltaTol or dNewYDelta > dYDelta + DELTA_SIC) + if bYDeltaS then + dNewYDelta = dNewYDelta + dYDeltaTol/2 + else + dNewYDelta = dYDelta + end - local dPosT = EMC.TPOS - local dYDelta = EMC.YDELTA - local dVDelta = EMC.VDELTA - - local dNewPosT = nil - local dNewYDelta = EMC.LB - dDistBackEff - local dNewVDelta = nil - - return SpecAdjustCarriages( dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos) - + dNewVDelta = nil -- [B] se altrimenti posso mettere entrambi i carrelli Y e V - elseif dDistBackEff > MinBackJoin - GEO.EPS_SMALL and - dDistFrontEff > MinFrontJoin - GEO.EPS_SMALL then - - local dPosT = EMC.TPOS - local dYDelta = EMC.YDELTA - local dVDelta = EMC.VDELTA - - local dNewPosT = nil - local dNewYDelta = EMC.LB - dDistBackEff - local dNewVDelta = dDistFrontEff - - return SpecAdjustCarriages( dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos) + elseif dDistBackEff > MinBackJoin - GEO.EPS_SMALL and dDistFrontEff > MinFrontJoin - GEO.EPS_SMALL then + -- se Y non era in presa, mi ricalcolo la posizione + if not dYDelta then + dYDelta = dVDelta + ( MinY - MaxV) + end + -- se V non era in presa, mi ricalcolo la posizione + if not dVDelta then + dVDelta = dYDelta - ( MinY - MaxV) + end + + dNewYDelta = EMC.LB - dDistBackEff + dNewVDelta = dDistFrontEff + + -- incremento la distanza tra le due posizioni ( se abilitato e possibile) + local dYDeltaAgg, dVDeltaAgg = AdjustPositionsForB( dNewYDelta, dNewVDelta, EMC.TCING, EMC.HCING, EMC.HOVM, bFixedDelta) + -- tolleranze + local dYDeltaTol = dYDeltaAgg + GetDeltaTol( EMC.LB - dNewYDelta - dYDeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'Y', bFixedDelta) + local dVDeltaTol = dVDeltaAgg + GetDeltaTol( dNewVDelta - dVDeltaAgg, EMC.TCING, EMC.HCING, EMC.HOVM, 'V', bFixedDelta) + -- definisco criteri per movimenti 'significativi' in base alle 'nuove' tolleranze + local bYDeltaS = ( dNewYDelta < dYDelta - dYDeltaTol or dNewYDelta > dYDelta + DELTA_SIC) + local bVDeltaS = ( dNewVDelta > dVDelta + dVDeltaTol or dNewVDelta < dVDelta - DELTA_SIC) + -- reimposto i delta finali in caso di spostamenti richiesti significativi, tenuto conto delle tolleranze + if bYDeltaS then + dNewYDelta = dNewYDelta + dYDeltaTol / 2 + else + dNewYDelta = dYDelta + end + if bVDeltaS then + dNewVDelta = dNewVDelta - dVDeltaTol / 2 + else + dNewVDelta = dVDelta + end -- [C] se altrimenti posso mettere solo carrello V elseif dDistBackEff < MinBackJoin and dDistFrontEff > MinFrontJoin - GEO.EPS_SMALL then - - local dPosT = EMC.TPOS - local dYDelta = EMC.YDELTA - local dVDelta = EMC.VDELTA - - local dNewPosT = nil - local dNewYDelta = nil - local dNewVDelta = dDistFrontEff - - return SpecAdjustCarriages( dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos) - + -- se V non era in presa, mi ricalcolo la posizione + if not dVDelta then + dVDelta = dYDelta - ( MinY - MaxV) + end + dNewVDelta = dDistFrontEff + -- verifico se posso lasciare la morsa in posizione + local dVDeltaTol = GetDeltaTol( dNewVDelta, EMC.TCING, EMC.HCING, EMC.HOVM, 'V', bFixedDelta) + local bVDeltaS = ( dNewVDelta > dVDelta + dVDeltaTol or dNewVDelta < dVDelta - DELTA_SIC) + -- reimposto i delta finali in caso di spostamenti richiesti significativi, tenuto conto delle tolleranze + if bVDeltaS then + dNewVDelta = dNewVDelta - dVDeltaTol/2 + else + dNewVDelta = dVDelta + end + dNewYDelta = nil -- altrimenti errore else if EgtGetDebugLevel() < 3 then @@ -1199,6 +1308,16 @@ function SpecCalcCarriages( dDistFront, dDistBack, bFixedDelta, bFixedPos) return {} end + -- salvo valori finali + EMC.YDELTANEXT = dNewYDelta + EMC.VDELTANEXT = dNewVDelta + + local vCmd = {} + SpecAdjustCarriages( vCmd, dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos) + + SpecOutputCNT() + return vCmd + end --------------------------------------------------------------------- @@ -1371,8 +1490,662 @@ function SpecCalcPreRot() end --------------------------------------------------------------------- -function SpecAdjustCarriages( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) +function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) + local dYPosA, dVPosA, dTPosA + -- se primo scambio + local MyMinY = EgtIf( EMC.CNT == 1, MinY + AGG_LOAD, MinY) + + -- se pinza non in presa, setto offset minimo in base all'altra che sta pinzando + if not dYDeltaI then + dYDeltaI = dVDeltaI + ( MyMinY - MaxV) + end + if not dVDeltaI then + dVDeltaI = dYDeltaI - ( MyMinY - MaxV) + end + if not dYDeltaF then + dYDeltaF = dVDeltaF + ( MyMinY - MaxV) + end + if not dVDeltaF then + dVDeltaF = dYDeltaF - ( MyMinY - MaxV) + end + + -- se non c'è posizione finale, è lo scarico. Allora setto al minimo della morsa allo scarico. + if not dTPosF then + dTPosF = MaxV - dVDeltaF + end + + -- verifico che le morse non sono in posizione + if abs( dYDeltaF - dYDeltaI) > 10 * GEO.EPS_SMALL or abs( dVDeltaF - dVDeltaI) > 10 * GEO.EPS_SMALL or + EMC.YDELTA ~= EMC.YDELTANEXT or EMC.VDELTA ~= EMC.VDELTANEXT then + if #vCmd == 0 then + table.insert( vCmd, { 0, 'Clamp repositioning'}) + -- risalita testa a Zmax + local bZmaxOk = EnsureZmax( bZmaxOk, vCmd) + end + + -- reset contatore primo riposizionamento con compensazione lettura laser + EMC.CNT = nil + + -- ricavo posizione delle morse nelle corse + local dYPosI = max( MyMinY, dTPosI + dYDeltaI) + local dVPosI = min( MaxV, dTPosI + dVDeltaI) + + -- calcolo eventuale massimo riposizionamento con passo del pellegrino. + -- al primo step si calcolano posizioni attuali delle morse + -- al secondo step si considerano le corse massime + local dMaxMovePilgrimStepDoubleClamp, dMaxMovePilgrimStepSingleClampY, dMaxMovePilgrimStepSingleClampV + if not EMC.PILGRIMSTEP then + dMaxMovePilgrimStepDoubleClamp = MaxY - dYPosI - MinV + dVPosI + dMaxMovePilgrimStepSingleClampY = MaxY - dYPosI + dMaxMovePilgrimStepSingleClampV = - MinV + dVPosI + else + dMaxMovePilgrimStepDoubleClamp = MaxY - MinY - MinV + MaxV + dMaxMovePilgrimStepSingleClampY = MaxY - MinY + dMaxMovePilgrimStepSingleClampV = - MinV + MaxV + end + + -- calcolo delta spostamento trave + local dDeltaBeam = dTPosI - dTPosF -- se positivo, la trave si sposta dal carico allo scarico + local dBeamMove = 0 + + -- PRIMO CASO -> SCAMBIO DIRETTO : V IN POSIZIONE FINALE + -- V può andare in posizione direttamente se : + -- * rispetta interasse minimo con Y + -- * deve effettivamente spostarsi + -- * non si arriva da gestione passo del pellegrino + -- * se riesce a raggiungere la posizione con le corse a disposizione per come sono posizionate le morse attualmente + if ( dYDeltaI - dVDeltaF) >= MyMinY - MaxV and abs( dVDeltaF - dVDeltaI) > 10 * GEO.EPS_SMALL and not EMC.PILGRIMSTEP and + ( dVDeltaF - dVDeltaI > MinV - dVPosI + MyMinY - dYPosI) then + table.insert( vCmd, { 0, 'Direct-V-Y'}) + -- se l'altra morsa non era in presa, vado a pinzare il pezzo + if not EMC.YDELTA then + dYPosA = MyMinY + dTPosA = MyMinY - dYDeltaI + dVPosA = dTPosA + dVDeltaI + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + dTPosI = dTPosA + dVPosI = dVPosA + table.insert( vCmd, { 11, 1}) + end + -- se spostando morsa diretto esco dalle corse, calcolo di quanto devo muovere la trave (cioè l'altra morsa) come minimo + -- se non era ingaggiata, vado al suo minimo + if not EMC.VDELTA then + dBeamMove = -( MaxV - dVDeltaF - dTPosI) + -- se spostamento verso lo scarico + elseif ( dVPosI + ( dVDeltaF - dVDeltaI)) < MinV then + dBeamMove = dVPosI + ( dVDeltaF - dVDeltaI) - MinV + -- se spostamento verso il carico + elseif ( dVPosI + ( dVDeltaF - dVDeltaI)) > MaxV then + dBeamMove = dVPosI + ( dVDeltaF - dVDeltaI) - MaxV + end + + table.insert( vCmd, { 12, 0}) + + dTPosA = dTPosI - dBeamMove + dYPosA = dTPosA + dYDeltaI + dVPosA = dTPosA + dVDeltaF + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + + -- la morsa allo scarico è adesso in posizione + dVDeltaI = dVDeltaF + dTPosI = dTPosA + + -- blocco la morsa + table.insert( vCmd, { 12, 1}) + + -- imposto i nuovi parametri di aggancio + if EMC.YDELTANEXT and EMC.VDELTANEXT then + -- porto assi alla loro posizione finale + if abs( dYDeltaF - dYDeltaI) > 10 * GEO.EPS_SMALL then + table.insert( vCmd, { 11, 0}) + dTPosA = dTPosF + dYPosA = dTPosF + dYDeltaF + dVPosA = dTPosF + dVDeltaF + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 11, 1}) + -- la morsa al carico è adesso in posizione + dYDeltaI = dYDeltaF + end + table.insert( vCmd, { 21, dYDeltaF, dVDeltaF}) + elseif EMC.YDELTANEXT then + if abs( dYDeltaF - dYDeltaI) > 10 * GEO.EPS_SMALL then + table.insert( vCmd, { 11, 0}) + dYPosA = max( MyMinY, dTPosI + dYDeltaF) + dTPosA = -( dYPosA + dVDeltaF) + dVPosA = dTPosA + dVDeltaF + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 11, 1}) + -- la morsa al carico è adesso in posizione + dYDeltaI = dYDeltaF + end + table.insert( vCmd, { 12, 0}) + -- sposto il carrello V in parcheggio + table.insert( vCmd, { 1, 'V', ParkV}) + table.insert( vCmd, { 21, dYDeltaF, 0}) + else + table.insert( vCmd, { 11, 0}) + table.insert( vCmd, { 1, 'Y', ParkY}) + table.insert( vCmd, { 21, 0, dVDeltaF}) + end + + -- movimento terminato + dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF + + -- SECONDO CASO -> SCAMBIO DIRETTO : Y IN POSIZIONE FINALE + -- Y può andare in posizione direttamente se : + -- * rispetta interasse minimo con Y + -- * deve effettivamente spostarsi + -- * non si arriva da gestione passo del pellegrino + -- * se riesce a raggiungere la posizione con le corse a disposizione per come sono posizionate le morse attualmente + elseif ( dYDeltaF - dVDeltaI) >= MyMinY - MaxV and abs( dYDeltaF - dYDeltaI) > 10 * GEO.EPS_SMALL and not EMC.PILGRIMSTEP and + ( dYDeltaF - dYDeltaI < MaxY - dYPosI + MaxV - dVPosI) then + table.insert( vCmd, { 0, 'Direct-Y-V'}) + -- se l'altra morsa non era in presa, vado a pinzare il pezzo + if not EMC.VDELTA then + dVPosA = MaxV + dTPosA = MaxV - dVDeltaI + dYPosA = dTPosA + dYDeltaI + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + dTPosI = dTPosA + dYPosI = dYPosA + table.insert( vCmd, { 12, 1}) + else + -- compenso delta errore misurazione laser + dVDeltaI = dVDeltaI - EgtIf( EMC.CNT == 1, AGG_LOAD, 0) + end + + -- se spostando morsa diretto esco dalle corse, calcolo di quanto devo muovere la trave (cioè l'altra morsa) come minimo + -- se non era ingaggiata, vado al suo minimo + if not EMC.YDELTA then + dBeamMove = - ( dYDeltaF - MyMinY + dTPosI) + -- se spostamento verso lo scarico + elseif ( dYPosI + ( dYDeltaF - dYDeltaI)) < MyMinY then + dBeamMove = -( dYPosI + ( dYDeltaF - dYDeltaI) - MyMinY) + -- se spostamento verso il carico + elseif ( dYPosI + ( dYDeltaF - dYDeltaI)) > MaxY then + dBeamMove = dYPosI + ( dYDeltaF - dYDeltaI) - MaxY + end + + table.insert( vCmd, { 11, 0}) + + dTPosA = dTPosI + dBeamMove + dYPosA = dTPosA + dYDeltaF + dVPosA = dTPosA + dVDeltaI + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + + -- la morsa allo scarico è adesso in posizione + dYDeltaI = dYDeltaF + dTPosI = dTPosA + + -- blocco la morsa + table.insert( vCmd, { 11, 1}) + + -- imposto i nuovi parametri di aggancio + if EMC.YDELTANEXT and EMC.VDELTANEXT then + if abs( dVDeltaF - dVDeltaI) > 10 * GEO.EPS_SMALL then + table.insert( vCmd, { 12, 0}) + dTPosA = dTPosF + dYPosA = dTPosF + dYDeltaF + dVPosA = dTPosF + dVDeltaF + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 12, 1}) + -- la morsa al carico è adesso in posizione + dVDeltaI = dVDeltaF + end + table.insert( vCmd, { 21, dYDeltaF, dVDeltaF}) + elseif EMC.VDELTANEXT then + if abs( dVDeltaF - dVDeltaI) > 10 * GEO.EPS_SMALL then + table.insert( vCmd, { 12, 0}) + dVPosA = min( MaxV, dTPosI + dVDeltaF) + dTPosA = dVPosA - dVDeltaF + dYPosA = dTPosA + dYDeltaF + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 12, 1}) + -- la morsa al carico è adesso in posizione + dVDeltaI = dVDeltaF + end + table.insert( vCmd, { 11, 0}) + -- sposto il carrello Y in parcheggio + table.insert( vCmd, { 1, 'Y', ParkY}) + table.insert( vCmd, { 21, 0, dVDeltaF}) + else + table.insert( vCmd, { 12, 0}) + -- sposto il carrello V in parcheggio + table.insert( vCmd, { 1, 'V', ParkV}) + table.insert( vCmd, { 21, dYDeltaF, 0}) + end + -- movimento terminato + dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF + + -- TERZO CASO -> PASSO DEL PELLEGRINO + -- non è possibile fare scambio diretto. + -- le morse vengono compattate e allargate sfruttando tutta la corsa X, massimizzando spostamento trave + else + EMC.PILGRIMSTEP = false + local bUpdateValues = false + table.insert( vCmd, { 0, 'Pilgrim Cycle'}) + -- compatto al centro + if not EMC.YDELTA then + table.insert( vCmd, { 0, 'Compact Y'}) + table.insert( vCmd, { 11, 0}) + dTPosA = MaxV - dVDeltaI + dVPosA = MaxV + dYPosA = MyMinY + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 11, 1}) + dYDeltaI = dVDeltaI - MaxV + MyMinY + EMC.YDELTA = dYDeltaI + bUpdateValues = true + end + if not EMC.VDELTA then + table.insert( vCmd, { 0, 'Compact V'}) + table.insert( vCmd, { 12, 0}) + dTPosA = MyMinY - dYDeltaI + dVPosA = MaxV + dYPosA = MyMinY + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 12, 1}) + dVDeltaI = dYDeltaI + MaxV - MyMinY + EMC.VDELTA = dVDeltaI + bUpdateValues = true + end + + -- se si sono compattate le morse, bisogna aggiornare le posizioni e i massimi recuperi + if bUpdateValues then + dTPosI = dTPosA + dYPosI = dYPosA + dVPosI = dVPosA + dMaxMovePilgrimStepDoubleClamp = MaxY - MinY - MinV + MaxV + dMaxMovePilgrimStepSingleClampY = MaxY - MinY + dMaxMovePilgrimStepSingleClampV = - MinV + MaxV + end + + -- aggiorno delta mancante + dDeltaBeam = dTPosI - dTPosF + + -- a questo punto entrambe le pinze sono in presa sul pezzo. + -- Il trascinatore si decide in base alla direzione di movimento trave + -- trascino con morsa allo scarico. Obiettivo mandare Y in posizione per prima + if dDeltaBeam > 0 then + -- apro morsa al carico + table.insert( vCmd, { 11, 0}) + -- devo recuperare più delle corse disponibili di entrambi i carrelli + if abs( dYDeltaI - dYDeltaF) > dMaxMovePilgrimStepDoubleClamp then + dYPosA = MaxY + dVPosA = MinV + dTPosA = dTPosI - dVPosI + MinV + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + -- nuova posizione della morsa al carico dopo riposizionamento + dYDeltaI = MaxY - dTPosA + dTPosI = dTPosA + EMC.YDELTA = dYDeltaI + EMC.VDELTA = nil + EMC.PILGRIMSTEP = true + -- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo + SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) + -- recupero una corsa massima e l'altra solo di quello che serve + elseif abs( dYDeltaI - dYDeltaF) > dMaxMovePilgrimStepSingleClampY then + -- morsa Y arriva in posizione finale + dYDeltaI = dYDeltaF + dVPosA = MinV + dTPosA = dTPosI - MaxV + MinV + dYPosA = dYDeltaF + dTPosA + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + dTPosI = dTPosA + EMC.YDELTA = dYDeltaF + EMC.VDELTA = dVDeltaI + -- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo + SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) + -- non serve recuperare al massimo della corsa, suddivido movimento in due + else + -- suddivido il movimento su entrambe le morse + local dTotMove = ( dYDeltaF - dYDeltaI) / 2 + + if abs( dTotMove) > 10 * GEO.EPS_SMALL then + dYPosA = dTPosI + dYDeltaI + dTotMove + dVPosA = dTPosI + dVDeltaI - dTotMove + dTPosA = dTPosI - dTotMove + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 12, 0}) + + -- aggiorno nuova posizione della morsa al carico dopo riposizionamento + dYDeltaI = dYDeltaF ; + + if not EMC.VDELTANEXT then + dTPosA = dTPosF + dYPosA = dTPosF + dYDeltaF + dVPosA = ParkV + elseif EMC.YDELTANEXT then + dTPosA = dTPosF + dYPosA = dTPosF + dYDeltaF + dVPosA = dTPosF + dVDeltaF + else + dYPosA = MyMinY + dTPosA = MyMinY - dYDeltaF + dVPosA = dTPosA + dVDeltaF + end + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF + + -- aggiorno nuova posizione della morsa allo scarico dopo riposizionamento + dVDeltaI = dVDeltaF + end + + -- imposto i nuovi parametri di aggancio + if EMC.YDELTANEXT and EMC.VDELTANEXT then + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 21, dYDeltaF, dVDeltaF}) + elseif EMC.YDELTANEXT then + table.insert( vCmd, { 21, dYDeltaF, 0}) + else + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- sposto il carrello Y in parcheggio + table.insert( vCmd, { 1, 'Y', ParkY}) + table.insert( vCmd, { 21, 0, dVDeltaF}) + end + end + -- trave si muove dallo scarico verso il carico. Obiettivo mandare V in posizione per prima + else + -- apro morsa allo scarico + table.insert( vCmd, { 12, 0}) + -- devo recuperare più del doppio delle corse + local dMaxMoveFirst + if abs( dVDeltaI - dVDeltaF) > dMaxMovePilgrimStepDoubleClamp then + dYPosA = MaxY + dVPosA = MinV + dTPosA = dTPosI + ( MaxY - dYPosI) + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + -- nuova posizione della morsa allo scarico dopo riposizionamento + dVDeltaI = MinV - dTPosA + dTPosI = dTPosA + EMC.YDELTA = nil + EMC.VDELTA = dVDeltaI + EMC.PILGRIMSTEP = true + -- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo + SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) + -- recupero una corsa massima e l'altra solo di quello che serve + elseif abs( dVDeltaI - dVDeltaF) > dMaxMovePilgrimStepSingleClampV then + -- aggiorno nuova posizione della morsa al carico dopo riposizionamento + local dTotMove = MaxY - dTPosI - dYDeltaI + dVDeltaI = dVDeltaF + dYPosA = MaxY + dTPosA = dTPosI + dTotMove + dVPosA = dVDeltaF + dTPosA + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + dTPosI = dTPosA + EMC.YDELTA = dYDeltaI + EMC.VDELTA = dVDeltaF + -- mi serve riposizonare di nuovo, quindi richiamo funzione in modo ricorsivo + SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) + -- non serve recuperare al massimo della corsa, suddivido movimento in due + else + -- suddivido il movimento su entrambe le morse + local dTotMove = ( dVDeltaI - dVDeltaF) / 2 + + if abs( dTotMove) > 10 * GEO.EPS_SMALL then + dYPosA = dTPosI + dYDeltaI + dTotMove + dVPosA = dTPosI + dVDeltaI - dTotMove + dTPosA = dTPosI + dTotMove + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + table.insert( vCmd, { 12, 1}) + table.insert( vCmd, { 11, 0}) + + -- aggiorno nuova posizione della morsa allo scarico dopo riposizionamento + dVDeltaI = dVDeltaF ; + + if not EMC.YDELTANEXT then + dTPosA = dTPosF + dVPosA = dTPosF + dVDeltaF + dYPosA = ParkY + elseif EMC.VDELTANEXT then + dTPosA = dTPosF + dYPosA = dTPosF + dYDeltaF + dVPosA = dTPosF + dVDeltaF + else + dVPosA = MaxV + dTPosA = MaxV - dVDeltaF + dYPosA = dTPosA + dYDeltaF + end + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + dTPosI, dYDeltaI, dVDeltaI = dTPosF, dYDeltaF, dVDeltaF + + -- aggiorno nuova posizione della morsa al carico dopo riposizionamento + dYDeltaI = dYDeltaF + end + + -- sistemo apertura morse + if EMC.YDELTANEXT then + table.insert( vCmd, { 11, 1}) + end + if not EMC.VDELTANEXT then + table.insert( vCmd, { 12, 0}) + -- sposto il carrello Y in parcheggio + table.insert( vCmd, { 1, 'V', ParkV}) + end + + -- imposto i nuovi parametri di aggancio + if EMC.YDELTANEXT and EMC.VDELTANEXT then + table.insert( vCmd, { 11, 1}) + table.insert( vCmd, { 21, dYDeltaF, dVDeltaF}) + elseif EMC.YDELTANEXT then + table.insert( vCmd, { 11, 1}) + -- sposto il carrello Y in parcheggio + table.insert( vCmd, { 12, 0}) + table.insert( vCmd, { 1, 'V', ParkV}) + table.insert( vCmd, { 21, dYDeltaF, 0}) + else + table.insert( vCmd, { 21, 0, dVDeltaF}) + end + end + end + end + end +end + +--------------------------------------------------------------------- +function SpecOutputCNT() + if EMC.CNT == 1 then + EgtSetInfo( EMC.PATHID, 'CNT', 1) + else + EgtRemoveInfo( EMC.PATHID, 'CNT') + end +end + +--------------------------------------------------------------------- +function SpecOutputCmds( vCmd, bEnd) + + local sRoot = EgtIf( not bEnd, 'AS', 'AE') + + -- Registro il numero di comandi + if #vCmd > 0 then + EgtSetInfo( EMC.PATHID, sRoot..'#', #vCmd) + else + EgtRemoveInfo( EMC.PATHID, sRoot..'#') + end + -- Registro i comandi + for i = 1, #vCmd do + local Cmd = vCmd[i] + local sKey = sRoot..tostring( i) + -- commento + if Cmd[1] == 0 then + local sInfo = '0,'..Cmd[2] + if Cmd[3] then sInfo = sInfo..','..Cmd[3] end + EgtSetInfo( EMC.PATHID, sKey, sInfo) + -- movimento di 1 asse + elseif Cmd[1] == 1 then + local sInfo = '1,'..Cmd[2]..','..EgtNumToString( Cmd[3],3) + EgtSetInfo( EMC.PATHID, sKey, sInfo) + -- movimento di 2 assi + elseif Cmd[1] == 2 then + local sInfo = '2,'..Cmd[2]..','..EgtNumToString( Cmd[3],3)..','..Cmd[4]..','..EgtNumToString( Cmd[5],3) + EgtSetInfo( EMC.PATHID, sKey, sInfo) + -- movimento di 3 assi + elseif Cmd[1] == 3 then + local sInfo = '3,'..Cmd[2]..','..EgtNumToString( Cmd[3],3)..','..Cmd[4]..','..EgtNumToString( Cmd[5],3)..','.. + Cmd[6]..','..EgtNumToString( Cmd[7],3) + EgtSetInfo( EMC.PATHID, sKey, sInfo) + -- apertura/chiusura morsa Y + elseif Cmd[1] == 11 then + local sInfo = '11,'..EgtNumToString( Cmd[2],0) + EgtSetInfo( EMC.PATHID, sKey, sInfo) + if Cmd[2] == 0 then EMC.YDELTA = nil end + -- apertura/chiusura morsa V + elseif Cmd[1] == 12 then + local sInfo = '12,'..EgtNumToString( Cmd[2],0) + EgtSetInfo( EMC.PATHID, sKey, sInfo) + if Cmd[2] == 0 then EMC.VDELTA = nil end + -- impostazione nuovo stato dei carrelli + elseif Cmd[1] == 21 then + local sInfo = '21,'..EgtNumToString( Cmd[2],3)..','..EgtNumToString( Cmd[3],3) + EgtSetInfo( EMC.PATHID, sKey, sInfo) + if Cmd[2] > 0 and Cmd[3] > 0 then + EMC.YDELTA = Cmd[2] + EMC.VDELTA = Cmd[3] + elseif Cmd[2] > 0 then + EMC.YDELTA = Cmd[2] + EMC.VDELTA = nil + elseif Cmd[3] > 0 then + EMC.YDELTA = nil + EMC.VDELTA = Cmd[3] + end + -- aggancio grezzo a carrello + elseif Cmd[1] == 31 then + local sInfo = '31,'..EgtNumToString( Cmd[2],0)..','..Cmd[3] + EgtSetInfo( EMC.PATHID, sKey, sInfo) + end + end + + -- Salvo i nuovi delta dei carrelli + if EMC.YDELTA then + EgtSetInfo( EMC.PATHID, 'YDELTA', EMC.YDELTA) + else + EgtRemoveInfo( EMC.PATHID, 'YDELTA') + end + if EMC.VDELTA then + EgtSetInfo( EMC.PATHID, 'VDELTA', EMC.VDELTA) + else + EgtRemoveInfo( EMC.PATHID, 'VDELTA') + end + +end + +--------------------------------------------------------------------- +function SpecSetCarrPosFromCmds( vCmd) + -- recupero nuova posizione carrelli + for i = 1, #vCmd do + local Cmd = vCmd[i] + if Cmd[1] == 21 then + if Cmd[2] > 0 and Cmd[3] > 0 then + EMC.YDELTA = Cmd[2] + EMC.VDELTA = Cmd[3] + elseif Cmd[2] > 0 then + EMC.YDELTA = Cmd[2] + EMC.VDELTA = nil + elseif Cmd[3] > 0 then + EMC.YDELTA = nil + EMC.VDELTA = Cmd[3] + end + end + end +end + +--------------------------------------------------------------------- +function SpecTestOnlyRemarkInCmds( vCmd) + if not vCmd then return true end + -- verifico se nella lista dei comandi ci sono solo commenti + for i = 1, #vCmd do + if vCmd[i][1] ~= 0 then + return false + end + end + return true +end + +--------------------------------------------------------------------- +--XXXXX XXXXX XXXXX --- TO REMOVE --- XXXXX XXXXX XXXXX XXXXX-- +--------------------------------------------------------------------- +--------------------------------------------------------------------- +function SpecCalcCarriagesOLD( dDistFront, dDistBack, bFixedDelta, bFixedPos) + + local MinFrontJoin = MinJoin + EMC.HCING + EMC.HOVM + local MinBackJoin = MinJoin + EgtIf( IsMid2Phase( EMC.PHASE) or IsEnd2Phase( EMC.PHASE), EMC.TCING, 0) + local MyMinOther = MinOther + EgtIf( EMC.CNT == 1, AGG_LOAD, 0) + + local dDistFrontEff = min( dDistFront, EMC.LB - MyMinOther - EMC.TCING) + if bFixedDelta and IsMid2Phase( EMC.PHASE + 1) then + dDistFrontEff = min( dDistFrontEff, EMC.LR - MinOther - EMC.TCING) + end + local dDistBackEff = min( dDistBack, EMC.LB - MyMinOther - EMC.HCING - EMC.HOVM) + + EgtOutLog( ' Dist/Min : Back=' .. EgtNumToString( dDistBackEff, 1) .. '/' .. EgtNumToString( MinBackJoin, 1) .. + ' Front=' .. EgtNumToString( dDistFrontEff, 1) .. '/' .. EgtNumToString( MinFrontJoin, 1) .. + ' Fixed : Delta=' .. EgtIf( bFixedDelta, 'T', 'F') .. ' Pos=' .. EgtIf( bFixedPos, 'T', 'F'), 3) + + -- [A] se posso mettere solo carrello Y + if dDistFrontEff < MinFrontJoin and dDistBackEff > MinBackJoin - GEO.EPS_SMALL then + + local dPosT = EMC.TPOS + local dYDelta = EMC.YDELTA + local dVDelta = EMC.VDELTA + + local dNewPosT = nil + local dNewYDelta = EMC.LB - dDistBackEff + local dNewVDelta = nil + + return SpecAdjustCarriagesOLD( dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos) + + -- [B] se altrimenti posso mettere entrambi i carrelli Y e V + elseif dDistBackEff > MinBackJoin - GEO.EPS_SMALL and + dDistFrontEff > MinFrontJoin - GEO.EPS_SMALL then + + local dPosT = EMC.TPOS + local dYDelta = EMC.YDELTA + local dVDelta = EMC.VDELTA + + local dNewPosT = nil + local dNewYDelta = EMC.LB - dDistBackEff + local dNewVDelta = dDistFrontEff + + return SpecAdjustCarriagesOLD( dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos) + + -- [C] se altrimenti posso mettere solo carrello V + elseif dDistBackEff < MinBackJoin and dDistFrontEff > MinFrontJoin - GEO.EPS_SMALL then + + local dPosT = EMC.TPOS + local dYDelta = EMC.YDELTA + local dVDelta = EMC.VDELTA + + local dNewPosT = nil + local dNewYDelta = nil + local dNewVDelta = dDistFrontEff + + return SpecAdjustCarriagesOLD( dPosT, dYDelta, dVDelta, dNewPosT, dNewYDelta, dNewVDelta, bFixedDelta, bFixedPos) + + -- altrimenti errore + else + if EgtGetDebugLevel() < 3 then + EgtOutLog( ' Dist/Min : Back=' .. EgtNumToString( dDistBackEff, 1) .. '/' .. EgtNumToString( MinBackJoin, 1) .. + ' Front=' .. EgtNumToString( dDistFrontEff, 1) .. '/' .. EgtNumToString( MinFrontJoin, 1)) + end + EgtOutLog( ' Error CLAMP impossible') + EMC.ERR = 18 + return {} + end +end + +--------------------------------------------------------------------- +function SpecAdjustCarriagesOLD( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) -- [A] richiesto solo carrello Y if dYDeltaF and ( not dVDeltaF) then -- [A1] rimango sul carrello Y @@ -1388,7 +2161,6 @@ function SpecAdjustCarriages( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDe EgtOutLog( ' Error CLAMP NULL-> Y impossibile') error( 'Error CLAMP NULL-> Y impossibile') end - -- (B) richiesti entrambi i carrelli elseif dYDeltaF and dVDeltaF then -- [B1] passo da carrello Y a entrambi @@ -1404,7 +2176,6 @@ function SpecAdjustCarriages( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDe EgtOutLog( ' Error CLAMP NULL-> Y+V impossibile') error( 'Error CLAMP NULL-> Y+V impossibile') end - -- [C] richiesto solo carrello V elseif ( not dYDeltaF) and dVDeltaF then -- [C1] provengo da solo carrello Y @@ -1420,9 +2191,7 @@ function SpecAdjustCarriages( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDe EgtOutLog( ' Error CLAMP NULL-> V impossibile') error( 'Error CLAMP NULL-> V impossibile') end - end - end --------------------------------------------------------------------- @@ -1436,35 +2205,6 @@ local function CalcCharStatus( sType, dDelta) end end ---------------------------------------------------------------------- -local function GetDeltaTol( dLenPresa, TCING, HCING, HOVM, Carr, bFixedDelta) - local dDeltaTolEff = DELTA_SIC - if Carr == 'Y' then - local dLenPreEff = dLenPresa - TCING - if dLenPreEff < MinJoin + DeltaTol then - dDeltaTolEff = max( DELTA_SIC, dLenPreEff - MinJoin + 10 * GEO.EPS_SMALL) - else - if BD.GO_FAST and BD.GO_FAST ~= 0 then - if bFixedDelta == false then - dDeltaTolEff = min( EMC.LB + 700, dLenPreEff, 3200) - else - dDeltaTolEff = 900 - end - else - dDeltaTolEff = DeltaTol - end - end - elseif Carr == 'V' then - local dLenPreEff = dLenPresa - HCING - HOVM - if dLenPreEff < MinJoin + DeltaTol then - dDeltaTolEff = max( DELTA_SIC, dLenPreEff - MinJoin + 10 * GEO.EPS_SMALL) - else - dDeltaTolEff = DeltaTol - end - end - return EgtIf( bFixedDelta, min( dDeltaTolEff, DELTA_TOL_FIXED), dDeltaTolEff) -end - --------------------------------------------------------------------- local function GetCorseDisp( dCorsaYfc, dCorsaVfc, dDistN, sSide) local dRecTotn = min( dDistN, dCorsaYfc+ dCorsaVfc) -- recupero possibile al netto di dCorsa..TrA) @@ -3734,122 +4474,3 @@ function SpecAdjustCarrC3( dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDelta SpecOutputCNT() return vCmd end --SpecAdjustCarrC3 - ---------------------------------------------------------------------- -function SpecOutputCNT() - if EMC.CNT == 1 then - EgtSetInfo( EMC.PATHID, 'CNT', 1) - else - EgtRemoveInfo( EMC.PATHID, 'CNT') - end -end - ---------------------------------------------------------------------- -function SpecOutputCmds( vCmd, bEnd) - - local sRoot = EgtIf( not bEnd, 'AS', 'AE') - - -- Registro il numero di comandi - if #vCmd > 0 then - EgtSetInfo( EMC.PATHID, sRoot..'#', #vCmd) - else - EgtRemoveInfo( EMC.PATHID, sRoot..'#') - end - -- Registro i comandi - for i = 1, #vCmd do - local Cmd = vCmd[i] - local sKey = sRoot..tostring( i) - -- commento - if Cmd[1] == 0 then - local sInfo = '0,'..Cmd[2] - if Cmd[3] then sInfo = sInfo..','..Cmd[3] end - EgtSetInfo( EMC.PATHID, sKey, sInfo) - -- movimento di 1 asse - elseif Cmd[1] == 1 then - local sInfo = '1,'..Cmd[2]..','..EgtNumToString( Cmd[3],3) - EgtSetInfo( EMC.PATHID, sKey, sInfo) - -- movimento di 2 assi - elseif Cmd[1] == 2 then - local sInfo = '2,'..Cmd[2]..','..EgtNumToString( Cmd[3],3)..','..Cmd[4]..','..EgtNumToString( Cmd[5],3) - EgtSetInfo( EMC.PATHID, sKey, sInfo) - -- movimento di 3 assi - elseif Cmd[1] == 3 then - local sInfo = '3,'..Cmd[2]..','..EgtNumToString( Cmd[3],3)..','..Cmd[4]..','..EgtNumToString( Cmd[5],3)..','.. - Cmd[6]..','..EgtNumToString( Cmd[7],3) - EgtSetInfo( EMC.PATHID, sKey, sInfo) - -- apertura/chiusura morsa Y - elseif Cmd[1] == 11 then - local sInfo = '11,'..EgtNumToString( Cmd[2],0) - EgtSetInfo( EMC.PATHID, sKey, sInfo) - if Cmd[2] == 0 then EMC.YDELTA = nil end - -- apertura/chiusura morsa V - elseif Cmd[1] == 12 then - local sInfo = '12,'..EgtNumToString( Cmd[2],0) - EgtSetInfo( EMC.PATHID, sKey, sInfo) - if Cmd[2] == 0 then EMC.VDELTA = nil end - -- impostazione nuovo stato dei carrelli - elseif Cmd[1] == 21 then - local sInfo = '21,'..EgtNumToString( Cmd[2],3)..','..EgtNumToString( Cmd[3],3) - EgtSetInfo( EMC.PATHID, sKey, sInfo) - if Cmd[2] > 0 and Cmd[3] > 0 then - EMC.YDELTA = Cmd[2] - EMC.VDELTA = Cmd[3] - elseif Cmd[2] > 0 then - EMC.YDELTA = Cmd[2] - EMC.VDELTA = nil - elseif Cmd[3] > 0 then - EMC.YDELTA = nil - EMC.VDELTA = Cmd[3] - end - -- aggancio grezzo a carrello - elseif Cmd[1] == 31 then - local sInfo = '31,'..EgtNumToString( Cmd[2],0)..','..Cmd[3] - EgtSetInfo( EMC.PATHID, sKey, sInfo) - end - end - - -- Salvo i nuovi delta dei carrelli - if EMC.YDELTA then - EgtSetInfo( EMC.PATHID, 'YDELTA', EMC.YDELTA) - else - EgtRemoveInfo( EMC.PATHID, 'YDELTA') - end - if EMC.VDELTA then - EgtSetInfo( EMC.PATHID, 'VDELTA', EMC.VDELTA) - else - EgtRemoveInfo( EMC.PATHID, 'VDELTA') - end - -end - ---------------------------------------------------------------------- -function SpecSetCarrPosFromCmds( vCmd) - -- recupero nuova posizione carrelli - for i = 1, #vCmd do - local Cmd = vCmd[i] - if Cmd[1] == 21 then - if Cmd[2] > 0 and Cmd[3] > 0 then - EMC.YDELTA = Cmd[2] - EMC.VDELTA = Cmd[3] - elseif Cmd[2] > 0 then - EMC.YDELTA = Cmd[2] - EMC.VDELTA = nil - elseif Cmd[3] > 0 then - EMC.YDELTA = nil - EMC.VDELTA = Cmd[3] - end - end - end -end - ---------------------------------------------------------------------- -function SpecTestOnlyRemarkInCmds( vCmd) - if not vCmd then return true end - -- verifico se nella lista dei comandi ci sono solo commenti - for i = 1, #vCmd do - if vCmd[i][1] ~= 0 then - return false - end - end - return true -end diff --git a/Essetre-FAST.mlde b/Essetre-FAST.mlde index 0c40120..db386d8 100644 --- a/Essetre-FAST.mlde +++ b/Essetre-FAST.mlde @@ -65,12 +65,13 @@ -- 2024/09/06 LM ver 2.6i4 In BeamData le costanti sopra sono configurabili anche da offsets Ts3v7 -- 2024/09/16 AV ver 2.6i5 Allineamento con common ver. 2.6i2 -- 2024/09/18 LM ver 2.6i6 Modificato YAML per comunicazione versioni a LiMan. Aggiunta PP_NVER, versione in formato numerico. +-- 2024/09/23 AV ver 2.6i7 Allineamento con common ver. 2.6i3 require( 'EmtGenerator') EgtEnableDebug( false) -PP_VER = '2.6i6' -PP_NVER = '2.6.9.6' +PP_VER = '2.6i7' +PP_NVER = '2.6.9.7' MIN_MACH_VER = '2.5k1' MACH_NAME = 'Essetre-FAST' diff --git a/UpdateLog.txt b/UpdateLog.txt index cf244d4..d1dd83c 100644 --- a/UpdateLog.txt +++ b/UpdateLog.txt @@ -1,5 +1,10 @@ ==== Common_FAST Update Log ==== +Versione 2.6i3 (23/09/2024) +- (SIM-GEN) Aggiunta nuova strategia riposizionamento morse +- (SIM-GEN) Aggiunta lettura flag NEWCLAMPING in BeamData, per abilitare nuova strategia riposizionamento. Se false o nil, funziona con metodo vecchio. +- (SIM-GEN) Aggiunta lettura flag FASTCLAMPING. Se false, al carico prende al massimo 1000mm, per evitare collisioni durante ciclo di lettura laser e prima lavorazione. + Versione 2.6i2 (16/09/2024) - (SIM-GEN) Se utensili più lunghi di 200mm, si ruota in home e poi si approccia il pezzo. Ticket#2038 - (SIM-GEN) Aumentata distanza ingombro da 650mm a 660mm. In casi di utensile abbastanza lungo poteva andare in colisione. Ticket#2041 diff --git a/Version.lua b/Version.lua index 75b5963..bbe883c 100644 --- a/Version.lua +++ b/Version.lua @@ -3,7 +3,7 @@ local InfoCommon_STD_PP = { NAME = 'Common_FAST', -- nome script PP standard - VERSION = '2.6i2', -- versione script + VERSION = '2.6i3', -- versione script MIN_MACH_VER_PP_COMMON = '2.5k1' -- versione minima kernel } From 46665cf1fc2ce16c3f19c51d5da59b63c4255828 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Tue, 24 Sep 2024 11:17:47 +0200 Subject: [PATCH 09/11] modificato YAML --- .gitlab-ci.yml | 23 +++++++++++++++-------- 1 file changed, 15 insertions(+), 8 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index b4625bc..8e517e9 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -47,8 +47,8 @@ variables: echo "-----------------------" $customerPathR = $env:MACHINES_PATH_R + "\" + $env:MANUFACTURER ROBOCOPY /MIR "$env:SRC_PATH" "$customerPathR\$env:MACH_NAME\" /XD "bin" - ROBOCOPY "$env:TEST_PATH" "$customerPathR\$env:MACH_NAME_TEST\" /E /XD "bin" - ROBOCOPY /MIR "$env:BASE_PATH" "$customerPathR\Deploy\$env:MACH_NAME\$env:MACH_VERS\" /XD "bin" /XD "$env:MACH_NAME_TEST" + ROBOCOPY "$env:TEST_PATH" "$customerPathR\_TestMachines\$env:MACH_NAME\$env:MACH_NAME_TEST\" /E /XD "bin" + ROBOCOPY /MIR "$env:BASE_PATH" "$customerPathR\_Deploy\$env:MACH_NAME\$env:MACH_VERS\" /XD "bin" /XD "$env:MACH_NAME_TEST" SLEEP 2 net use R: /delete @@ -78,7 +78,7 @@ variables: echo " Copia macchina su R - DEV" echo "-----------------------" $customerPathR = $env:MACHINES_PATH_R + "\" + $env:MANUFACTURER - ROBOCOPY /MIR "$env:BASE_PATH" "$customerPathR\Deploy\$env:MACH_NAME\_DEV\$env:MACH_VERS\" /XD "bin" /XD "$env:MACH_NAME_TEST" + ROBOCOPY /MIR "$env:BASE_PATH" "$customerPathR\_Deploy\$env:MACH_NAME\_DEV\$env:MACH_VERS\" /XD "bin" /XD "$env:MACH_NAME_TEST" SLEEP 2 net use R: /delete @@ -91,8 +91,9 @@ variables: echo "-----------------------" echo " Recupero file non git da R e copia su macchina virtuale" echo "-----------------------" - ROBOCOPY "$env:LAST_MACHINE_PATH" "$env:SRC_PATH" /E /XF "*.bat" /XF "*.yml" /XF ".gitignore" /XD ".git" /XF "UpdateLog.txt" /XD ".vscode" - ROBOCOPY "$env:LAST_MACHINE_PATH" "$env:SRC_PATH\bin\$env:MACH_NAME\" /E /XF "*.bat" /XF "*.yml" /XF ".gitignore" /XD ".git" /XF "UpdateLog.txt" /XD ".vscode" + ROBOCOPY "$env:TOOLS_MACHINE_PATH" "$env:SRC_PATH" /E /XF "*.bat" /XF "*.yml" /XF ".gitignore" /XD ".git" /XF "UpdateLog.txt" /XD ".vscode" + ROBOCOPY "$env:TOOLS_MACHINE_PATH" "$env:TEST_PATH" /E /XF "*.bat" /XF "*.yml" /XF ".gitignore" /XD ".git" /XF "UpdateLog.txt" /XD ".vscode" + ROBOCOPY "$env:TOOLS_MACHINE_PATH" "$env:SRC_PATH\bin\$env:MACH_NAME\" /E /XF "*.bat" /XF "*.yml" /XF ".gitignore" /XD ".git" /XF "UpdateLog.txt" /XD ".vscode" SLEEP 2 net use R: /delete @@ -172,8 +173,8 @@ variables: echo "-----------------------" echo " Creazione cartelle su macchina virtuale" echo "-----------------------" - $env:LAST_MACHINE_PATH = "$env:MACHINES_PATH_R\$env:MACH_NAME"; - Write-Output $env:LAST_MACHINE_PATH; + $env:TOOLS_MACHINE_PATH = "$env:MACHINES_PATH_R\$env:MANUFACTURER\_DefaultMachineSetup\$env:MACH_NAME"; + Write-Output $env:TOOLS_MACHINE_PATH; $env:SRC_PATH = "$env:TEMP_PATH\$env:MACH_NAME\$env:MACH_VERS\$env:MACH_NAME"; $env:BASE_PATH = "$env:TEMP_PATH\$env:MACH_NAME\$env:MACH_VERS"; $env:TEST_PATH = "$env:TEMP_PATH\$env:MACH_NAME\$env:MACH_VERS\$env:MACH_NAME_TEST"; @@ -203,9 +204,15 @@ variables: echo " Invio versione a log online" echo "-----------------------" $tags = "" + $date = "" # se critico scrive tag if ( $CI_COMMIT_MESSAGE | Select-String -Pattern $env:CRITICAL_STRING) { - $tags = "CRITICAL" + $tags = "CRITICAL" + $date = (Get-Date).AddDays(1).toString("yyyy-MM-ddTHH:mm:ss.fffZ") + } + else + { + $date = (Get-Date).AddDays(3).toString("yyyy-MM-ddTHH:mm:ss.fffZ") } $body = @{ From 7922a3bb171f9f7735b0c5e5c07386947a12c720 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Tue, 24 Sep 2024 13:08:11 +0200 Subject: [PATCH 10/11] update gitignore e YAML --- .gitignore | 9 +++++++++ .gitlab-ci.yml | 13 ++++++++++--- 2 files changed, 19 insertions(+), 3 deletions(-) diff --git a/.gitignore b/.gitignore index 196fc23..1017e67 100644 --- a/.gitignore +++ b/.gitignore @@ -15,3 +15,12 @@ /Wall/PocketingData.lua /Wall/SawingData.lua /Wall/Ts3Data.lua +/.vscode +/MachNotes.ini +/ToolNotes.ini + +# ignoro file bak nella cartella principale e nelle sottocartelle al primo livello +*.bak +/*/*.bak + +Wall/SurfacingData.lua diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 8e517e9..b6ec408 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -21,6 +21,7 @@ variables: URL_VERSIONS_LOG: "https://liman.egalware.com/ELM.API/api/release/save" MACH_VERS_NUM: '0.0.0.0' CRITICAL_STRING: "#critical#" + TOOLS_MACHINE_PATH: "" #Note compilazione LUA: @@ -91,6 +92,12 @@ variables: echo "-----------------------" echo " Recupero file non git da R e copia su macchina virtuale" echo "-----------------------" + # test se la cartella con gli utensili esiste per questa macchina + if (!(Test-Path -Path $env:TOOLS_MACHINE_PATH)) { + echo "-----------------------" + echo "CANNOT FIND TOOLS FOR THIS MACHINE!!" + echo "-----------------------" + Exit 1} ROBOCOPY "$env:TOOLS_MACHINE_PATH" "$env:SRC_PATH" /E /XF "*.bat" /XF "*.yml" /XF ".gitignore" /XD ".git" /XF "UpdateLog.txt" /XD ".vscode" ROBOCOPY "$env:TOOLS_MACHINE_PATH" "$env:TEST_PATH" /E /XF "*.bat" /XF "*.yml" /XF ".gitignore" /XD ".git" /XF "UpdateLog.txt" /XD ".vscode" ROBOCOPY "$env:TOOLS_MACHINE_PATH" "$env:SRC_PATH\bin\$env:MACH_NAME\" /E /XF "*.bat" /XF "*.yml" /XF ".gitignore" /XD ".git" /XF "UpdateLog.txt" /XD ".vscode" @@ -173,8 +180,8 @@ variables: echo "-----------------------" echo " Creazione cartelle su macchina virtuale" echo "-----------------------" - $env:TOOLS_MACHINE_PATH = "$env:MACHINES_PATH_R\$env:MANUFACTURER\_DefaultMachineSetup\$env:MACH_NAME"; - Write-Output $env:TOOLS_MACHINE_PATH; + $env:TOOLS_MACHINE_PATH = "$env:MACHINES_PATH_R\$env:MANUFACTURER\_DefaultMachineSetup\$env:MACH_NAME" + Write-Output $env:TOOLS_MACHINE_PATH $env:SRC_PATH = "$env:TEMP_PATH\$env:MACH_NAME\$env:MACH_VERS\$env:MACH_NAME"; $env:BASE_PATH = "$env:TEMP_PATH\$env:MACH_NAME\$env:MACH_VERS"; $env:TEST_PATH = "$env:TEMP_PATH\$env:MACH_NAME\$env:MACH_VERS\$env:MACH_NAME_TEST"; @@ -223,7 +230,7 @@ variables: tipo = "Machine" versNum = $env:MACH_VERS_NUM versText = $env:MACH_VERS - releaseDate = (Get-Date).toString("yyyy-MM-ddTHH:mm:ss.fffZ") + releaseDate = $date relTags = $tags } $jsonBody = ConvertTo-Json -InputObject $body From 75355f60f1fdbff4bcd80a1cc0eb86f8f4d24b7e Mon Sep 17 00:00:00 2001 From: "andrea.villa" Date: Tue, 24 Sep 2024 17:44:17 +0200 Subject: [PATCH 11/11] - Allineamento con common ver. 2.6i5 - Aggiunta parametri NEWCLAMPING, FASTCLAMPING e GAIN_RECLAMPING --- Beam/BeamData.lua | 5 +++ Common_FAST.NUM.mlpe | 23 +++++++++-- Common_FAST.NUM_PLUS.mlpe | 23 +++++++++-- Common_FAST.TPA.mlpe | 19 +++++++-- Common_FAST.mlpe | 5 ++- Common_FAST.mlse | 86 ++++++++++++++++++++++++++++++++++++++- Essetre-FAST.mlde | 6 ++- UpdateLog.txt | 8 ++++ Version.lua | 2 +- 9 files changed, 160 insertions(+), 17 deletions(-) diff --git a/Beam/BeamData.lua b/Beam/BeamData.lua index 9b3cd47..544a09e 100644 --- a/Beam/BeamData.lua +++ b/Beam/BeamData.lua @@ -8,6 +8,8 @@ local BeamData = { GO_FAST = 0, -- flag abilitazione modalità veloce (0=no, 1=carrelli, 2=anche cambio utensili) RIGHT_LOAD = false, -- flag carico da destra ROT90 = false, -- flag abilitazione rotazione 90 gradi + NEWCLAMPING = false, -- flag abilitazione nuovo metodo riposizionamento carrelli + FASTCLAMPING= true, -- flag abilitazione riduzione numero riposizionamenti al carico e durante grande trascinamento MIN_WIDTH = 40, -- larghezza minima del grezzo MIN_HEIGHT = 40, -- altezza minima del grezzo MAX_WIDTH = 240, -- larghezza massima del grezzo @@ -72,6 +74,7 @@ local BeamData = { PRECUT_HEAD = true, -- flag abilitazione pretaglio grezzo a zero in testa PRECUT_TAIL = true, -- flag abilitazione pretaglio grezzo a zero in coda MIN_HEIGHT_ADDED_CUTS = 400, -- altezza minima pezzo per effettuare tagli orizzontali aggiuntivi in testa e coda + GAIN_RECLAMPING = 1000 -- in caso di scarso pinzaggio, mm da recuperare con pinzaggio ulteriore prima di spostare } -- Aggiornamento con dati da TechnoEssetre7 @@ -99,6 +102,8 @@ if EgtExistsFile( sData) then if Machine.Offsets.PRECUT_HEAD_DISABLE then BeamData.PRECUT_HEAD = ( Machine.Offsets.PRECUT_HEAD_DISABLE == 0) end if Machine.Offsets.PRECUT_TAIL_DISABLE then BeamData.PRECUT_TAIL = ( Machine.Offsets.PRECUT_TAIL_DISABLE == 0) end if Machine.Offsets.MIN_HEIGHT_ADDED_CUTS then BeamData.MIN_HEIGHT_ADDED_CUTS = min( Machine.Offsets.MIN_HEIGHT_ADDED_CUTS, BeamData.MIN_HEIGHT_ADDED_CUTS) end + if Machine.Offsets.NEWCLAMPING ~= nil then BeamData.NEWCLAMPING = Machine.Offsets.NEWCLAMPING end + if Machine.Offsets.FASTCLAMPING ~= nil then BeamData.FASTCLAMPING = Machine.Offsets.FASTCLAMPING end end if Machine.Trave then BeamData.MIN_WIDTH = Machine.Trave.XMIN or BeamData.MIN_WIDTH diff --git a/Common_FAST.NUM.mlpe b/Common_FAST.NUM.mlpe index 02e1f11..07d2cf4 100644 --- a/Common_FAST.NUM.mlpe +++ b/Common_FAST.NUM.mlpe @@ -627,7 +627,7 @@ function OnRapid() local MyZHome = EgtGetAxisHomePos( 'Z') local bZmax = ( #EMT.AUXSTR > 0 or EMT.TOOL ~= EMT.PREVTOOL or EMT.L3 > -1) -- se avevo motosega, torno in zona sicura senza ruotare assi rotanti - if ( EMT.PREVHEAD == 'H3' or EMT.TTOTLEN > 200) and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then + if EMT.PREVHEAD == 'H3' and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then local sOutPreMove = 'G101' .. ' X' .. EmtLenToString( -SafeXRotAxes, 3) .. ' Z' .. EmtLenToString( MyZHome, 3) .. ' B' .. EmtLenToString( EMT.R2pp, 3) .. ' C' .. EmtLenToString( EMT.R1pp, 3) .. ' EE' .. EgtIf( bZmax, '3', '4') .. EMT.PREVsEL .. EMT.PREVsER .. EMT.PREVsET .. EMT.PREVsES @@ -649,7 +649,7 @@ function OnRapid() local sES = ' ES'..EgtNumToString( EMT.S, 0) -- se carico motosega, ruoto in zona sicura prima di approcciare la lavorazione - if ( EMT.HEAD == 'H3' or EMT.TTOTLEN > 200) and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then + if ( EMT.HEAD == 'H3' or ( bZmax and EMT.TTOTLEN > 200)) and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then local sEEPreMove = ' EE' .. EgtIf( bZmax, '3', '4') local sOutPreMove = 'G101' .. ' X' .. EmtLenToString( -SafeXRotAxes, 3) .. ' Z' .. EmtLenToString( MyZHome, 3) .. EmtGetAxis( 'R2') .. EmtGetAxis( 'R1') .. sEE .. sEL .. sER .. sET .. sES @@ -836,9 +836,24 @@ function OnRapid() -- se altrimenti movimento in Home elseif EMT.FLAG == 4 then -- non previsto - -- se altrimenti rotazione a Z max + -- se altrimenti rotazione a Z max per lavorazione successiva elseif EMT.FLAG == 5 then - -- viene gestito all'inizio della lavorazione successiva + EMT.REFLOC = nil + EMT.IPLGL = false + MyAdjustLinearAxes() + EmtAdjustRotaryAxes() + EmtResetPrev() + -- ricavo i dati per la lavorazione + local sEE = ' EE3' + local sEL = ' EL' .. EmtLenToString( EgtIf( EMT.HEAD ~= 'H3', EMT.TLEN, ( EMT.TDIST or ChSawLen)), 3) + local sER = ' ER' .. EmtLenToString( EgtIf( EMT.HEAD ~= 'H3', EMT.TDIAM / 2, EMT.TLEN), 3) + local sET = GetET( EMT.HEAD, EMT.TCPOS, EMT.R3) + local sES = ' ES'..EgtNumToString( EMT.S, 0) + local sOut = 'G101' .. EmtGetAxis( 'L2') .. EmtGetAxis( 'L3') .. + EmtGetAxis( 'R2') .. EmtGetAxis( 'R1') .. sEE .. sEL .. sER .. sET .. sES + EmtOutput( sOut) + EmtOutput( 'G101 ET1001') + EmtOutput( 'G101 ET2001') -- altrimenti errore else EmtSetLastError( 1212, "Unknown Rapid flag") diff --git a/Common_FAST.NUM_PLUS.mlpe b/Common_FAST.NUM_PLUS.mlpe index 23be211..205957f 100644 --- a/Common_FAST.NUM_PLUS.mlpe +++ b/Common_FAST.NUM_PLUS.mlpe @@ -668,7 +668,7 @@ function OnRapid() local MyZHome = EgtGetAxisHomePos( 'Z') local bZmax = ( #EMT.AUXSTR > 0 or EMT.TOOL ~= EMT.PREVTOOL or EMT.L3 > -1) -- se avevo motosega, torno in zona sicura senza ruotare assi rotanti - if ( EMT.PREVHEAD == 'H3' or EMT.TTOTLEN > 200) and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then + if EMT.PREVHEAD == 'H3' and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then local sOutPreMove = 'G101' .. ' X' .. EmtLenToString( -SafeXRotAxes, 3) .. ' Z' .. EmtLenToString( MyZHome, 3) .. ' B' .. EmtLenToString( EMT.R2pp, 3) .. ' C' .. EmtLenToString( EMT.R1pp, 3) .. ' EE' .. EgtIf( bZmax, '3', '4') .. EMT.PREVsEL .. EMT.PREVsER .. EMT.PREVsET .. EMT.PREVsES @@ -713,7 +713,7 @@ function OnRapid() local sES = ' ES'..EgtNumToString( EMT.S, 0) -- se carico motosega, ruoto in zona sicura prima di approcciare la lavorazione - if ( EMT.HEAD == 'H3' or EMT.TTOTLEN > 200) and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then + if ( EMT.HEAD == 'H3' or ( bZmax and EMT.TTOTLEN > 200)) and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then local sEEPreMove = ' EE' .. EgtIf( bZmax, '3', '4') local sOutPreMove = 'G101' .. ' X' .. EmtLenToString( -SafeXRotAxes, 3) .. ' Z' .. EmtLenToString( MyZHome, 3) .. EmtGetAxis( 'R2') .. EmtGetAxis( 'R1') .. sEE .. sEL .. sER .. sET .. sES @@ -910,9 +910,24 @@ function OnRapid() -- se altrimenti movimento in Home elseif EMT.FLAG == 4 then -- non previsto - -- se altrimenti rotazione a Z max + -- se altrimenti rotazione a Z max per lavorazione successiva elseif EMT.FLAG == 5 then - -- viene gestito all'inizio della lavorazione successiva + EMT.REFLOC = nil + EMT.IPLGL = false + MyAdjustLinearAxes() + EmtAdjustRotaryAxes() + EmtResetPrev() + -- ricavo i dati per la lavorazione + local sEE = ' EE3' + local sEL = ' EL' .. EmtLenToString( EgtIf( EMT.HEAD ~= 'H3', EMT.TLEN, ( EMT.TDIST or ChSawLen)), 3) + local sER = ' ER' .. EmtLenToString( EgtIf( EMT.HEAD ~= 'H3', EMT.TDIAM / 2, EMT.TLEN), 3) + local sET = GetET( EMT.HEAD, EMT.TCPOS, EMT.R3) + local sES = ' ES'..EgtNumToString( EMT.S, 0) + local sOut = 'G101' .. EmtGetAxis( 'L2') .. EmtGetAxis( 'L3') .. + EmtGetAxis( 'R2') .. EmtGetAxis( 'R1') .. sEE .. sEL .. sER .. sET .. sES + EmtOutput( sOut) + EmtOutput( 'G101 ET1001') + EmtOutput( 'G101 ET2001') -- altrimenti errore else EmtSetLastError( 1212, "Unknown Rapid flag") diff --git a/Common_FAST.TPA.mlpe b/Common_FAST.TPA.mlpe index c3acb1d..e683a67 100644 --- a/Common_FAST.TPA.mlpe +++ b/Common_FAST.TPA.mlpe @@ -647,7 +647,7 @@ function OnRapid() local MyZHome = EgtGetAxisHomePos( 'Z') local bZmax = ( #EMT.AUXSTR > 0 or EMT.TOOL ~= EMT.PREVTOOL or EMT.L3 > -1) -- se avevo motosega, torno in zona sicura senza ruotare assi rotanti - if ( EMT.PREVHEAD == 'H3' or EMT.TTOTLEN > 200) and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then + if EMT.PREVHEAD == 'H3' and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then local sOutPreMove = 'M101 P1=1' .. ' P2=' .. EmtLenToString( -SafeXRotAxes, 3) .. ' P3=' .. EmtLenToString( MyZHome, 3) .. ' P4=' .. EgtNumToString( EMT.R2pp, 3) .. ' P5=' .. EgtNumToString( EMT.R1pp, 3) .. ' P6=' .. EgtNumToString( EMT.PREVTCPOS, 3) .. ' P7=' .. EgtNumToString( EMT.PREVS, 0) .. @@ -663,7 +663,7 @@ function OnRapid() end -- se carico motosega, ruoto in zona sicura prima di approcciare la lavorazione - if ( EMT.HEAD == 'H3' or EMT.TTOTLEN > 200) and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then + if ( EMT.HEAD == 'H3' or ( bZmax and EMT.TTOTLEN > 200)) and EMT.ST > BeamHeightForFixRot and EMT.FLAG2 == 1 then local sOutPreMove = 'M101 P1=1' .. ' P2=' .. EmtLenToString( -SafeXRotAxes, 3) .. ' P3=' .. EmtLenToString( MyZHome, 3) .. ' P4=' .. EgtNumToString( EMT.R2, 3) .. ' P5=' .. EgtNumToString( EMT.R1, 3) .. ' P6=' .. AdjustTcPos( false) .. ' P7=' .. EgtNumToString( EMT.S, 0) .. @@ -852,9 +852,20 @@ function OnRapid() -- se altrimenti movimento in Home elseif EMT.FLAG == 4 then -- non previsto - -- se altrimenti rotazione a Z max + -- se altrimenti rotazione a Z max per lavorazione successiva elseif EMT.FLAG == 5 then - -- viene gestito all'inizio della lavorazione successiva + EMT.REFLOC = nil + EMT.IPLGL = false + MyAdjustLinearAxes() + EmtAdjustRotaryAxes() + EmtResetPrev() + local sOut = 'M101 P1=1' .. ' P2=' .. EmtLenToString( EMT.L2, 3) .. ' P3=' .. EmtLenToString( EMT.L3, 3) .. + ' P4=' .. EgtNumToString( EMT.R2, 3) .. ' P5=' .. EgtNumToString( EMT.R1, 3) .. + ' P6=' .. AdjustTcPos( false) .. ' P7=' .. EgtNumToString( EMT.S, 0) .. + ' P8=0' .. ' P9=0' .. ' P10=3' + EmtOutput( sOut) + EmtOutput( 'M101 P1=2') + EmtOutput( 'M101 P1=3') -- altrimenti errore else error( "Unknown Rapid flag") diff --git a/Common_FAST.mlpe b/Common_FAST.mlpe index 2594db7..ecfeee3 100644 --- a/Common_FAST.mlpe +++ b/Common_FAST.mlpe @@ -662,6 +662,7 @@ function OnSimulMachiningEnd() EMT.FALL = false end EMT.PREVHEAD = EMT.HEAD + EMT.PREVTOOL = EMT.TOOL EMT.PREVEXIT = EMT.EXIT end @@ -749,10 +750,12 @@ function OnSimulMoveStart() if EMT.MCHFIRST then EgtOutText( '') EMT.MCHFIRST = false + local bZmax = ( EMT.TOOL ~= EMT.PREVTOOL or EMT.L3 > -1) + -- con pezzi alti aggiorno gli assi rotanti prima di muovermi sopra il pezzo if not EMT.LOAD and EMT.MOVE == 0 and EMT.HB > BeamHeightForFixRot and EMT.FLAG2 == 1 then -- se motosega mi muovo a X di sicurezza per ruotare - if EMT.HEAD == 'H3' or EMT.TOTLEN > 200 then + if ( EMT.HEAD == 'H3' or ( bZmax and EMT.TOTLEN > 200)) then SimulMoveAxes( 'X', SafeXRotAxes, MCH_SIM_STEP.RAPID, 'C', EMT.R1, MCH_SIM_STEP.COLLROT, 'B', EMT.R2, MCH_SIM_STEP.COLLROT) end end diff --git a/Common_FAST.mlse b/Common_FAST.mlse index f4be8e6..fba0a4c 100644 --- a/Common_FAST.mlse +++ b/Common_FAST.mlse @@ -1111,7 +1111,7 @@ function SpecCalcLoad( dPosT, dDistFront, dDistBack) EgtOutLog( ' *[L2]', 1) end else - -- si pinza sempre a 1000mm massimo + -- altrimenti si pinza sempre a massimo 1000mm dNewYDelta = min( dNewYDelta, 1000) end @@ -1492,6 +1492,7 @@ end --------------------------------------------------------------------- function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF, dVDeltaF, bFixedDelta, bFixedPos) local dYPosA, dVPosA, dTPosA + local dGainOnReclamping = BD.GAIN_RECLAMPING or 1000 -- se primo scambio local MyMinY = EgtIf( EMC.CNT == 1, MinY + AGG_LOAD, MinY) @@ -1568,6 +1569,7 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF dVPosI = dVPosA table.insert( vCmd, { 11, 1}) end + -- se spostando morsa diretto esco dalle corse, calcolo di quanto devo muovere la trave (cioè l'altra morsa) come minimo -- se non era ingaggiata, vado al suo minimo if not EMC.VDELTA then @@ -1580,6 +1582,27 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF dBeamMove = dVPosI + ( dVDeltaF - dVDeltaI) - MaxV end + -- se serve un grande spostamento e si sta pinzando poco. Y trascinatore pinza poco e V si sposta per prima per recuperare + if not BD.FASTCLAMPING and abs( dBeamMove) > 2000 and dDeltaBeam < 0 and EMC.LB - dYDeltaI < max( 550, (MinJoin * 2)) then + table.insert( vCmd, { 12, 0}) + dVPosA = dVPosI - dGainOnReclamping + -- sposto il carrello V di 1000mm + table.insert( vCmd, { 1, 'V', dVPosA}) + table.insert( vCmd, { 12, 1}) + -- apro morsa Y e recupero i 1000mm + table.insert( vCmd, { 11, 0}) + dVPosA = dVPosI + dYPosA = dYPosI + dTPosA = dTPosI + dGainOnReclamping + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + dTPosI = dTPosA + dVPosI = dVPosA + dVDeltaI = dVDeltaI - dGainOnReclamping + dYDeltaI = dYDeltaI - dGainOnReclamping + table.insert( vCmd, { 11, 1}) + dBeamMove = dBeamMove + dGainOnReclamping + end + table.insert( vCmd, { 12, 0}) dTPosA = dTPosI - dBeamMove @@ -1667,6 +1690,27 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF dBeamMove = dYPosI + ( dYDeltaF - dYDeltaI) - MaxY end + -- se serve un grande spostamento e si sta pinzando poco. V trascinatore pinza poco e Y si sposta per prima per recuperare + if not BD.FASTCLAMPING and abs( dBeamMove) > 2000 and dDeltaBeam > 0 and dVDeltaI < max( 550, (MinJoin * 2)) then + table.insert( vCmd, { 11, 0}) + dYPosA = dYPosI + dGainOnReclamping + -- sposto il carrello V di 1000mm + table.insert( vCmd, { 1, 'Y', dYPosA}) + table.insert( vCmd, { 11, 1}) + -- apro morsa Y e recupero i 1000mm + table.insert( vCmd, { 12, 0}) + dVPosA = dVPosI + dYPosA = dYPosI + dTPosA = dTPosI - dGainOnReclamping + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + dTPosI = dTPosA + dVPosI = dVPosA + dVDeltaI = dVDeltaI + dGainOnReclamping + dYDeltaI = dYDeltaI + dGainOnReclamping + table.insert( vCmd, { 12, 1}) + dBeamMove = dBeamMove - dGainOnReclamping + end + table.insert( vCmd, { 11, 0}) dTPosA = dTPosI + dBeamMove @@ -1768,6 +1812,26 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF -- Il trascinatore si decide in base alla direzione di movimento trave -- trascino con morsa allo scarico. Obiettivo mandare Y in posizione per prima if dDeltaBeam > 0 then + -- se serve un grande spostamento e si sta pinzando poco. Y trascinatore pinza poco e V si sposta per prima per recuperare + if not BD.FASTCLAMPING and abs( dDeltaBeam) > 2000 and dVDeltaI < max( 550, (MinJoin * 2)) then + table.insert( vCmd, { 11, 0}) + dYPosA = dYPosI + dGainOnReclamping + -- sposto il carrello V di 1000mm + table.insert( vCmd, { 1, 'Y', dYPosA}) + table.insert( vCmd, { 11, 1}) + -- apro morsa Y e recupero i 1000mm + table.insert( vCmd, { 12, 0}) + dVPosA = dVPosI + dYPosA = dYPosI + dTPosA = dTPosI - dGainOnReclamping + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + dTPosI = dTPosA + dVPosI = dVPosA + dVDeltaI = dVDeltaI + dGainOnReclamping + dYDeltaI = dYDeltaI + dGainOnReclamping + table.insert( vCmd, { 12, 1}) + end + -- apro morsa al carico table.insert( vCmd, { 11, 0}) -- devo recuperare più delle corse disponibili di entrambi i carrelli @@ -1853,6 +1917,26 @@ function SpecAdjustCarriages( vCmd, dTPosI, dYDeltaI, dVDeltaI, dTPosF, dYDeltaF end -- trave si muove dallo scarico verso il carico. Obiettivo mandare V in posizione per prima else + -- se serve un grande spostamento e si sta pinzando poco. Y trascinatore pinza poco e V si sposta per prima per recuperare + if not BD.FASTCLAMPING and abs( dDeltaBeam) > 2000 and EMC.LB - dYDeltaI < max( 550, (MinJoin * 2)) then + table.insert( vCmd, { 12, 0}) + dVPosA = dVPosI - dGainOnReclamping + -- sposto il carrello V di 1000mm + table.insert( vCmd, { 1, 'V', dVPosA}) + table.insert( vCmd, { 12, 1}) + -- apro morsa Y e recupero i 1000mm + table.insert( vCmd, { 11, 0}) + dVPosA = dVPosI + dYPosA = dYPosI + dTPosA = dTPosI + dGainOnReclamping + table.insert( vCmd, { 3, 'Y', dYPosA , 'T', dTPosA, 'V', dVPosA}) + dTPosI = dTPosA + dVPosI = dVPosA + dVDeltaI = dVDeltaI - dGainOnReclamping + dYDeltaI = dYDeltaI - dGainOnReclamping + table.insert( vCmd, { 11, 1}) + end + -- apro morsa allo scarico table.insert( vCmd, { 12, 0}) -- devo recuperare più del doppio delle corse diff --git a/Essetre-FAST.mlde b/Essetre-FAST.mlde index db386d8..031b68b 100644 --- a/Essetre-FAST.mlde +++ b/Essetre-FAST.mlde @@ -66,12 +66,14 @@ -- 2024/09/16 AV ver 2.6i5 Allineamento con common ver. 2.6i2 -- 2024/09/18 LM ver 2.6i6 Modificato YAML per comunicazione versioni a LiMan. Aggiunta PP_NVER, versione in formato numerico. -- 2024/09/23 AV ver 2.6i7 Allineamento con common ver. 2.6i3 +-- 2024/09/24 AV ver 2.6i8 Allineamento con common ver. 2.6i4 +-- 2024/09/24 AV ver 2.6i9 Allineamento con common ver. 2.6i5 require( 'EmtGenerator') EgtEnableDebug( false) -PP_VER = '2.6i7' -PP_NVER = '2.6.9.7' +PP_VER = '2.6i9' +PP_NVER = '2.6.9.9' MIN_MACH_VER = '2.5k1' MACH_NAME = 'Essetre-FAST' diff --git a/UpdateLog.txt b/UpdateLog.txt index d1dd83c..c167a31 100644 --- a/UpdateLog.txt +++ b/UpdateLog.txt @@ -1,5 +1,13 @@ ==== Common_FAST Update Log ==== +Versione 2.6i5 (24/09/2024) +- (SIM-GEN) Tolto controllo su lunghezza maggiore di 200mm introdotto con 2.6i2 perchè non completamente funzionante +- (GEN) Gestione in OnRapid() di EMT.FLAG=5 (rotazione a Z max per lavorazione successiva). Ora allineata alla simulazione + +Versione 2.6i4 (24/09/2024) +- (SIM-GEN) Aggiunto ripinzaggio extra in caso servisse un grande spostamento e si sta pinzando poco. + L'aggiunta del ripinzaggio dipende da FASTCLAMPING (che deve essere disattiva). Viene aggiunta GAIN_RECLAMPING per decidere il guadagno in mm del ripinzaggio. + Versione 2.6i3 (23/09/2024) - (SIM-GEN) Aggiunta nuova strategia riposizionamento morse - (SIM-GEN) Aggiunta lettura flag NEWCLAMPING in BeamData, per abilitare nuova strategia riposizionamento. Se false o nil, funziona con metodo vecchio. diff --git a/Version.lua b/Version.lua index bbe883c..8ee9825 100644 --- a/Version.lua +++ b/Version.lua @@ -3,7 +3,7 @@ local InfoCommon_STD_PP = { NAME = 'Common_FAST', -- nome script PP standard - VERSION = '2.6i3', -- versione script + VERSION = '2.6i5', -- versione script MIN_MACH_VER_PP_COMMON = '2.5k1' -- versione minima kernel }