***

# Vetromeccanica Remote Format Changeover Process

This document describes the remote format changeover functionality as implemented in the `FormatManagementQE1_G` function block (FC800) on the Vetromeccanica Q1 PLC for the TL2x line. The Q1s PLC coordinates the changeover process, interacting with an operator via HMI, the master line PLC (Henkel), other Vetromeccanica machines on the line, and external systems like AUTEFA and Alpla.

## General Concept

The process is managed by a state machine controlled by the `FormatChangeCycle` variable. The Q1 PLC acts as a local coordinator for its section of the line (including Merger and Guides) and synchronizes with the overall line state via signals from a supervisory PLC.

## Prerequisites

For the remote changeover to be initiated, the following conditions must be met:
1.  **Remote Mode Enabled**: The operator must select remote format change on the HMI, which sets the `"FormatManagementQE1_D".RemoteSelector` flag to `TRUE`.
2.  **Line Ready for Emptying**: The supervisory PLC (Henkel) must signal that the current production batch is finished by sending `0` in the `"ComSV".TL25_WriteToSv.FromHenkel.SignalExchange.Filler.CalculatedBottlesRemainingToFill` variable.
3.  **Next SKU Information**: Information about the next product (`"FormatManagementQE1_D".NextSku`) must be available from the Alpla system via the supervisor.

To enable the Remote change-over we need to enable on the following page:

![[Pasted image 20250731131434.png]]


## State Machine Workflow

The core logic resides in a state machine. The main states and their functions are:

### State 1: `FormatChange_Enabled`
- The system enters this state once Remote Mode is active.
- It continuously monitors `CalculatedBottlesRemainigToFill`.
- When this value becomes `0`, the PLC reads the current and next batch information (SKU, IDH, PO numbers) from the supervisory PLC.
- It then transitions to State 2 (`FormatChange_Emptying`).

### State 2: `FormatChange_Emptying`
- The PLC compares the current bottle type (`"DB HMI Recipe Bottle".number_set_data`) with the next scheduled one (`"FormatManagementQE1_D".NextSku.ProdFamily`).
- **If the format is the same**: It determines a change is not required, shows a `PopUp_LineReady` (2000) message, and moves to State 5 (`FormatChange_NotNecessary`).
- **If the format is different**:
    - A pop-up (`PopUp_EmptyStart` - 2001) is displayed on the HMI, asking the operator to confirm the start of the line emptying process.
    - Upon operator confirmation (`HMI_PopUp.Yes`):
        - The PLC sets the `"FormatManagementQE1_D".EmptyingStart` flag.
        - It sends `MachineEmpty` commands to the relevant machinery (e.g., Merger).
        - A new pop-up (`PopUp_EmptyEnd` - 2002) is shown to signal that the emptying process has begun.
    - Once the line machines confirm they are empty, and the operator confirms via the `PopUp_EmptyEnd` dialog, the system transitions to State 3 (`FormatChange_InProgress`).
    - The Transport to carry on also need #"Line Empty" memory that is all photocells clear set on the FC380 -> "ComSV".TL25_WriteToSv.ToSV.STW.QE1.MachineEmpty. 



If the system 
### State 3: `FormatChange_InProgress`
- This is the main state where the physical changeover occurs.
- The PLC triggers the loading of the new remote recipe by activating `"Rt_LoadRemoteRecipe"`. This sends a command (Job `70`) to the HMI system.
- It signals to AUTEFA that a changeover is active (`"ComSV".TL25_WriteToSv.ToAutefa.dw0.x[] := TRUE`).
- It monitors the status of the recipe download (`"DB HMI".DBW_36`). A value of `4` indicates success, while `12` indicates an error.
- It waits for confirmations from all local machines that the changeover is complete (e.g., `"FormatManagementQE1_D".EndFormatManagement.Q`, `"Ap_LifterGuideInPositon"`).
- **On Success**: When all machines are ready and in position for the new format, it shows a `PopUp_LineReady` (2000) message and awaits final operator confirmation.
- **On Failure**: If there's a recipe load error or a machine fails to complete its changeover, it moves to State 6 (`FormatChange_Error`).

### State 4: `FormatChange_Done`
- After the final operator confirmation in State 3, the system enters this `Done` state.
- It sends the `BatchLast` information to the Alpla system.
- It signals to the Henkel PLC that the line is ready for production (`LineStatus.di0.x[]`).
- It resets internal flags and awaits a new `CalculatedBottlesRemainigToFill` value to transition back to State 1 for the next changeover.

### State 5: `FormatChange_NotNecessary`
- Entered when the current and next SKU are identical.
- It displays a `PopUp_LineReady` message.
- Upon operator confirmation, it moves to the `FormatChange_Done` state to finalize the (skipped) cycle.

