15 KiB

Raw Blame History

Accumulation Table System Documentation

System Overview

The Accumulation Table System is a PLC-based control solution for a test ring facility designed to handle two different bottle formats. The system manages bottle accumulation, divider/combiner operations, and format switching capabilities for individual bottle handling.

System Architecture

The system is built around several key components:

Main Controller: FC_Ttop_Run.scl - Main execution control function
Device Configuration: FC_Ttop_Devices.scl - Device setup and configuration
Accumulation Logic: FB_AccumTable.scl - Core accumulation table function block
Motor Management: FB_Motors_Manage.scl - Universal motor control block
Format Management: FC_FormatCheck.scl - Format change coordination

Core Components Analysis

1. FC_Ttop_Devices.scl

This function is responsible for device configuration and initialization of the table top system.

Key Features:

Recipe Configuration: Sets speed, position, and timing parameters for all devices
Area Management: Configures infeed, outfeed, and channel areas with their respective recipes
Motor Coordination: Links all motors with their specific function blocks
Format Handling: Updates guide positions based on format requirements

Critical Configuration Parameters:

// Channel Area Configuration
"FB_AccumTable_DB".Area_Channel[n].Recipe.Length := 11600;
"FB_AccumTable_DB".Area_Channel[n].Recipe.End_Area := 300;
"FB_AccumTable_DB".Area_Channel[n].Recipe.Initial_Area := 500;
"FB_AccumTable_DB".Area_Channel[n].Recipe.Outfeed_Safety_Area := 2000;

Motor Integration:

Infeed Table Motors: M31610 (Left), M31710 (Right)
Outfeed Table Motors: M34110 (Left), M34210 (Right)
Channel Motors: U32810-U33610 (Channels 1-9)
Guide Motors: M31810 (Infeed), M34310 (Outfeed)

2. FB_AccumTable.scl

The main function block managing the accumulation table operations.

Input Parameters:

i_Reset_AllCounters: System reset signal
i_Pth_Min_Accumulation: Minimum accumulation photocell
i_Pth_Count_Input: Input counting photocell
i_Pth_Safety_Selector_Input: Input selector safety photocell
i_Pth_Safety_Selector_Output: Output selector safety photocell
i_Pth_Count_Output: Output counting photocell
i_Pth_Max_Accumulation: Maximum accumulation photocell
i_GuidesInPosition: Guide positioning confirmation
i_Nominal_Speed: Base speed reference (1000.0 mm/sec)
i_Bottle_Size: Bottle dimensions (100.0 mm)
i_Bottle_Gap: Gap between bottles (5.0 mm)

Output Parameters:

o_Load_Finish: Load operation completion signal
o_Unload_Finish: Unload operation completion signal

Core Logic Structure:

The system operates through a state machine with multiple cycle steps managing:

Channel Selection: Automatic selection of available channels for bottle routing
Speed Calculation: Dynamic speed adjustment based on bottle parameters
Area Tracking: Virtual encoder simulation for bottle tracking
Safety Management: Photocell-based safety zone monitoring

Key Algorithms:

Speed Factor Calculation:

IF "i_Bottle_Gap" > 0 AND "i_Bottle_Size" > 0 THEN
    "k_Factor" := 1.0 + ("i_Bottle_Gap" / "i_Bottle_Size");
ELSE
    "k_Factor" := 1.0;
END_IF;

State Machine Operation (CASE Logic)

The FB_AccumTable operates through a comprehensive state machine implemented via a CASE statement based on #Status.Cycle_Step. This state machine manages all operational modes and transitions.

State Machine Architecture

