using multiple sequence names for the same operation, because different controllers and different programmers are using different masks for this "checkpoints"
hello let's start with a simple code, and develop :
Code:
[ p1.min ]
NAT02 CALL OS01 ( operation is executed with tool number 2 )
NAT04 CALL OS02 ( ... ... ... ... ... ... ... ... ... .. 4 )
NAT06 CALL OS03 ( ... ... ... ... ... ... ... ... ... .. 6 )
NAT08 CALL OS04 ( ... ... ... ... ... ... ... ... ... .. 8 )
from whatever reason, operation 2 has to be canceled, so let's use some brakets :
Code:
[ p1.min ]
NAT02 CALL OS01 ( operation is executed with tool number 2 )
NAT04 ( CALL OS02 ) ( ... ... ... ... ... ... ... ... ... .. 4 )
NAT06 CALL OS03 ( ... ... ... ... ... ... ... ... ... .. 6 )
NAT08 CALL OS04 ( ... ... ... ... ... ... ... ... ... .. 8 )
using brakets requires too many keystrokes, so let's pass the tool&offset number by using LINK variable; 2nd operation will be skipped, because LINK<0; like this activating/deactivating operations is done with minimal code edit
Code:
[ p1.min ]
NAT02 CALL OS01 LINK = +02 ( operation is executed with tool number 2 )
NAT04 CALL OS02 LINK = -04 ( ... ... ... ... ... ... ... ... ... .. 4 )
NAT06 CALL OS03 LINK = +06 ( ... ... ... ... ... ... ... ... ... .. 6 )
NAT08 CALL OS04 LINK = +08 ( ... ... ... ... ... ... ... ... ... .. 8 )
now let's consider that 3rd operation needs to be restarted; if it is not known that 3rd operation is done with tool 6, then is needed to open the door and check the turret, or look inside the program ... this requires too much time, so let's add a 2nd layer of sequences for each operation; like this, operation 3 will be restarted with NN03, thus, avoiding to inspect the turret or the program
Code:
[ p1.min ]
NN01 NOEX
NAT02 CALL OS01 LINK = +02
NN02 NOEX
NAT04 CALL OS02 LINK = -04
NN03 NOEX
NAT06 CALL OS03 LINK = +06
NN04 NOEX
NAT08 CALL OS04 LINK = +08
i like to use NN+operation_number more then NAT+tool_number, because NN** seems to me more intuitive; also, i preffer to remove the "A" from NAT, so to reduce the number of keystrokes; as a result, code from above becomes :
Code:
[ p1.min ]
NT02 NOEX ( tool 2 will be used )
NN01 CALL OS01 LINK = +02 ( operation 1 )
NT04 NOEX ( tool 4 will be used )
NN02 CALL OS02 LINK = -04 ( operation 2 )
NT06 NOEX ( tool 6 will be used )
NN03 CALL OS03 LINK = +06 ( operation 3 )
NT08 NOEX ( tool 8 will be used )
NN04 CALL OS04 LINK = +08 ( operation 4 )
so far so goo for single programs it seems enough to use 2 types of sequence names for each operation
now, please, let's consider that there are 2 programs ( ssb type, not min type ), and those programs are runned by a master program ( min type ) :
... 1st program uses tools 2 4 6 8 10
... 2nd program uses tools 1 3 5 7 10 10
*each program has 2sequences for each operation :
Code:
[ united.min ]
call p1.ssb
call p2.ssb
[ p1.ssb ]
NT02 NOEX
NN01 CALL OS01 LINK = +02
NT04 NOEX
NN02 CALL OS02 LINK = -04
NT06 NOEX
NN03 CALL OS03 LINK = +06
NT08 NOEX
NN04 CALL OS04 LINK = +08
NT10 NOEX
NN05 CALL OS05 LINK = +10
[ p2.ssb ]
NT01 NOEX
NN01 CALL OS15 LINK = +01
NT03 NOEX
NN02 CALL OS16 LINK = +03
NT05 NOEX
NN03 CALL OS17 LINK = +05
NT07 NOEX
NN04 CALL OS18 LINK = +07
NT10 NOEX
NN05 CALL OS19 LINK = +10
NT10 NOEX
NN06 CALL OS20 LINK = +10
structure from above allows to replace " sdf + pselect " with " min + call ", when there is no problem with memory; as a result, all these disadvatanges, specific to sdf files, are gone :
... spindle stops between programs
... there is a small delay between programs, during when the program is loaded, and this leads to visible downtime
... there are too many keystrokes required to re-start, involving selecting the program, etc
now, let's say that i wish to restart 6th operation inside 2nd program; to do this, i can restart in 2 ways :
... NT10 order 3
... NN06 order 1
it will work, but why should i pay attention to order number ? why loose time to remember or to dig for the order number ? to handle this, let's add a 3rd layer of sequences :
Code:
[ united.min ]
call p1.ssb
call p2.ssb
[ p1.ssb ]
NP01 NOEX ( general counter : operation 01 )
NT02 NOEX
NN01 CALL OS01 LINK = +02
NP02 NOEX ( general counter : operation 02 )
NT04 NOEX
NN02 CALL OS02 LINK = -04
NP03 NOEX ( general counter : operation 03 )
NT06 NOEX
NN03 CALL OS03 LINK = +06
NP04 NOEX ( general counter : operation 04 )
NT08 NOEX
NN04 CALL OS04 LINK = +08
NP05 NOEX ( general counter : operation 05 )
NT10 NOEX
NN05 CALL OS05 LINK = +10
[ p2.ssb ]
NP06 NOEX ( general counter : operation 06 )
NT01 NOEX
NN01 CALL OS15 LINK = +01
NP07 NOEX ( general counter : operation 07 )
NT03 NOEX
NN02 CALL OS16 LINK = +03
NP08 NOEX ( general counter : operation 08 )
NT05 NOEX
NN03 CALL OS17 LINK = +05
NP09 NOEX ( general counter : operation 09 )
NT07 NOEX
NN04 CALL OS18 LINK = +07
NP10 NOEX ( general counter : operation 10 )
NT10 NOEX
NN05 CALL OS19 LINK = +10
NP11 NOEX ( general counter : operation 11 )
NT10 NOEX
NN06 CALL OS20 LINK = +10
like this, if i wish to restart 6th operation inside program 2, i simply restart on NP11; idea, behind it, is that a part can be delivered by having all operations inside a program, inside multiple programs, or inside conditional looped codes, etc ... in the end, regardless of program arhitecture, a unique label is attached, removing the need to inspect the program
after i create a program, if needed, i also deliver documentation ( machine setup + operation etc ). including the restart sequence
during testing, i have used 9 sequences for each operation, but i generaly use only 2 or 3 :
... single programs : NT+tool, NN+operation_number
... linked programs : NP+general_operation_number
video shared in previous post is about testing all these things shared so far; there is also a log that shows if an operation is runned in continuous mode, or if it had been restarted
as for the future, i wish to restart with a single keystroke / kindly