### State 6: `FormatChange_Error`
- This state is entered if any error occurs during the process (e.g., recipe load failure, machine timeout).
- Specific alarms are raised (e.g., `A371_23_0` for recipe error, `A371_23_1` for machine error).
- The operator must acknowledge the error via a `Reset` button (`"DB TT Run".TT_Run.IN_PB_Reset`).
- Depending on the error, the system may attempt to retry the operation by transitioning back to State 3 (`FormatChange_InProgress`) or require further manual intervention.




Important Signals From HENKEL - Vetro - AUTEFA

![[Pasted image 20250731115919.png]]

FromHenkel : Data_From_EbConvey[0].0 : Request Signal To Start ChangeOver
FromHenkel : Data_From_EbConvey[0].1 : Reset Signal To Restart all Counter
FromHenkel : Data_From_EbConvey[0].2 : ChangeOver Complete
FromHenkel : Data_From_EbConvey[0].3 : Production Ready


![[Pasted image 20250731115940.png]]

ToHenkel : Data_From_EbConvey[0].0 : Line is busy with ChangeOver
ToHenkel : Data_From_EbConvey[0].1 : ChangeOver is finished and ready
ToHenkel : Data_From_EbConvey[0].2 : IDH_BTL_NEXT Proper: 1 = Found / 0 = Not Found


![[Pasted image 20250731115959.png]]

ToAutefa: x[0] : Reset
ToAutefa: x[1] : Request Signal To Start Changeover


### Change Over STEPs - 

```plantuml
@startuml
title Changeover STEPs
hide footbox
skinparam ArrowHeadColor none
skinparam NoteBackgroundColor #F0F0F0
skinparam NoteBorderColor #999999
skinparam ParticipantPadding 100
skinparam BoxPadding 6
skinparam WrapWidth 250
!pragma teoz true

' ==== Estilos reutilizables ====
!define VAR(x) <back:#F0F0F0><color:#7F6000><b>x</b></color></back>
!define SIG(x) <back:#F0F0F0><color:#005A9E><b>x</b></color></back>
!define FROM(x) <back:#FFAAAA><color:#000000><b>x</b></color></back>
!define TO(x) <back:#AAFFFF><color:#000000><b> x</b></color></back>

!definelong Nota($donde, $text)
  note over $donde
  $text
  end note
!enddefinelong

!definelong NotaParalela($donde, $text)
  / note over $donde 
  $text
  end note
!enddefinelong

!definelong Variable($donde, $text)
  hnote right $donde #AAFFFF
  $text
  end note
!enddefinelong

!definelong VariableRojo($donde, $text)
  hnote right $donde #FFBBBB
  $text
  end note
!enddefinelong

!definelong VariableIzquierda($donde, $text)
  hnote left $donde #AAFFFF
  $text
  end note
!enddefinelong

!definelong VariableCentro($donde, $text)
  hnote over $donde #AAFFFF
  $text
  end note
!enddefinelong

!definelong VariableParalelo($donde, $text)
  / hnote right $donde #AAFFFF
  $text
  end note
!enddefinelong


participant HENKEL as H
participant Alpla as A
participant Vetromeccanica as V
participant AUTEFA as U

== Before Changeover ==
H -> A : Send VAR(IDH_BTL_NEXT) number to be validated

Nota(A,Validate VAR(IDH_BTL_NEXT) and send acknowledge)
Variable(A,Data_From_EbConvey[0].2)
& A -> H : VAR(IDH_BTL_NEXT) validated

== Step 1 ==
Nota(H,Operator manually selects "Line Clearance" (?) and send signal "0" on VAR(CalculatedBottlesRemainingToFill).)
VariableCentro(H,Data_To_EbConvey[23])
H -> V : Send VAR(CalculatedBottlesRemainingToFill) = 0

== Step 2 ==
NotaParalela(V,Show Popup to Start Empting Line and Mergers)
Variable(U,TG10 Send 0 in Bottles for Actual Batch)
& V -> U : Send 0 in Bottles for Actual Batch
Nota(A,Stops taking bottles out of trays and sends what is already on the tables and conveyors.)
NotaParalela(U,Stops taking bottles out of trays and sends what is already on the tables and conveyors.)
== Step 3 ==
Nota(H,Operator verifies line is empty and sends "changeover request" signal after last bottle goes through filler.)
Variable(V,Data_To_EbConvey[0].0)
& H -> V : Send Changeover Request

== Step 4 ==
Nota(V,'Operator verifies line is empty and sends "line is busy with changeover",confirming on Popup screen')
Variable(V,Data_From_EbConvey[0].0)
& V -> H : Line is busy with changeover

== Step 5 ==
Nota(V,Starts changeover)
NotaParalela(U,Starts changeover)

VariableIzquierda(V,..FromAutefa.dw0.x[24])
& U -> V : Line is busy with changeover

Variable(V,Data_From_EbConvey[0].0)
& V -> H: Send Changeover Request
Variable(U,Data_From_EbConvey[0].0)
& U -> H: Send Changeover Request

== Step 6 ==
Nota(V,Ends changeover)
NotaParalela(U,Ends changeover)

Variable(V,Data_From_EbConvey[0].1)
& V o-> H: Send Changeover Complete
Variable(U,Data_From_EbConvey[0].1)
& U o-> H: Send Changeover Complete

== Step 7 ==
Variable(V,Data_To_EbConvey[0].1)
& H -> V : Reset Counters
Nota(V,Reset Counters)

== Step 8 ==
Nota(H,Send new value on VAR(CalculatedBottlesRemainingToFill))
Variable(V,Data_To_EbConvey[23])
& H -> V : VAR(CalculatedBottlesRemainingToFill > 0)

== Step 9 ==
Nota(H,Send Changeover Complete. To be considered "Production Ready")
Variable(V,Data_To_EbConvey[0].2)
& H -> V : Changeover Complete
NotaParalela(V,Finish Changeover Cycle - Start Line)
NotaParalela(A,Starts conveying bottles.)
NotaParalela(U,Starts conveying bottles.)

@enduml

```


