Inferensys

Integration

AI Integration with Ignition for Data Acquisition

Leverage Ignition's real-time data acquisition engine as a high-fidelity source for AI model training and inference. This guide details how to cleanse time-series data, engineer features, and establish feedback loops for predictive maintenance, quality scoring, and operational intelligence.
Data scientist building training data pipeline on laptop, data preprocessing visible, technical workspace.
ARCHITECTURE

Why Ignition is a Foundational Data Source for Manufacturing AI

Ignition's real-time data acquisition engine provides the high-fidelity, time-series foundation required to train and deploy production-grade AI models on the shop floor.

Unlike transactional ERP or MES systems, Ignition is built to handle high-volume, high-velocity data streams from PLCs, sensors, vision systems, and SCADA networks. This creates a unified data fabric of time-series events—motor temperatures, pressure readings, cycle counts, OEE states, and quality sensor outputs—that is essential for AI feature engineering. For AI integration, you treat Ignition's Tag Historian, SQL Bridge, and MQTT/Sparkplug B connectivity as the primary ingestion layer, feeding cleansed, contextualized data into your AI training pipelines and inference endpoints.

The implementation centers on using Ignition's scripting (Python/Jython) and gateway APIs to execute lightweight data transformations—normalization, outlier removal, rolling window calculations—before streaming to a vector database or feature store. This pre-processing at the edge reduces cloud data transfer costs and latency. For example, you can configure Ignition to calculate derived features like vibration_FFT_peak_frequency or energy_consumption_per_unit in real-time, creating an AI-ready data pipeline that feeds models for predictive maintenance or energy optimization without replacing underlying control logic.

Governance and rollout require mapping Ignition's tag structures and UDTs (User Defined Types) to your AI model's expected schema, establishing data quality rules at the source, and implementing a feedback loop where model predictions (e.g., a predicted_failure_in_8_hours score) are written back to Ignition tags. This allows operators to see AI-driven alerts directly in HMI screens or Perspective dashboards, creating a closed-loop system where the AI continuously learns from the outcomes of its own recommendations. This architecture ensures AI inferences are grounded in the most current operational reality, not stale batch data.

WHERE TO CONNECT AI MODELS

Key Ignition Surfaces for AI Data Acquisition

The Core Data Fabric for AI

Ignition's tag historian is the primary source for training and feeding predictive models. This includes real-time sensor data (temperatures, pressures, speeds), calculated tags (OEE, rates), and state data (machine status, alarm states). For AI, this surface provides the high-volume, timestamped sequences needed for anomaly detection, predictive maintenance, and quality forecasting.

Key integration patterns:

  • Batch Extraction: Scheduled queries to pull historical time-series for model training, often using Ignition's SQL bridging to export to a data lake or feature store.
  • Streaming Inference: Real-time tag value streams piped to lightweight AI models at the edge for immediate scoring, with results written back as new tags.
  • Feature Engineering: Using Ignition's scripting or connected compute to create rolling averages, derivatives, or FFT transforms before the data reaches the AI model, reducing latency and cloud data transfer costs.
MANUFACTURING EXECUTION PLATFORMS

High-Value AI Use Cases Powered by Ignition Data

Ignition's real-time data acquisition engine provides a high-fidelity, time-series foundation for AI. These use cases demonstrate how to transform raw SCADA and MES data into predictive insights and automated actions that improve yield, uptime, and quality.

01

Predictive Quality Scoring

Ingest real-time process parameters (temperature, pressure, flow rates) from Ignition tags into an AI model to predict final product quality scores before lab results are available. Flag batches likely out-of-spec for immediate intervention, reducing scrap and rework.

Batch -> Real-time
Quality insight
02

Automated Root Cause Analysis for Downtime

Use Ignition's alarm and event historian to train AI models that classify and attribute unplanned downtime. Automatically correlate stoppages with preceding sensor patterns, shift logs, and maintenance events to generate root cause summaries, cutting investigation time from hours to minutes.

Hours -> Minutes
Investigation time
03

Dynamic Recipe Optimization

Leverage Ignition's batch data and SQL bridging to feed historical recipe execution data into an AI system. The model recommends real-time parameter adjustments for active batches based on current material properties and ambient conditions, maximizing yield and consistency.

1-2% Yield Lift
Typical improvement
04

Intelligent Anomaly Detection

Apply unsupervised learning to multivariate sensor streams from Ignition's IIoT modules to establish normal operating envelopes. Detect subtle, multi-sensor anomalies indicative of early equipment degradation or process drift long before single-point alarms trigger.

Days -> Hours
Early warning lead time
05

Automated Shift Handover Reporting

Use AI to synthesize Ignition historian data, Andon events, and production counts from the past shift into a narrative production summary. Automatically highlight key issues, performance against targets, and recommended actions for the incoming shift crew.

30+ Minutes Saved
Per shift supervisor
06

Predictive Maintenance Trigger

Integrate feature-engineered vibration, temperature, and power data from Ignition with a CMMS like SAP PM or Maximo. AI models predict remaining useful life and automatically generate draft work orders in the CMMS, prioritizing maintenance before failure.

