Page History

Historian Module (Reference) provides comprehensive time-series data collection, storage, and retrieval capabilities for FrameworX solutions.

Key Concepts:

Historian Tag: Individual data points mapped for archiving
Historian Table: Logical grouping of tags
Storage Location: Data repository
Historian Engine: Data collection engine

In this page:

Table of Contents

maxLevel	2
minLevel	2
indent	10px
exclude	Steps
style	none

Historian → Tutorial | Concept | How-to Guide | Reference

Historian Module Configuration

Designer UI Section

Configuration Sections

Section	Path	Purpose
Storage Locations	Historian → Storage Locations	Define data repositories
Historian Tables	Historian → Historian Tables	Configure archiving groups
Historian Tags	Historian → Historian Tags	Map tags to tables
Historian Monitor	Historian → Historian Monitor	Runtime status and trends

Configuration Workflow

Step	Action	Purpose
1. Define Storage	Configure default database	Set primary repository
2. Add Locations	Configure external historians	Multiple storage targets
3. Create Tables	Define historian tables	Group tags logically
4. Map Tags	Assign tags to tables	Configure collection
5. Set Triggers	Configure archiving events	Control data collection

Storage Options

SQL Databases

Default TagHistorian using embedded SQLite or external databases:

Tag Providers

Dataset.DB.TagHistorian

SQLite (default, 10GB limit)
SQL Server
PostgreSQL

Oracle

MySQL

Others...

TagProvider Storage Service

External historian integration:

CanaryLabs - Industrial historian
InfluxDB - Time-series database
GE Proficy - Enterprise historian

ScriptClass Custom Storage

Script Classes for

For specialized requirements:

Cloud storage adapters
Custom file formats
API integrations

Runtime Architecture

Process Execution

The Historian Module runs as an isolated server process:

Event detection and triggering
Data archiving operations
Store and Forward management
Query response handling
Synchronization tasks

Control Operations

Access via Runtime → Runtime Diagnostics:

Run/Pause/Stop execution
Monitor performance metrics
View error messages
Check module

status

Historian Namespace

Access historian objects at runtime:

csharp

// Table properties int rowCount = @Historian.Table.ProcessData.RowCount; DateTime lastStore = @Historian.Table.ProcessData.LastStoredTimeStamp; // Query methods DataTable data = @Historian.Table.ProcessData.QueryData(startTime, endTime); // Module control bool isRunning = @Historian.IsStarted; string

status

= @Historian.OpenStatusMessage;

Key Concepts

Historian Tags

Individual data points mapped for archiving:

Tag reference
Deadband configuration
Table assignment
Collection parameters

Historian Tables

Logical grouping of tags:

Storage location

Trigger configuration

Schema selection

Retention policies

Storage Locations

Data repositories:

Database connections
External historians
Store and Forward
Custom implementations

Archiving Process

Data collection engine:

Trigger evaluation
Event detection
Queue management
Database writing

Archiving Methods

Archiving Control

Trigger-Based

Event-driven collection:

Time triggers (Server.Minute)
Tag triggers (value change)
Expression triggers
Batch/process events

SaveOnChange

Continuous monitoring:

Individual tag tracking
Value change detection
Deadband filtering
Asynchronous storage

TimeDeadband

Minimum interval control:

Prevents excessive writes
Reduces storage requirements
Maintains data integrity

Display Integration

TrendChart Control

Built-in visualization:

Real-time trending
Historical analysis
Multiple pen support
Zoom and pan features

Historian Monitor

Runtime monitoring interface:

Table status display
Error tracking
Performance metrics
Remote web access

Performance Optimization

Table Design

Group by update frequency
Limit tags per table (50-100)
Match process dynamics
Consider query patterns

Storage Strategy

Choose appropriate schema
Set retention policies
Enable compression
Plan capacity

Deadband Configuration

Value deadbands for noise
Time deadbands for frequency
Deviation for exceptions
Rate of change for upsets

Common Configurations

High-Speed Data

Storage: Local SQLite
Schema: Normalized
Trigger: SaveOnChange
TimeDeadband: 1 second
Retention: 30 days

Production Records

Storage: SQL Server
Schema: Standard
Trigger: Batch events
SaveQuality: True
Retention: 365 days

Compliance Data

Storage: CanaryLabs
Store&Forward: True
SaveQuality: True
Retention: 7 years
Audit: Enabled

Advanced Topics

For deep technical understanding: → See [Historian Engine (Reference)]

Best Practices Checklist

Design

Plan storage architecture - Match technology to requirements
Group tags logically - Similar rates and relationships
Size tables appropriately - Balance performance
Configure deadbands - Optimize storage
Set retention policies - Manage growth

Operations

Monitor regularly - Check error counts
Test failover - Verify Store and Forward
Archive old data - Maintain performance
Document configuration - Track changes
Backup settings - Protect configuration

Performance

Optimize queries - Use appropriate time ranges
Index databases - Improve retrieval
Cache frequently - Reduce database load
Batch operations - Minimize transactions

Troubleshooting

Data Not Storing

Verify trigger configuration
Check table assignment
Confirm database connection
Review error messages

Incomplete Data

Check module started status
Verify tag quality
Review deadband settings
Examine triggers

Slow Retrieval

Enable caching
Optimize query ranges
Check database indexes
Review network latency

Store and Forward Issues

Verify feature enabled
Check local disk space
Monitor buffer size
Review sync status

In this section...

Page Tree

root	@parent
spaces	93DRAF

...

Page tree