### Current changeover process

```plantuml
@startuml
  
skinparam rectangle {
 FontSize 14
 Padding 4
 Margin 5
 roundCorner 25
}
skinparam defaultTextAlignment center
  
' We use the Business Process sprite (simple ArchiMate style)
sprite $bProcess jar:archimate/application-service
sprite $aOperator jar:archimate/actor
sprite $aMaintOp jar:archimate/technology-device
sprite $aEvent jar:archimate/event
sprite $aColaboration jar:archimate/communication-path
  
' === BLOCKS ===
rectangle "Henkel tank reaches\n5 feet of liquid" as A <<$aEvent>> #ff0000
rectangle "Henkel operator notifies\nby radio to Alpla to collect\nchange form" as B <<$aColaboration>> #8CD96B
rectangle "Henkel tank empties" as C <<$aEvent>> #ff0000
rectangle "Henkel operator calls\nto put TLO in manual" as D <<$aOperator>> #ff0000
  
rectangle "Henkel runs out of product\non the line" as E <<$aEvent>> #ff0000
rectangle "Alpla operator moves\nremaining pallets manually" as F <<$aOperator>> #8CD96B
rectangle "Operator changes AVID\nand requests new pallets" as G <<$aOperator>> #8CD96B
  
rectangle "Operator calls maintenance\nto adjust Vetro to new format" as H <<$aColaboration>> #8CD96B
rectangle "Operator accepts new AVID\nin rotators 1 and 2" as I <<technology-device>> #8CD96B
rectangle "Operator changes format parts\nin rotators 1 and 2" as J <<$aOperator>> #8CD96B
  
rectangle "Operator notifies by radio that\nHenkel Alpla is ready" as K <<$aOperator>> #8CD96B
rectangle "Operator puts line in automatic\nat Henkel's request" as L <<$aMaintOp>> #8CD96B
  
rectangle "Maintenance starts change\nVetro conveyors" as M <<$aMaintOp>> #FFC933
rectangle "Maintenance changes\nKeyence camera" as N <<$aMaintOp>> #FFC933
rectangle "Maintenance verifies complete\nchange of conveyors" as O <<$aMaintOp>> #FFC933
  
' === FLOW UP TO E (left->right by default) ===
A -right-> B
B -right-> C
C -down-> D
D -left-> E
  
' === FROM E: FORCE TOP-DOWN ===
E -down-> F
F -left-> G
G -left-> H
H -down-> I
I -down-> J
J -down-> K
K -down-> L
  
' === MAINTENANCE: lateral and vertical branch ===
H -down-> M
M -down-> N
N -down-> O
  
@enduml
```

### Current auto batch handling change over process