Reactive -> Predictive
Maintenance mode
IGNITION INTEGRATION PATTERNS

Example AI-Enhanced Data Acquisition Workflows

Ignition's real-time data acquisition engine provides a high-volume, structured stream of shop floor data. These workflows demonstrate how to inject AI models into that stream to create closed-loop intelligence, moving from passive data collection to active insight generation and automated response.

This workflow uses unsupervised learning to detect subtle equipment deviations before they cause downtime or quality issues.

  1. Trigger: Ignition's SCADA module polls a PLC for sensor data (e.g., motor vibration, temperature, pressure) at a high frequency (e.g., every 100ms).
  2. Context/Data Pulled: A sliding window of the last 5 minutes of multivariate time-series data is packaged with equipment metadata (asset ID, current recipe, maintenance history) from Ignition's SQL Tags or a connected database.
  3. Model/Agent Action: An anomaly detection model (e.g., Isolation Forest, Autoencoder) hosted in a containerized inference service scores the data window. If an anomaly score exceeds a dynamic threshold, an AI agent:
    • Classifies the anomaly type (e.g., "bearing wear", "cavitation", "sensor drift").
    • Checks for correlated alarms in Ignition's alarm system.
    • Generates a contextual alert payload.
  4. System Update/Next Step: The agent posts the enriched alert to Ignition's scripting module, which:
    • Creates a high-priority, pre-classified alarm in Ignition's alarm console.
    • Logs the event with root-cause hypothesis to a dedicated SQL table for model feedback.
    • Optionally triggers a work order draft in a connected CMMS via Ignition's REST client.
  5. Human Review Point: The maintenance supervisor reviews the AI-classified alarm in the Ignition HMI. They confirm or correct the diagnosis, providing a feedback label that is used to retrain the model weekly.
BUILDING A REAL-TIME DATA FABRIC FOR AI

Implementation Architecture: From Ignition Tags to AI Insights

A practical blueprint for using Ignition's data acquisition engine as the high-volume, high-fidelity source for training and deploying AI models on the shop floor.

The integration architecture starts with Ignition's native tag system and historian. We treat Ignition's OPC-UA and PLC drivers as the primary ingestion layer, streaming time-series data—temperatures, pressures, cycle times, motor currents—into a dedicated feature engineering pipeline. This pipeline, often deployed as a containerized service alongside the Ignition Gateway, performs real-time data cleansing (handling missing values, smoothing noise), calculates rolling aggregates (5-minute averages, standard deviations), and creates lagged features essential for predictive models. The cleansed, feature-rich data stream is then published to a message queue (like Apache Kafka or MQTT) to decouple data acquisition from model inference, ensuring the shop floor's real-time control loops remain unaffected by downstream AI processing latency.

For model inference, we deploy lightweight AI containers—either on-premises near the Ignition server or in a hybrid cloud edge node—that subscribe to the feature stream. These models perform tasks like anomaly detection for predictive maintenance or quality deviation prediction. Inference results are written back to Ignition as new virtual tags, making them immediately available to HMI screens, Perspective dashboards, and alarm systems. For example, a Predicted_Failure_Probability tag can trigger a color change on a motor symbol or generate a work order in a connected CMMS via Ignition's database scripting. This closed-loop design ensures AI insights are actionable within the same operational context where the data originated.

The feedback loop for model retraining is critical. We configure Ignition to log ground-truth events—like a confirmed equipment failure or a final quality pass/fail result from a test station—to a time-series database (like InfluxDB or TimescaleDB) keyed to the original feature set. Periodically, a batch job extracts these labeled datasets to retrain models offline. The updated model is validated, versioned, and then seamlessly deployed back to the inference container, often using Ignition's system. functions to restart services. Governance is maintained through audit logs of model versions, inference tags, and data lineage tracked within Ignition's own logging database and integrated with enterprise tools via its REST API.

IGNITION DATA ACQUISITION

Code and Configuration Examples

Querying Time-Series Data for Model Training

Ignition's Tag Historian is the primary source for time-series features. Use its SQL Bridge or scripting to extract sequences for training. The key is to align process tag data with event markers (e.g., batch start/end, quality results) to create labeled datasets.

python
# Example: Query Tag Historian via Ignition's Gateway API
import requests
import pandas as pd

# Query for a specific tag and time range
gateway_url = "http://ignition-gateway:8088"
auth = ('admin', 'password')

# Query tag history
tag_query = {
    "tagProvider": "default",
    "tags": ["Line1/Reactor/Temperature", "Line1/Reactor/Pressure"],
    "startDate": "2024-01-15T00:00:00",
    "endDate": "2024-01-16T00:00:00",
    "sampleSize": 1000
}

response = requests.post(f"{gateway_url}/api/v1/tags/history/query",
                         json=tag_query, auth=auth)
tag_data = response.json()

# Convert to DataFrame for feature engineering
df = pd.DataFrame(tag_data['data'])
# Perform rolling averages, lags, and statistical features
df['temp_rolling_avg'] = df['Line1/Reactor/Temperature'].rolling(10).mean()

