verview
This guide walks you through the complete solution lifecycle from
...
development through production deployment
...
What You'll Learn:
- Plan and scope your project
- Design the architecture
- Build using the Four Pillars
- Deploy to production
- Maintain and support
</ac:layout-cell> ac:layout-cell <ac:structured-macro ac:name="panel"> <ac:parameter ac:name="title">On this Page:</ac:parameter> ac:rich-text-body <ac:structured-macro ac:name="toc"> <ac:parameter ac:name="maxLevel">2</ac:parameter> <ac:parameter ac:name="minLevel">2</ac:parameter> </ac:structured-macro> </ac:rich-text-body> </ac:structured-macro>
<ac:structured-macro ac:name="info"> ac:rich-text-body Time Estimate
- Small System: 4-6 weeks
- Medium System: 8-12 weeks
- Enterprise: 16-24 weeks </ac:rich-text-body> </ac:structured-macro> </ac:layout-cell> </ac:layout-section> </ac:layout>
Quick Start Workflow
Follow this high-level workflow, then dive into detailed procedures for each stage:
1. INITIATE (1-2 weeks)
??? Define Requirements
??? Identify Stakeholders
??? Create Project Charter
2. DESIGN (2-4 weeks)
??? Architecture Planning
??? Data Model Design
??? Standards Definition
3. BUILD (4-12 weeks)
??? P1: Configure UNS
??? P2: Setup Process Modules
??? P3: Add Application Logic
??? P4: Create User Interface
4. DEPLOY (1-2 weeks)
??? Production Installation
??? Commissioning
??? Training
5. SUPPORT (Ongoing)
??? Monitoring
??? Maintenance
??? Optimization
Stage 1: Initiate Your Project
Step 1.1: Define Project Scope
Prerequisites: Business objectives, budget constraints
- Create Project Charter
Project Name: _____________ Business Objective: _____________ Success Criteria: _____________ Constraints: _____________ Timeline: _____________
- Document Technical Requirements
- I/O Count: _____ points
- User Count: _____ concurrent
- Data Sources: _____ systems
- Performance: _____ ms response
- Identify Stakeholders <table> <tr><th>Role</th><th>Name</th><th>Responsibility</th></tr> <tr><td>Sponsor</td><td>___</td><td>Approval</td></tr> <tr><td>Operations</td><td>___</td><td>Requirements</td></tr> <tr><td>IT</td><td>___</td><td>Infrastructure</td></tr> </table>
Validation: All stakeholders sign off on scope document
Step 1.2: Gather Requirements
- Collect Data Source Information
For each PLC/Device: - Protocol: _____________ - IP Address: _____________ - Point Count: _____________ - Scan Rate: _____________
- Define Functional Requirements
- Process control needs
- Alarm requirements
- Reporting specifications
- Integration points
- Security requirements
Deliverable: Requirements Specification Document
Stage 2: Design Your Architecture
Step 2.1: System Architecture
- Select Deployment Model
[ ] Standalone - Single server [ ] Distributed - Multiple servers [ ] Cloud - Azure/AWS [ ] Hybrid - Mixed deployment
- Design Network Topology
- Production Network: _____________
- Control Network: _____________
- DMZ Configuration: _____________
- Plan Database Architecture
Development: SQLite (default) Production: [ ] SQL Server [ ] PostgreSQL [ ] Oracle Historian: [ ] Local [ ] Enterprise [ ] Cloud
Step 2.2: Data Architecture
- Define Naming Convention
Standard: [Area]_[Equipment]_[Signal] Example: WTP_PUMP01_RUNNING
- Design UDT Templates
yaml
Motor_Template: - Running: Boolean - Speed_SP: Float - Speed_PV: Float - Fault: Boolean
- Plan Asset Structure
Plant ??? Area1 ? ??? Line1 ? ??? Line2 ??? Area2
Deliverable: Architecture Design Document
Stage 3: Build Your Solution
Step 3.1: Configure Foundation (P1)
- Create Tag Structure
a. Open Designer → UNS → Tags b. Click New Tag c. Enter: Name, Type, Initial Value d. Set Engineering Units e. Configure Min/Max ranges
- Build UserTypes (UDTs)
a. Navigate to UNS → UserTypes b. Click New Type c. Add Members: - Commands (Start, Stop) - Status (Running, Faulted) - Values (Speed, Current) d. Save Template
- Organize Asset Tree
a. Go to UNS → Asset Tree b. Create Folders for Areas c. Add Equipment nodes d. Link to Tags/UDTs
Step 3.2: Setup Process Modules (P2)
- Configure Device Communications
a. Devices → Channels → New b. Select Protocol (Modbus, OPC UA, etc.) c. Configure Connection: - IP: _____________ - Port: _____________ - Timeout: 3000ms d. Add Nodes → Map Points e. Test Communication
- Setup Alarms
a. Alarms → Groups → New Group b. Add Alarm Items: - Tag: Select from UNS - Condition: HiHi, Hi, Lo, LoLo - Limits: Set values - Priority: 1-999 c. Configure Notifications
- Enable Historian
a. Historian → Storage → Configure b. Select Location (SQL Database) c. Create Storage Groups d. Add Tags to collect e. Set collection rates
Step 3.3: Add Application Logic (P3)
- Create Scripts
csharp
// Scripts → Tasks → New // Name: Calculate_KPI // Trigger: Timer (60 seconds) public void RunTask() { // Calculate OEE float availability = Tag.RunTime / Tag.PlannedTime; float performance = Tag.ActualRate / Tag.TargetRate; float quality = Tag.GoodParts / Tag.TotalParts; Tag.OEE = availability * performance * quality; }
- Configure Datasets
sql
-- Datasets → DBs → New Connection -- Datasets → Queries → New SELECT ProductID, BatchNumber, Quantity, Timestamp FROM Production WHERE Timestamp > @StartTime
Step 3.4: Build User Interface (P4)
- Create Main Navigation
a. Displays → New Display b. Name: MainMenu c. Add Navigation buttons: - Overview - Areas - Reports - Admin
- Design Process Graphics
a. Create display per area b. Add equipment symbols c. Bind to tags: - Drag tag to object - Configure animation d. Add navigation buttons
Validation: Test all displays in Test Mode (F5)
Stage 4: Deploy to Production
Step 4.1: Pre-Deployment Checklist
- All tests passed
- Documentation complete
- Backup created (.dbback file)
- Licenses verified
- Training materials ready
- Rollback plan prepared
Step 4.2: Installation Procedure
- Backup Current System (if exists)
Solution Center → Backup Save to: Backup_YYYYMMDD.dbback
- Install Software
a. Run FrameworX installer b. Select components c. Enter license d. Configure services
- Deploy Solution
a. Copy .dbsln to server b. Open Solution Center c. Import solution d. Select Production profile e. Start Runtime
Step 4.3: Commissioning
- I/O Checkout
For each signal: - [ ] Force value at source - [ ] Verify in FrameworX - [ ] Document in loop sheet
- Functional Testing
- Test each control loop
- Verify alarm functions
- Check interlock logic
- Validate calculations
- Performance Validation
- Response time: < 500ms
- CPU usage: < 60%
- Memory: < 70%
- Network: < 50%
Sign-off: Customer acceptance signature
Stage 5: Support & Maintenance
Step 5.1: Setup Monitoring
- Configure Diagnostics
Runtime → Diagnostics → Enable: - [ ] Performance counters - [ ] Error logging - [ ] Audit trail
- Create KPI Dashboard
- System uptime
- Response times
- Alarm rates
- Data quality
Step 5.2: Maintenance Schedule
<table> <thead> <tr><th>Frequency</th><th>Tasks</th><th>Procedure</th></tr> </thead> <tbody> <tr> <td><strong>Daily</strong></td> <td>System check</td> <td>Review alarms, check status</td> </tr> <tr> <td><strong>Weekly</strong></td> <td>Backup</td> <td>Solution Center → Backup</td> </tr> <tr> <td><strong>Monthly</strong></td> <td>Archive</td> <td>Export historian data</td> </tr> <tr> <td><strong>Quarterly</strong></td> <td>Review</td> <td>Performance analysis</td> </tr> </tbody> </table>
Step 5.3: Common Troubleshooting
Issue: Communication Loss
- Check network connectivity
- Verify device status
- Review error logs
- Restart communication service
Issue: High CPU Usage
- Check script execution times
- Review polling rates
- Optimize queries
- Adjust priorities
Tools and Templates
Project Management Tools
FrameworX Built-in:
- Track Changes (version control)
- Cross-Reference (dependency tracking)
- Build Flag (backup points)
- Publish (production lock)
Recommended Third-party:
- JIRA/Azure DevOps (task tracking)
- Git/SVN (source control)
- Confluence (documentation)
Downloadable Templates
- [Project Charter Template]
- [Requirements Checklist]
- [Test Plan Template]
- [Commissioning Sheets]
- [Training Materials]
Best Practices Summary
DO:
? Follow naming conventions consistently ? Test at each stage ? Document all decisions ? Plan for 20-30% growth ? Use version control ? Create reusable components
DON'T:
? Skip testing to save time ? Hardcode values ? Deploy without backups ? Ignore user feedback ? Neglect documentation
Next Steps
After completing this lifecycle:
- Review Advanced Topics
- [Performance Optimization →]
- [Security Hardening →]
- [Redundancy Setup →]
- Explore Templates
- [Industry Solutions →]
- [Standard Libraries →]
- Get Support
- [Training Courses →]
- [Community Forum →]
- [Technical Support →]
. Learn to manage versions, migrate between environments, and maintain solution integrity across all stages.
Prerequisites:
- Understanding of three workspaces (Solution Center, Designer, Runtime)
- Familiarity with execution profiles
- Basic knowledge of solution architecture
Solution Lifecycle Overview
The Three Stages
Development → |
---|
|
Validation → |
---|
|
Production |
---|
|
The Three Workspaces
Solution Center → |
---|
|
Designer → |
---|
|
Runtime. |
---|
|
↓
Solution Configuration |
---|
Database (.dbsln) |
Development Stage
Initial Development
Creating the solution:
- Solution Center → New Solution
- Select appropriate template
- Configure in Designer
- Use Development profile
Development environment characteristics:
- Local SQLite databases
- Full diagnostic logging
- Simulation data enabled
- Unrestricted editing
- Test mode available
Development Workflow
- Configure modules progressively:
- Define tags and templates
- Setup device connections
- Create displays
- Add business logic
- Test incrementally:
- Use Test Mode (F5)
- Verify each module
- Check integrations
- Monitor performance
- Version control:
- Regular backups
- Track changes
- Document modifications
- Tag development versions
Development Sprint Planning
Organize work in sprints:
- Sprint 1: UNS Foundation (P1)
- Sprint 2: Process Modules (P2)
- Sprint 3: Application Modules (P3)
- Sprint 4: User Interface (P4)
- Sprint 5: Integration & Testing
Validation Stage
Moving to Validation
Preparation steps:
- Complete development features
- Build solution (F6)
- Export/backup development version
- Create validation environment
Validation profile setup:
Panel |
---|
Database: Test SQL Server |
Validation Testing
Functional testing:
- All features work as designed
- Data flows correctly
- Alarms trigger properly
- Reports generate accurately
Performance testing:
- Load testing with real data volumes
- Stress testing communications
- Client connection limits
- Resource utilization
Integration testing:
- External system connections
- Database operations
- Third-party interfaces
- Redundancy failover
Testing Levels
- Unit Testing - Individual components
- Integration Testing - Module interactions
- System Testing - Complete solution
- Acceptance Testing - Business requirements
Validation Checklist
? All modules configured ? Scripts compile without errors ? Displays render correctly ? Communications stable ? Alarms functioning ? Historical data recording ? Security implemented ? Performance acceptable
Production Stage
Production Deployment
Pre-deployment:
- Complete validation sign-off
- Create production backup
- Document configuration
- Prepare rollback plan
Deployment steps:
- Publish solution:
Runtime → Publish Version: 1.0.0 Type: Read-only (.dbrun)
- Transfer to production:
- Copy .dbrun file
- Install on production server
- Configure production profile
- Production profile:
Database: Production SQL Historian: Full retention Security: Active Directory Redundancy: Enabled
Production Startup
- Stop any running solutions
- Load production solution
- Select Production profile
- Start with monitoring
- Verify all modules active
- Check client connections
- Confirm data flow
Version Management
Version Numbering
Standard format: Major.Minor.Build
- Major: Significant changes
- Minor: Feature additions
- Build: Bug fixes
Example progression:
1.0.0 - Initial production
1.1.0 - Added reporting module
1.1.1 - Fixed alarm bug
2.0.0 - Major upgrade
Creating Versions
Development versions:
- Auto-increment build number
- Tag with date/time
- Include developer notes
Production versions:
- Go to Runtime → Publish
- Set version number
- Add release notes
- Create .dbrun file
- Archive with documentation
Migration Procedures
Development to Validation
- Export from Development:
- Build solution
- Create backup
- Document changes
- Import to Validation:
- Load in test environment
- Switch to Validation profile
- Update connection strings
- Test all functions
Validation to Production
- Prepare solution:
- Final build
- Publish read-only
- Create deployment package
- Deploy to production:
- Schedule maintenance window
- Backup current production
- Install new version
- Verify operation
- Monitor closely
Rollback Procedures
If issues occur:
- Stop current solution
- Load previous .dbrun
- Start with last known good
- Investigate issues offline
- Plan corrective action
Backup and Recovery
Backup Strategy
Development backups:
- Daily automatic
- Before major changes
- Keep 30 days
Production backups:
- Continuous replication
- Daily full backup
- Weekly archives
- Monthly long-term
Backup Methods
Manual backup:
- Solution Center → Select solution
- File → Export → Backup
- Choose location
- Include resources
Automatic backup:
batch
TBackup.exe /solution:"Production" /output:"D:\Backups" /daily
Recovery Procedures
From backup:
- Solution Center → Import
- Select .dbback file
- Choose restore location
- Verify integrity
- Update configuration
From published version:
- Locate .dbrun file
- Copy to production
- Start with profile
- Verify operation
Change Management
Change Control Process
- Request: Document change need
- Review: Assess impact
- Approve: Get authorization
- Implement: Make change in Dev
- Test: Validate in Test
- Deploy: Move to Production
- Verify: Confirm operation
Online Changes
Changes safe for production:
- Tag value modifications
- Display updates
- Report adjustments
- User permissions
Changes requiring restart:
- Device configurations
- Database connections
- Module additions
- Port changes
Change Documentation
Track for each change:
- Date and time
- Person responsible
- Modules affected
- Reason for change
- Test results
- Rollback plan
Best Practices
Development Phase
Use meaningful naming conventions
Comment complex logic
Test edge cases
Document assumptions
Regular commits
Validation Phase
Test with production data volumes
Verify all integrations
Check error handling
Validate performance
Document test results
Production Phase
Monitor continuously
Maintain change log
Regular backups
Plan maintenance windows
Keep documentation current
General Guidelines
Never edit production directly
Always have rollback plan
Test changes thoroughly
Document everything
Maintain version history
This guide covered the complete solution lifecycle from initial development through production deployment, including version management, migration procedures, and best practices for maintaining solution integrity throughout all stages
...
.