```plantuml
@startuml
skinparam rectangle {
  FontSize 14
  Padding 4
  Margin 5
  roundCorner 25
}
skinparam defaultTextAlignment center

' Sprites (mismos que en tu ejemplo)
sprite $bProcess jar:archimate/application-service
sprite $aOperator jar:archimate/actor
sprite $aMaintOp jar:archimate/technology-device
sprite $aEvent jar:archimate/event
sprite $aColaboration jar:archimate/communication-path

' === BLOCKS (diagram translation) ===
' Initial event
rectangle "Henkel tank reaches\n0 ft" as A <<$aEvent>> #ff0000

' System reaction (top)
rectangle "TLO automatically stops\nsending bottles" as B1 <<$bProcess>> #0B5FA5
rectangle "Henkel line runs out\nof product (run-out)" as C1 <<$aEvent>> #ff0000

' Change request (below initial)
rectangle "Change request sent\nto Alpla HMI" as B2 <<$bProcess>> #0B5FA5
rectangle "Alpla operator accepts\nnew AVID from Henkel in SCO" as C2 <<$aOperator>> #8CD96B
rectangle "Alpla operator selects\nwhich TLO will run the new AVID" as D2 <<$aOperator>> #8CD96B
rectangle "Alpla operator walks\nto the TLO" as E2 <<$aOperator>> #8CD96B
rectangle "Alpla operator moves\nremaining trays to\nthe empty conveyor" as F2 <<$aOperator>> #8CD96B
rectangle "Alpla operator accepts\nthe new AVID in the TLO\nand requests stacks" as G2 <<$aOperator>> #8CD96B

' Maintenance branch
rectangle "Operator calls maintenance\nto adjust Vetro conveyor\nto new format" as H2 <<$aColaboration>> #8CD96B
rectangle "Maintenance accepts\nnew AVID in Vetro HMI\nand begins conveyor change" as M1 <<$aMaintOp>> #FFC933
rectangle "Maintenance performs\nKeyence camera change" as M2 <<$aMaintOp>> #FFC933
rectangle "Maintenance verifies\nVetro conveyor change\ncompleted" as M3 <<$aMaintOp>> #FFC933

' Rotator adjustments
rectangle "Operator accepts new AVID\nin rotators 1 and 2" as I2 <<$aOperator>> #8CD96B
rectangle "Operator changes format parts\nin rotators 1 and 2" as J2 <<$aOperator>> #8CD96B
rectangle "Operator notifies by radio that\nHenkel/Alpla is ready to\nsend bottles" as K2 <<$aOperator>> #8CD96B
rectangle "At Henkel's request, operator\nputs line in automatic" as L2 <<$aMaintOp>> #8CD96B

' === FLOWS ===
' Upper branch (event -> system)
A -up-> B1
B1 -right-> C1

' Main branch (event -> request -> TLO actions)
A -right-> B2
B2 -right-> C2
C2 -right-> D2
D2 -right-> E2
E2 -down-> F2
F2 -left-> G2
G2 -left-> H2

' Lateral maintenance branch
H2 -left-> M1
M1 -down-> M2
M2 -down-> M3

' Rotator adjustments and closure
H2 -down-> I2
I2 -down-> J2
J2 -right-> K2
K2 -right-> L2

@enduml

```

### Desired auto batch process:

```plantuml
@startuml
skinparam rectangle {
  FontSize 14
  Padding 4
  Margin 5
    roundCorner 25
}
skinparam defaultTextAlignment center

' Sprites (mismos que antes)
sprite $bProcess jar:archimate/application-service
sprite $aOperator jar:archimate/actor
sprite $aMaintOp jar:archimate/technology-device
sprite $aEvent jar:archimate/event
sprite $aColaboration jar:archimate/communication-path

' === BLOCKS ===
' Henkel events/states
rectangle "Henkel tank reaches\n0 remaining bottles" as A <<$aEvent>> #ff0000
rectangle "Henkel runs out of\nproduct on the line" as E <<$aEvent>> #ff0000

' Systems (blue)
rectangle "TLO automatically stops\nsending bottles" as B <<$bProcess>> #0B5FA5
rectangle "Change request sent\nto Alpla HMI" as C <<$bProcess>> #0B5FA5
rectangle "Vetro conveyor and Keyence\ncamera initiate format change" as V1 <<$bProcess>> #0B5FA5
rectangle "Autefa system removes trays/\nexcess stacks from TLO" as S1 <<$bProcess>> #0B5FA5
rectangle "Autefa system requests new\nbottles from warehouse" as S2 <<$bProcess>> #0B5FA5
rectangle "Henkel sends signal to Autefa\nto release bottles" as Z <<$bProcess>> #0B5FA5

' Alpla operation (green)
rectangle "Alpla operator accepts the\nnew AVID from Henkel in SCO\nand defines which TLO will run it" as D <<$aOperator>> #8CD96B
rectangle "Alpla operator changes format\nparts in rotators 1 and 2" as F1 <<$aOperator>> #8CD96B
rectangle "Alpla operator verifies\ncomplete format change\nin all systems" as F2 <<$aOperator>> #8CD96B

' === FLOWS ===
A -down-> B
B -right-> E

A -right-> C
C -right-> D

E -right-> V1

' Autefa branch and format adjustment
D -right-> S1
S1 -down-> S2
S2 -down-> F1
F1 -down-> F2
F2 -right-> Z

' Vetro/Keyence branch towards final verification
D -down-> V1
V1 -down-> F2

@enduml

```