stateDiagram-v2
    [*] --> Idle
    Idle --> Bypass_Setup: No Load/Unload Request
    Idle --> Loading_Mode: Load Request
    Idle --> UnLoading_Mode: Unload Request
    
    Bypass_Setup --> Bypass_Mode: Selectors Positioned
    Bypass_Mode --> Loading_Mode: Load Request
    Bypass_Mode --> UnLoading_Mode: Unload Request
    
    Loading_Mode --> Load_Ch1: Format Sx
    Loading_Mode --> Load_Ch9: Format Dx
    Loading_Mode --> Idle: No Space Available
    
    Load_Ch1 --> Load_Ch2: Channel 1 Full
    Load_Ch2 --> Load_Ch3: Channel 2 Full
    Load_Ch3 --> Load_Ch4: Channel 3 Full
    Load_Ch4 --> Idle: Channel 4 Full/Timeout
    
    Load_Ch9 --> Load_Ch8: Channel 9 Full
    Load_Ch8 --> Load_Ch7: Channel 8 Full
    Load_Ch7 --> Load_Ch6: Channel 7 Full
    Load_Ch6 --> Idle: Channel 6 Full/Timeout
    
    UnLoading_Mode --> Unload_Ch4: Format Sx
    UnLoading_Mode --> Unload_Ch6: Format Dx
    UnLoading_Mode --> Idle: All Empty
    
    Unload_Ch4 --> Unload_Ch3: Channel 4 Empty
    Unload_Ch3 --> Unload_Ch2: Channel 3 Empty
    Unload_Ch2 --> Unload_Ch1: Channel 2 Empty
    Unload_Ch1 --> Idle: Channel 1 Empty
    
    Unload_Ch6 --> Unload_Ch7: Channel 6 Empty
    Unload_Ch7 --> Unload_Ch8: Channel 7 Empty
    Unload_Ch8 --> Unload_Ch9: Channel 8 Empty
    Unload_Ch9 --> Idle: Channel 9 Empty

State Definitions and Operations

1. IDLE State (`#Idle: 0`)

Purpose: System waiting state with priority-based operation selection Logic:

// Priority hierarchy: Load > Unload > Bypass
IF #i_Load_Request THEN
    #Status.Cycle_Step := #Loading_Mode;
ELSIF #i_Unload_Request THEN
    #Status.Cycle_Step := #UnLoading_Mode;
ELSIF NOT #i_Load_Request AND NOT #i_Unload_Request THEN
    #Status.Cycle_Step := #Bypass_Setup;
END_IF;

Transitions: Based on external requests with defined priority

2. BYPASS_SETUP State (`#Bypass_Setup: 1000`)

Purpose: Prepare system for direct bottle flow through central channel Key Operations:

Configure both selectors to central position (Channel 5)
Enable selector movement
Verify positioning and safety conditions
Wait for all systems ready

Safety Conditions:

#Conditions_To_Run := #i_GuidesInPosition AND
    (#Infeed_ChSelector.o_InPosition = #Central) AND
    (#Outfeed_ChSelector.o_InPosition = #Central) AND
    #Status.Motors_Enable AND #Status.AutoCycle;

3. BYPASS_MODE State (`#Bypass_Mode: 1010`)

Purpose: Active bypass operation for direct bottle flow Logic:

Continuous monitoring of selector positions
Demand-based motor control
Return to setup if selectors move incorrectly

Flow Control:

// Run central channel based on output demand
IF #Area_Outfeed_Ch_Selector.Status.Empty_End_Area OR #Dosser_Output.i_Motor_Run THEN
    #Area_Channel[#Central].i_Motor_Run := TRUE;
    #Dosser_Input.i_Motor_Run := TRUE;
ELSE
    // Stop if no demand from output
    #Area_Channel[#Central].i_Motor_Run := FALSE;
    #Dosser_Input.i_Motor_Run := FALSE;
END_IF;

4. LOADING_MODE State (`#Loading_Mode: 2000`)

Purpose: Initial preparation and channel availability assessment Channel Availability Logic:

Format Sx (Left): Check channels 1-4 for available space
Format Dx (Right): Check channels 6-9 for available space

Preparation Sequence:

Configure selectors to central position
Stop infeed during preparation
Clear central areas
Determine starting channel based on format

5. Load Channel States (`#Load_Ch1-9: 2010-2090`)

Loading Strategy:

Left Format (Sx): Load sequence 1→2→3→4 (outermost to innermost)
Right Format (Dx): Load sequence 9→8→7→6 (outermost to innermost)

Example - Load Channel 1 Logic:

// Prerequisites for Channel 1 loading:
// - Target channel (1) must have end area space
// - All intermediate channels (2,3,4) must be completely empty
IF #Conditions_To_Run AND
    #Area_Channel[1].Status.Empty_End_Area AND
    #Area_Channel[2].Status.Empty AND
    #Area_Channel[3].Status.Empty AND
    #Area_Channel[4].Status.Empty THEN
    
    // Configure selector and run motors
    #Status.InfeedSelector_Ch := 1;
    // Run all channels in path: 1→2→3→4→5(central)
    #Area_Channel[1].i_Motor_Run := #Filtered.Min_Accumulation OR NOT #i_Load_Request;
    // ... (similar for channels 2,3,4,5)
END_IF;

Progressive Loading Logic:

Each channel requires downstream channels to be empty
Motors run based on accumulation status or load request
Input dosser runs only when target channel has large space available

6. UNLOADING_MODE State (`#UnLoading_Mode: 3000`)

Purpose: Preparation for bottle evacuation from storage channels Preparation Steps:

Stop input feeding
Position input selector at center
Clear all central areas
Determine starting channel (innermost to outermost)

7. Unload Channel States (`#Unload_Ch1-9: 3010-3090`)

Unloading Strategy:

Left Format (Sx): Unload sequence 4→3→2→1 (innermost to outermost)
Right Format (Dx): Unload sequence 6→7→8→9 (innermost to outermost)

Example - Unload Channel 4 Logic:

// Basic conditions for unloading
#Conditions_To_Run := #Dosser_Output.i_Motor_Run AND
    #Area_Channel[#Central].Status.Empty AND
    #Area_Infeed_Ch_Selector.Status.Empty;

// Run motors only when output selector is positioned
IF #Outfeed_ChSelector.o_InPosition = #Status.OutfeedSelector_Ch THEN
    #Area_Channel[#Central].i_Motor_Run := #Conditions_To_Run;
    #Area_Channel[4].i_Motor_Run := #Conditions_To_Run;
END_IF;

Progressive Unloading Logic:

Start from innermost channels (closest to central)
Each channel waits for previous channel to empty
Output selector moves progressively outward
Safety areas must be clear before transitions

State Transition Controls

Transition Validation:

All transitions verify safety conditions
Selector positions confirmed before motor operations
Area status checked before state changes
Timeout protection prevents infinite loops

Emergency Transitions:

Any state can return to IDLE on timeout
Load/Unload requests can interrupt bypass operations
Safety violations force immediate stops

Completion Detection:

// Loading completion
IF NOT #Area_Channel[#Channel].Status.Empty_End_Area THEN
    #Status.Cycle_Step := #Next_Channel;  // Move to next channel
END_IF;

// Unloading completion  
IF #Area_Channel[#Channel].Status.Empty_Outfeed_Safety_Area THEN
    #o_Unload_Finish := TRUE;
    #Status.Cycle_Step := #Idle;
END_IF;

Performance Optimization Features

Parallel Operations:

Multiple channels can run simultaneously during loading
Central channel operates independently when needed
Input/output operations can overlap when safe

Demand-Based Control:

Motors run only when bottles are present or space is available
Output demand controls input feeding
Accumulation sensors provide real-time feedback

Format-Specific Logic:

Left/Right format handling with mirrored logic
Channel selection based on bottle format
Independent operation of format sides

This state machine architecture provides robust, efficient, and safe operation of the accumulation table system while maintaining flexibility for different operational scenarios.

3. Supporting Function Blocks

FB_DoserPair.scl

Manages paired dosing operations with:

Motor synchronization between left and right feeders
Speed coordination based on nominal values
Enable/ready state management

FB_AreaTracker.scl

Provides bottle tracking capabilities:

Virtual photocell simulation
Bottle position tracking through conveyor areas
Speed-based position calculation

FB_PositionAxis.scl

Handles positioning operations:

Home sensor integration
Position feedback management
In-position status reporting

4. Data Management

DB_TransportStatus.scl

Central data structure containing:

Format definitions (2 formats supported)
HMI interface data
Table status information
Transport system status
Divider and combiner status

Format Structure:

VAR
  Formats : Array[0..1] of "Struct";
  _00_HMI_Machine : "Struct";
  _01_Table : "Struct"; 
  _02_Transport : "Struct";
  _03_Divider : "Struct";
  _04_Combiner : "Struct";
END_VAR

System Operation Modes

1. Bypass Mode

When no accumulation is required:

Direct bottle routing through selected channels
Minimal buffer usage
Real-time format switching capability

2. Accumulation Mode

For format storage:

Full channel utilization
Sequential loading/unloading operations
Format segregation management

3. Format Change Mode

During format transitions:

Controlled emptying of accumulation areas
Guide repositioning operations
Safety zone clearance verification

Communication Architecture

@startuml
package "TTOP Control System" {
    [FC_Ttop_Run] as run
    [FC_Ttop_Devices] as devices
    [FB_AccumTable] as accum
    [FB_Motors_Manage] as motors
    [FC_Motor_Protocols] as protocols
    [DB_TransportStatus] as db
    
    run --> devices : Configure
    run --> accum : Control
    devices --> accum : Setup
    accum --> motors : Commands
    motors --> protocols : Communication
    
    db <--> accum : Status Data
    db <--> devices : Configuration
}

package "Motor Network" {
    [M31610] as m1
    [M31710] as m2  
    [U32810-U33610] as channels
    [M31810] as guide1
    [M34310] as guide2
}

protocols --> m1
protocols --> m2
protocols --> channels
protocols --> guide1
protocols --> guide2
@enduml

Performance Characteristics

Speed Parameters

Nominal Speed: 1000 mm/sec at 50Hz
Speed Adjustment Range: Configurable per motor
Synchronization Accuracy: Real-time speed matching

Capacity Management

Channel Count: 9 independent channels
Channel Length: 11,600 mm per channel
Safety Areas: Configurable per zone
Format Switching Time: Dependent on emptying cycle

Safety Features

Photocell Integration

Input/output counting for bottle tracking
Safety zone monitoring for personnel protection
Accumulation limit enforcement

Emergency Procedures

Complete system stop capability
Individual motor emergency stops
Format change abort functionality

Fault Detection

Motor communication monitoring
Position feedback verification
Speed deviation detection

Integration Points

HMI Interface

Format selection and status display
Manual operation controls
Diagnostic information access
Alarm acknowledgment capabilities

External Systems

Divider interface integration
Combiner coordination
Upstream/downstream conveyor synchronization

Maintenance Considerations

Calibration Requirements

Photocell positioning verification
Speed reference validation
Position accuracy confirmation

Diagnostic Capabilities

Motor status monitoring
Communication health checks
Performance trending data

Service Access

Individual component isolation
Manual operation modes
Bypass functionality for maintenance

Technical Specifications

Control Platform

PLC: Siemens S7-1500 series
Programming Language: SCL (Structured Control Language)
Optimization: S7_Optimized_Access enabled

Communication Protocols

PN (PROFINET): Primary communication
DP (PROFIBUS-DP): Legacy support
Analog: Speed reference signals

Performance Metrics

Cycle Time: Optimized for real-time operation
Response Time: Sub-second for format changes
Throughput: Dependent on bottle size and gap parameters

15 KiB Raw Blame History