Miguel
/
Obsidean_VM
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Obsidean_VM/01-Documentation/Vetromeccanica/Micromeccanica Guides/Micromecanica Motor Guides ...

626 lines
19 KiB
Markdown
Raw Blame History

# SCL Scripts Functionality Analysis
***
## Overview of Script Organization
The project consists of several SCL scripts that manage different aspects of the Gateway and Motor-Box control system. Here's a breakdown of the main functional areas:
1. Data Conversion (002_FC, 101_FC)
2. Remote Control (003_FC, 100_FC)
3. System Configuration (004_FC, 020_FC, 021_FC)
4. Alarms Management (010_FC)
5. Operation Modes (030_FC, 032_FC, 035_FC, 036_FC)
6. HMI Interface (050_FC)
Let's analyze each script in detail.
## Data Conversion Scripts
***
### 002_FC Data Read Conversion
This script handles the reading of data from the ADI structures provided by the Gateway and converts it into a more usable format for the PLC program.
**Key functions:**
- Determines which Gateway is active based on mode (Auto or Manual)
- Reads ADI_110 data to extract Gateway firmware and box communication status
- Reads ADI_111 data to extract motor and box status information
- Performs byte-by-byte data mapping including:
- Motor status (forward/backward motion, alarms, position status)
- Box status (firmware version, power issues)
- Repeats the same process for Port 2 (ADI_120, ADI_121) if configured
### 101_FC Data Write Conversion
This script converts the PLC program data format into the proper byte format required by the Gateway ADI structures for writing commands.
**Key functions:**
- Formats motor position commands into ADI_211 byte structure for each motor
- Sets motor direction, position type, stop command, and reset flags
- Configures current limits for both forward and reverse motion in ADI_212
- Repeats the same process for Port 2 (ADI_221, ADI_222) if configured
## Remote Control Scripts
***
### 003_FC Remote Control Read
This script handles data transfer from the I/O controller (remote system) to the Gateway control system.
**Key functions:**
- Reads control word bits from the remote I/O controller
- Reads lifecycle counter and bottle type information
- Checks if local/remote selection is active and accordingly processes or ignores remote commands
### 100_FC Remote Control Write
This script manages data transfer to the I/O controller, sending status information from the Gateway system.
**Key functions:**
- Updates status word bits based on system state (manual mode, changeover status, alarms)
- Sends lifecycle counter, actual bottle type, and required bottle type
- Transfers alarm list to remote system
- Maps all data to appropriate I/O controller data locations
## System Configuration Scripts
***
### 004_FC Zone Activation
A simple script that enables the four operational zones of the system.
### 020_FC Format Parameters
This script manages format changes and recipe handling for different bottle types.
**Key functions:**
- Processes format selection requests (manual or from remote control)
- Initiates and monitors recipe loading process
- Transfers recipe data to zone parameters
- Updates position offset information for each actuator
### 021_FC Area Parameters
This script manages the assignment of actuators to operational zones.
**Key functions:**
- Checks actuator availability for zone configuration
- Assigns actuators to zones in both zone parameters and motor parameters
- Manages actuator configuration errors
- Monitors zones that haven't completed format change
- Checks if format change is complete across all zones
## Alarms Management
***
### 010_FC Alarms
This is a comprehensive script handling all system alarms including:
**Key functions:**
- Box communication alarms for both ports
- Burned fuse detection
- Low voltage detection
- Motor error monitoring
- Gateway communication issues
- Area configuration validation
- Area-specific alarms
- Safety module monitoring
- Area timeout detection
- Recipe loading errors
The script uses various timers for alarm indication and implements a scrolling mechanism to highlight different alarms in sequence.
## Operation Modes Scripts
***
### 030_FC Aut_Man Selection
This script manages the switching between automatic and manual modes.
**Key functions:**
- Processes local/remote selection input
- Uses timers to implement mode switching delays
- Sets the appropriate mode flags (Auto or Man)
### 032_FC Manual Function
This script handles manual control of motors.
**Key functions:**
- Processes manual movement commands (forward, backward, zero/position)
- Implements motor stop logic
- Handles alarm reset functionality
- Manages motor current limitation settings
- Updates HMI with motor status information
### 035_FC Automatic Cycle
This script implements the automatic cycle state machine for the format change process.
**Key functions:**
- Manages 13 states of the automatic cycle (from Manual to Clearing)
- Handles transitions between states based on conditions
- Processes external commands (reset, alarm, format change request)
- Controls the zone state machine
### 036_FC Area Cycle
This script manages the cycling through zones during format changes.
**Key functions:**
- Implements a 7-state zone state machine (from inactive to completion)
- Calculates actuator positions based on bottle dimensions
- Checks if actuators have reached their positions
- Controls actuator commands (zero/position, forward/backward)
- Manages manual movement of zones
- Handles stop commands and alarm reset functionality
## HMI Interface
***
### 050_FC HMI
This script handles the HMI (Human-Machine Interface) functionality.
**Key functions:**
- Controls lamp blinking for visual indicators
- Updates HMI elements based on system state
- Manages screen-specific elements for different HMI screens
- Updates status LEDs for motors and boxes
- Controls stackable light and buzzer based on system state
## Execution Flow
***
The overall execution flow can be summarized as:
1. The system reads configuration from Gateway through data conversion (002_FC)
2. Based on mode (auto/manual), it either:
- In Auto mode: Follows the automatic cycle (035_FC) and area cycle (036_FC) state machines
- In Manual mode: Processes manual commands (032_FC)
3. Commands are sent to Gateway after conversion (101_FC)
4. Alarm conditions are continuously monitored (010_FC)
5. HMI is updated with status information (050_FC)
6. Remote control information is exchanged (003_FC, 100_FC)
The system uses a combination of state machines, timers, and direct command processing to manage the format change process across multiple zones, ensuring actuators move to the correct positions based on bottle dimensions and configuration parameters.
***
### Motor Movement Command Flow Diagram
***
This diagram shows how movement commands flow through the system from various input sources (HMI, Automatic Cycle, Remote Control) to the Gateway and ultimately to the motors. It highlights:
- Different command sources
- Processing through the manual and automatic functions
- Data conversion for Gateway communication
- The structure of movement commands, including the Zero/Position mode
- Feedback flow of motor status information
```mermaid
flowchart TD
subgraph "Input Sources"
HMI["HMI Commands\n(Manual Mode)"]
AUT["Automatic Cycle\n(Auto Mode)"]
RMT["Remote Control\n(External Commands)"]
end
subgraph "Command Processing"
MAN_FUNC["FC032 Manual Function\n- Forward/Backward\n- Zero/Position\n- Stop\n- Reset Alarm"]
AREA_CYC["FC036 Area Cycle\n- Automatic Zero/Position\n- Zone Movement\n- Position Calculation"]
MOV_CMD["Movement Command Generation\n- Position Value\n- Direction\n- Mode\n- Stop/Reset"]
end
subgraph "Data Conversion"
DATA_CONV["FC101 Data Write Conversion\n- Byte/Bit Formatting\n- ADI Structure Mapping"]
end
subgraph "Gateway Communication"
ADI_211["ADI#211/ADI#221\n- Motor Commands Port 1/2"]
ADI_212["ADI#212/ADI#222\n- Current Limits Port 1/2"]
end
subgraph "Feedback Processing"
DATA_READ["FC002 Data Read Conversion\n- Status Interpretation"]
ADI_111["ADI#111/ADI#121\n- Motor Status Port 1/2"]
MOT_STATUS["Motor Status\n- InPosition\n- InZero\n- Moving\n- Alarm"]
end
%% Connections
HMI --> MAN_FUNC
AUT --> AREA_CYC
RMT --> AREA_CYC
MAN_FUNC --> MOV_CMD
AREA_CYC --> MOV_CMD
MOV_CMD --> DATA_CONV
DATA_CONV --> ADI_211
DATA_CONV --> ADI_212
ADI_111 --> DATA_READ
DATA_READ --> MOT_STATUS
MOT_STATUS --> MAN_FUNC
MOT_STATUS --> AREA_CYC
%% Special Motor Commands Breakdown
subgraph "Zero/Position Command Structure (Bit Layout)"
ZP1["Position Value\n(12-bit value 0-4095)"]
ZP2["Direction Sign\n(Bit 4: 1=+, 0=-)"]
ZP3["Position Mode\n(Bit 5: 1=Zero then Position, 0=Relative)"]
ZP4["Stop Motor\n(Bit 6: 1=Stop)"]
ZP5["Reset Alarm\n(Bit 7: 1=Reset)"]
end
MOV_CMD -.-> ZP1
MOV_CMD -.-> ZP2
MOV_CMD -.-> ZP3
MOV_CMD -.-> ZP4
MOV_CMD -.-> ZP5
```
### Data Structures Flow Between Scripts
***
This diagram illustrates how data flows between the different SCL scripts and data blocks in the system:
- Shows all major data blocks (DB Gateway, DB Cycle, DB AreaPar, etc.)
- Maps connections between functional blocks and data storage
- Highlights key cross-function data flows
- Identifies important data elements (ADI structures, motor status, commands)
```mermaid
flowchart TD
subgraph "Data Storage Blocks"
DB_GW["DB Gateway\n- ADI Input/Output\n- Motor Box Control\n- Status Information"]
DB_CYCLE["DB Cycle\n- Operation Mode\n- State Machines\n- Current Zone\n- Format Data"]
DB_AREA["DB AreaPar\n- Zone Configuration\n- Motor Assignments\n- Position Settings"]
DB_HMI["DB HMI\n- UI Parameters\n- User Selections\n- Status Display"]
DB_MOTOR["DB MotorPar\n- Motor Enables\n- Current Limits\n- Zone Assignments"]
DB_ALARMS["DB Alarms\n- Alarm Conditions\n- Error States\n- Diagnostic Info"]
DB_FORMAT["DB FormatPar\n- Recipe Information\n- Format Settings\n- Bottle Parameters"]
DB_REMOTE["DB Remote Control\n- External Commands\n- Status Reporting"]
end
subgraph "Data Flow Functions"
FC002["FC002\nData Read Conversion"]
FC003["FC003\nRemote Control Read"]
FC010["FC010\nAlarms Management"]
FC020["FC020\nFormat Parameters"]
FC021["FC021\nArea Parameters"]
FC030["FC030\nAut/Man Selection"]
FC032["FC032\nManual Function"]
FC035["FC035\nAutomatic Cycle"]
FC036["FC036\nArea Cycle"]
FC050["FC050\nHMI Interface"]
FC100["FC100\nRemote Control Write"]
FC101["FC101\nData Write Conversion"]
end
%% Primary Data Flows
DB_GW <--> FC002
DB_GW <--> FC101
DB_CYCLE <--> FC035
DB_CYCLE <--> FC036
DB_AREA <--> FC021
DB_AREA <--> FC020
DB_AREA <--> FC036
DB_HMI <--> FC050
DB_HMI <--> FC032
DB_MOTOR <--> FC021
DB_MOTOR <--> FC032
DB_MOTOR <--> FC101
DB_ALARMS <--> FC010
DB_FORMAT <--> FC020
DB_REMOTE <--> FC003
DB_REMOTE <--> FC100
%% Cross-Function Data Flows
FC002 --> FC010
FC002 --> FC032
FC002 --> FC036
FC002 --> FC050
FC003 --> FC035
FC020 --> FC036
FC030 --> FC035
FC032 --> FC101
FC035 --> FC036
FC036 --> FC101
FC050 --> FC032
FC010 --> FC100
%% Key Data Elements
subgraph "Key Data Elements"
ADI_IN["ADI Input Structures\n(110, 111, 120, 121)"]
ADI_OUT["ADI Output Structures\n(211, 212, 221, 222)"]
MOT_STAT["Motor Status\n(Position, Alarms, Movement)"]
MOT_CMD["Motor Commands\n(Position, Direction, Mode)"]
AREA_CONF["Area Configuration\n(Assignments, Parameters)"]
BOT_PARAM["Bottle Parameters\n(Dimensions, Distances)"]
ALARM_STAT["Alarm Status\n(Communication, Hardware)"]
end
ADI_IN -.-> DB_GW
DB_GW -.-> ADI_OUT
MOT_STAT -.-> DB_GW
DB_GW -.-> MOT_CMD
AREA_CONF -.-> DB_AREA
BOT_PARAM -.-> DB_FORMAT
ALARM_STAT -.-> DB_ALARMS
```
### Motor Command Sequence Diagram
***
This sequence diagram shows the exact flow of a motor command through the system:
- Step-by-step process from command initiation to execution
- Data conversion through FC101
- Command transmission through Gateway to Motor-Box
- Status feedback loop through FC002
- Command termination and final status
```mermaid
sequenceDiagram
autonumber
participant PLC as PLC Control Logic
participant DBGateway as DB Gateway
participant FC101 as FC101 Data Write Conversion
participant Gateway as Gateway Device
participant MotorBox as Motor-Box
participant Motor as Actuator Motor
participant FC002 as FC002 Data Read Conversion
%% Command Generation
Note over PLC: Movement request initiated
PLC->>DBGateway: Set command parameters in<br>DB Gateway.N[g].write.P[p].MotorBoxCtrl[b].Mot[m]
Note over PLC: Position value, PosType, Sign, Stop, Reset bits set
%% Command Conversion & Formatting
PLC->>FC101: Call data write conversion
FC101->>DBGateway: Format command into ADI structure
Note over FC101: Bit-by-bit mapping to ADI_211/221
FC101->>DBGateway: Map current limits to ADI_212/222
%% Command Transmission
DBGateway->>Gateway: Transmit ADI_211/221 command bytes
Gateway->>MotorBox: Forward command to target Motor-Box
MotorBox->>Motor: Execute motor command
%% Feedback Loop
Motor->>MotorBox: Return status (moving, position, alarm)
MotorBox->>Gateway: Send status data
Gateway->>DBGateway: Update ADI_111/121 structures
DBGateway->>FC002: Call data read conversion
FC002->>DBGateway: Update status in structured format
DBGateway->>PLC: Status available for program logic
%% Command Termination
alt In Position Reached
PLC->>DBGateway: Clear command (detected from status)
else Stop Requested
PLC->>DBGateway: Send explicit stop command
end
%% Final Command Flow
PLC->>FC101: Convert final command
FC101->>DBGateway: Update ADI structure
DBGateway->>Gateway: Transmit final command
Gateway->>MotorBox: Forward to Motor-Box
MotorBox->>Motor: Execute final command (stop)
```
### Automatic Cycle and Zone State Machines
***
This diagram illustrates the state machines that control automatic operation:
- Automatic Cycle State Machine (FC035) with all 13 states
- Zone State Machine (FC036) with 7 states
- Manual Control Functions
- Transitions between states and conditions that trigger them
```mermaid
stateDiagram-v2
[*] --> Manual: System Start
state "Automatic Cycle State Machine (FC035)" as AutoCycle {
state "00 - Manual" as Auto00
state "01 - Stopped" as Auto01
state "02 - Resetting" as Auto02
state "03 - Idle" as Auto03
state "04 - Starting" as Auto04
state "05 - Execute" as Auto05
state "06 - Completing" as Auto06
state "07 - Complete" as Auto07
state "10 - Stopping" as Auto10
state "11 - Aborting" as Auto11
state "12 - Aborted" as Auto12
state "13 - Clearing" as Auto13
Auto00 --> Auto01 : Auto Mode Selected
Auto01 --> Auto02 : Reset Pressed
Auto02 --> Auto03 : No Area Alarms
Auto03 --> Auto04 : Auto Start Delay Complete
Auto04 --> Auto05 : Configure Initial Zone
Auto05 --> Auto10 : Stop Request
Auto05 --> Auto11 : Alarm Condition
Auto05 --> Auto06 : All Zones Complete
Auto06 --> Auto07 : Update Format Status
Auto07 --> Auto01 : Reset Pressed
Auto10 --> Auto01 : Zone Stopped
Auto11 --> Auto12 : Zone Stopped
Auto12 --> Auto01 : Reset Pressed
Auto13 --> Auto01 : No Active Alarms
}
state "Zone State Machine (FC036)" as ZoneSM {
state "00 - Disabled" as Zone00
state "01 - Format Change Required" as Zone01
state "02 - Initial Zone Assignment" as Zone02
state "03 - Load Positions" as Zone03
state "04 - Start Actuators" as Zone04
state "05 - Stop Actuators" as Zone05
state "06 - Zone Completion" as Zone06
Zone00 --> Zone01 : Format Changed
Zone01 --> Zone02 : Auto Cycle Execute
Zone02 --> Zone03 : Recipe Loaded
Zone03 --> Zone04 : Positions Calculated
Zone04 --> Zone05 : All Motors In Position
Zone05 --> Zone06 : All Motors Stopped
Zone06 --> Zone02 : More Zones To Process
Zone06 --> Auto06 : All Zones Complete
}
state "Manual Control Functions (FC032)" as ManualFuncs {
state "Forward/Backward Movement" as ManMove
state "Zero/Position Command" as ManZero
state "Stop Command" as ManStop
state "Reset Alarm" as ManReset
}
Manual --> AutoCycle : Auto Mode
AutoCycle --> Manual : Manual Mode
Manual --> ManualFuncs : Manual Commands
AutoCycle --> ZoneSM : Auto Cycle Execute
```
### Command Data Structure Diagram
***
This class diagram shows the detailed structure of command data:
- Hierarchical organization of DB Gateway data
- Structure of port, box, and motor specific information
- Command and status data fields
- Command structure interfaces showing bit layouts
- Current limit structure with value definitions
```mermaid
classDiagram
class DBGateway {
+Array[8] N[Gateway]
}
class Gateway {
+Struct read
+Struct write
}
class GatewayRead {
+Array[2] P[Port]
+Array[] ADI_110
+Array[] ADI_111
+Array[] ADI_120
+Array[] ADI_121
}
class GatewayWrite {
+Array[2] P[Port]
+Array[] ADI_211
+Array[] ADI_212
+Array[] ADI_221
+Array[] ADI_222
}
class PortRead {
+USINT MboxNumber
+USINT Firmware
+Array[32] BoxCommunication[Box]
+Array[32] MotorsBoxStatus[Box]
}
class PortWrite {
+Array[32] MotorBoxCtrl[Box]
}
class MotorBoxStatus {
+Array[8] MotorStatus[Motor]
+Struct BoxStatus
}
class MotorStatus {
+BOOL MovingFW
+BOOL MovingBW
+BOOL InPOS
+BOOL Alarm
+BOOL InZero
+BOOL MovingSlowly
+BOOL Reserved1
+BOOL Reserved2
}
class BoxStatus {
+USINT FirmwareVersion
+USINT FirmwareRevision
+BOOL BurnedFuse
+BOOL Undervoltage
}
class MotorBoxCtrl {
+Array[8] Mot[Motor]
}
class MotorCommand {
+INT Position
+BOOL Sign
+BOOL PosType
+BOOL Stop
+BOOL Reset
}
DBGateway "1" *-- "8" Gateway
Gateway "1" *-- "1" GatewayRead
Gateway "1" *-- "1" GatewayWrite
GatewayRead "1" *-- "2" PortRead
GatewayWrite "1" *-- "2" PortWrite
PortRead "1" *-- "32" MotorBoxStatus
PortWrite "1" *-- "32" MotorBoxCtrl
MotorBoxStatus "1" *-- "8" MotorStatus
MotorBoxStatus "1" *-- "1" BoxStatus
MotorBoxCtrl "1" *-- "8" MotorCommand
%% ADI Structure notes
class CommandStructure {
<<Interface>>
Position: 12-bit value (0-4095)
Sign: 1=positive, 0=negative
PosType: 1=Zero then Position, 0=Relative
Stop: 1=stop motor, 0=continue movement
Reset: 1=reset alarm, 0=normal operation
}
class CurrentLimitStructure {
<<Interface>>
Bits 0-2: Reverse current limit
Bits 3-5: Forward current limit
000: 650mA (default)
001: 200mA
010: 300mA
011: 400mA
100: 500mA
101: 600mA
110: 700mA
111: 800mA
}
MotorCommand ..|> CommandStructure
```
Reference in New Issue View Git Blame Copy Permalink