This data is then packaged and sent to your feature store or training pipeline.

AI-ENHANCED DATA ACQUISITION

Realistic Time Savings and Operational Impact

How integrating AI with Ignition's data acquisition engine transforms time-series data from a raw feed into a production-ready intelligence asset.

MetricBefore AIAfter AINotes

Time-series data cleansing

Manual rule configuration & periodic review

Automated anomaly flagging & drift correction

Reduces data prep for analytics from hours to minutes

Feature engineering for models

Data scientist-led, batch SQL queries

Automated pipeline with real-time feature store

Enables rapid prototyping of new predictive models

Sensor-to-alert latency

Next-shift report review

Real-time inference & contextual alerts

Moves from detection to prevention for equipment issues

Model feedback loop cycle

Weeks (manual data extraction & retraining)

Days (automated performance tracking & retriggering)

Accelerates model improvement and adaptation to process changes

Data acquisition pipeline monitoring

Reactive troubleshooting after failures

Predictive health scoring & maintenance alerts

Increases uptime and reliability of the core data fabric

Contextual data enrichment

Static lookups from reference tables

Dynamic enrichment using LLMs & external APIs

Adds operational context (e.g., maintenance logs, weather) to raw signals automatically

Compliance data traceability

Manual audit preparation for regulators

Automated lineage & audit trail generation

Reduces audit preparation effort by 60-80%

ARCHITECTING FOR PRODUCTION

Governance, Security, and Phased Rollout

Deploying AI on Ignition's data acquisition engine requires a deliberate approach to data governance, model security, and controlled rollout to ensure reliability and trust.

Governance starts with the Ignition Tag Historian and SQL Bridge modules. Define clear data contracts for which time-series tags and transactional records feed your AI models. Use Ignition's built-in audit trails and user permissions to control access to training data and model outputs. For feature engineering pipelines, maintain a versioned feature store separate from Ignition's runtime to track lineage from raw sensor data to model-ready vectors, ensuring reproducibility for compliance audits.

Security is multi-layered. At the edge, AI inference containers should run in isolated environments with strict network policies, communicating with Ignition's Gateway via secure WebSocket or MQTT. Encrypt sensitive payloads containing proprietary process parameters. For cloud-hosted models, implement role-based access control (RBAC) so only authorized engineers or systems can retrain models or adjust inference parameters. Use Ignition's alarm and notification system to create alerts for model drift detection or unauthorized access attempts to the AI service layer.

A phased rollout mitigates risk. Start with a read-only pilot on a single production line or asset, where AI models analyze Ignition data streams to generate predictive alerts but take no control actions. Use Ignition's Perspective or Vision clients to create a dedicated pilot dashboard for operators and engineers to review AI suggestions alongside traditional SCADA views. Establish a human-in-the-loop review process, logging every AI recommendation and the operator's subsequent action in a linked SQL database to build a feedback loop for model refinement.

Scale the integration by gradually connecting AI outputs to Ignition's scripting engine and PLC write-backs for closed-loop control, but only after establishing governance gates. Implement a canary release strategy for model updates, deploying new versions to a subset of tags or machines while monitoring for performance regressions in Ignition's real-time displays. Finally, integrate the AI operations dashboard with your existing ITSM platform (like ServiceNow) to treat model failures or data pipeline issues as standard IT incidents, ensuring sustainable, long-term operations.

AI INTEGRATION WITH IGNITION

Frequently Asked Questions

Practical questions about using AI to enhance Ignition's data acquisition engine for predictive analytics, automated feature engineering, and closed-loop model feedback.

A production feedback loop uses Ignition as the central nervous system for data flow:

  1. Data Acquisition & Streaming: Ignition's native drivers (OPC UA, MQTT, PLC drivers) collect high-frequency sensor and machine data, writing to a time-series database (like InfluxDB) or a historian tag.
  2. Feature Engineering Pipeline: A lightweight service (e.g., a Python microservice) subscribes to relevant tag groups. It performs real-time windowing, rolling averages, and statistical feature calculation (like rate-of-change, FFT components) to create model-ready features.
  3. Model Inference: The engineered features are sent via a REST API or message queue (Kafka) to a deployed AI model (e.g., for anomaly detection or yield prediction).
  4. Action & Visualization: The model's inference (e.g., anomaly_score: 0.92) is written back to a new Ignition tag. This can trigger:
    • Alarms in the Ignition alarm pipeline.
    • Visualization on HMI screens (Perspective or Vision).
    • Automated control actions via Ignition scripting to adjust setpoints.
  5. Feedback for Retraining: Labeled outcomes (e.g., confirmed faults, actual yield) are logged back to a data lake. Periodically, this new ground truth data is used to retrain and redeploy the model, completing the loop.

Ignition's scripting (Python or Jython) and gateway APIs are key for steps 1, 4, and 5.

Prasad Kumkar

About the author

Prasad Kumkar

CEO & MD, Inference Systems

Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.

His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.