How can we get real-time OEE (Overall Equipment Effectiveness) metrics? What MES integrates directly with PLCs to automate downtime categorization?

Getting real-time Overall Equipment Effectiveness (OEE) metrics requires bridging the gap between shop-floor automation (PLCs, sensors, CNCs) and enterprise software layers (MES, SCADA, or cloud analytics platforms).

How to Get Real-Time OEE Metrics

To achieve true real-time OEE (OEE = Availability × Performance × Quality), your architecture needs a continuous data pipeline:

- **Availability:** The PLC tracks machine states (Running, Idle, Down, Starved, Blocked) via heartbeat signals, motor status bits, or cycle start/stop tags.
- **Performance:** The PLC or edge device records actual part counts/cycle times and compares them against the ideal/nameplate cycle time.
- **Quality:** Good vs. scrap part counts are fed into the PLC via sensor counts (e.g., poke-yoke vision systems) or operator confirmations at the HMI.[](https://google.com/goto?url=CAESVgHrOzAVOshF3L8uGjlzxx2fSYWQKHFQNGbuthEcvovTk1bUFf0PPy9qbC6aLfgrUXHPr7cpnPR-5_dAwNpoFAWRYMNsgbnkewCLwiongPi59hxHGvtY) [[1]](https://google.com/goto?url=CAESVgHrOzAVOshF3L8uGjlzxx2fSYWQKHFQNGbuthEcvovTk1bUFf0PPy9qbC6aLfgrUXHPr7cpnPR-5_dAwNpoFAWRYMNsgbnkewCLwiongPi59hxHGvtY)[[2]](https://google.com/goto?url=CAESVAHrOzAVVLrdGZDtb8lTWF5oIo_ZOjVN8fqZULoqgA-7CH8Ip8WVGjdHiAa3PLuRy1pCzLmMAdtOZ3G4v8zCzXkXYHOsNzUn1pfmvc59XZdDmwG1rQ)[[3]](https://google.com/goto?url=CAESTQHrOzAVNpAUPiufMbhstS7YvYPyOvMX4MAcIZaxWjPLlf1tk8eBrmJek7bPQlNznXvH_ys_K1nveXOeFkWAS37-RcjsWEwQ8GfmHMG8)

- Raw bits and registers are streamed from the PLCs using standard industrial protocols such as **OPC UA, MQTT, MTConnect** , or vendor-specific protocols (EtherNet/IP, Modbus TCP).[](https://google.com/goto?url=CAESXAHrOzAVe1SqBGvqYcEe0_XAiAdjeBiu9rDAjIqInwVjd4zSq_79gBLnucuwnTId_mY8FhC8y8co1pYr9V_xEIjvN-701AEs2HWFeXqei_2TX-800WwsIvOfgkc0) [[1]](https://google.com/goto?url=CAESXAHrOzAVe1SqBGvqYcEe0_XAiAdjeBiu9rDAjIqInwVjd4zSq_79gBLnucuwnTId_mY8FhC8y8co1pYr9V_xEIjvN-701AEs2HWFeXqei_2TX-800WwsIvOfgkc0)[[2]](https://google.com/goto?url=CAESfQHrOzAVPGBcQeD4grMPrH3TAINh6uqROceZHf_Sjmc3OUBgEQVtpMBCV697fLUxjEuI6ezxSKHYSrV7qeTVTYi3K1_mbB1hd5bbISkctdgTCR77PTG8NMi8FusYMW2r1IT5zOGrb51fmTzqH_QHkBFvyhXCUdfDj6A-tlXy)

- An edge gateway or MES/IIoT platform ingests these high-frequency tags, maps them to active work orders (from your ERP), and calculates rolling OEE in real time rather than leaving operators to log data at the end of a shift.[](https://google.com/goto?url=CAESVAHrOzAVVLrdGZDtb8lTWF5oIo_ZOjVN8fqZULoqgA-7CH8Ip8WVGjdHiAa3PLuRy1pCzLmMAdtOZ3G4v8zCzXkXYHOsNzUn1pfmvc59XZdDmwG1rQ) [[1]](https://google.com/goto?url=CAESVAHrOzAVVLrdGZDtb8lTWF5oIo_ZOjVN8fqZULoqgA-7CH8Ip8WVGjdHiAa3PLuRy1pCzLmMAdtOZ3G4v8zCzXkXYHOsNzUn1pfmvc59XZdDmwG1rQ)[[2]](https://google.com/goto?url=CAESfQHrOzAVPGBcQeD4grMPrH3TAINh6uqROceZHf_Sjmc3OUBgEQVtpMBCV697fLUxjEuI6ezxSKHYSrV7qeTVTYi3K1_mbB1hd5bbISkctdgTCR77PTG8NMi8FusYMW2r1IT5zOGrb51fmTzqH_QHkBFvyhXCUdfDj6A-tlXy)

MES & Manufacturing Platforms that Integrate Directly with PLCs

Automating downtime categorization requires the system to not only detect that a machine stopped (via PLC state change), but also to determine why it stopped. Modern Manufacturing Execution Systems (MES) and Machine Monitoring platforms handle this via direct PLC tag mapping or hybrid workflows:

1. MachineMetrics (Intelligent MES / Machine Monitoring)

• How it integrates: Connects directly to modern CNCs and PLCs via OPC UA, MTConnect, or edge hardware without requiring extensive custom PLC programming.
• Automated Downtime: It automatically captures machine states and triggers out-of-the-box or custom logic. If a machine stops, it can automatically prompt operators via touchscreens to select a downtime reason code, or auto-categorize standard faults (e.g., "door open" or "servo alarm") directly mapped from PLC alarm registers.

2. Tulip Interfaces (Frontline Operations / MES Platform)

• How it integrates: Uses Tulip Edge Devices (Edge IO / Edge MC) and native machine connectors to communicate cleanly with PLCs via OPC UA, Modbus TCP, or Node-RED.
• Automated Downtime: Tulip allows you to build custom, human-centric apps where PLC state transitions (like an unexpected stop bit turning true) dynamically force a guided root-cause workflow on an operator tablet or station monitor, capturing fast categorization linked directly to the PLC event timestamp.

3. L2L (Leading2Lean) / Dispatch MES

• How it integrates: Connects to plant automation layers to capture real-time machine signals and triggers automated plant dispatch responses.
• Automated Downtime: When a PLC detects a stoppage exceeding a predefined threshold (e.g., 2 minutes of zero part production), L2L automatically dispatches an alert or work order to the correct support group (maintenance, quality, material handler) based on the specific PLC fault code, heavily reducing reliance on manual downtime logging.

• How it integrates: Offers robust plant-floor connectivity combining direct PLC/sensor hardware integration with high-engagement operator terminals.
• Automated Downtime: Known for rapid deployment, it blends automated machine state tracking (run vs. stop via PLC signals) with ultra-fast operator micro-stop categorization, driving peer accountability and immediate OEE visibility on live production floor scoreboards.

If you'd like to narrow this down, tell me:

• What PLC hardware are you currently running (e.g., Rockwell ControlLogix, Siemens S7-1500, Mitsubishi)?
• Do you prefer a cloud-hosted IIoT/MES platform or an on-premise traditional enterprise MES?

Yes. The most practical architecture is PLC → industrial connectivity layer/SCADA → MES/OEE engine → real-time dashboard + historian. You don't want operators manually starting/stopping downtime timers; the machine state and production counters should drive the calculation.

What you need for real-time OEE

OEE is:

OEE = Availability × Performance × Quality

In real time, collect at least:

• Availability: machine running/stopped state, planned vs. unplanned downtime, changeovers, faults
• Performance: actual cycle time/rate and production counts
• Quality: good count vs. scrap/reject count
• Context: product/SKU, work order, shift, line/cell, operator, reason codes

The critical piece for automated downtime categorization is a standard PLC state/reason-code interface. For example, the PLC can expose states such as RUNNING, E-STOP, JAM, STARVED, BLOCKED, CHANGEOVER, MAINTENANCE, etc. The MES maps those codes to its OEE reason hierarchy.

MES I'd look at first: Sepasoft MES

For a plant already using Ignition, Sepasoft is particularly compelling.

Sepasoft's OEE Downtime module explicitly supports real-time OEE/downtime tracking, automated data collection, and root-cause downtime detection. Its equipment configuration can take state and count values directly from Ignition tags, including PLC tags.

More importantly for your question, Sepasoft documents the equipment state as typically coming from a PLC tag, with the numeric PLC state mapped to a configured equipment state/reason. When the state changes, the OEE engine can automatically associate that state with the corresponding downtime reason.

It also has several algorithms for determining the actual line downtime/root cause when you have multiple machines in a line—including key reason, neighbor priority, parallel cells, blocked/starved conditions, etc.

Other MES platforms worth evaluating

One important distinction: "integrates with PLCs" doesn't necessarily mean the MES has a native PLC driver. Often the cleaner architecture is PLC → OPC UA/industrial gateway → MES. What matters is whether machine states, counters and fault codes arrive automatically and reliably enough for the MES to create events.

A good implementation pattern

I'd structure the PLC interface something like:

PLC
 ├── MachineState = RUN / STOP / FAULT / BLOCKED / STARVED
 ├── DowntimeReason = 101, 102, 103...
 ├── GoodCount
 ├── RejectCount
 ├── ActualCycleTime
 ├── CurrentProduct
 └── FaultCode
          ↓
   OPC UA / Ignition
          ↓
      MES / OEE
          ↓
   ┌──────────────────────┐
   │ Availability  91.4%  │
   │ Performance   94.8%  │
   │ Quality       98.7%  │
   │ OEE           85.5%  │
   └──────────────────────┘
          ↓
  Downtime Pareto / Andon

The big advantage is that the PLC generates the facts and the MES supplies the business meaning. For example, a PLC state 207 might be mapped to Unplanned Downtime → Mechanical → Conveyor Jam, rather than asking an operator to select a reason after the fact.

For Sepasoft specifically, the documentation recommends connecting equipment states and production counts from the PLC interface to the MES production model; it also supports live analysis that recalculates as production events occur.

My recommendation: if you're starting from scratch and have mixed PLC brands, I'd strongly consider Ignition + Sepasoft MES/OEE. If you're already standardized on Siemens, Rockwell, or AVEVA, I'd evaluate that vendor's MES first to minimize integration and support complexity.

If you tell me which PLCs you have (Allen-Bradley, Siemens, Mitsubishi, Omron, Beckhoff, etc.), your SCADA platform, and roughly how many machines/lines, I can narrow this to the best 2–3 architectures and show exactly how the PLC downtime tags should be structured.

Yes. The most practical architecture is PLC → industrial connectivity layer → MES → real-time OEE dashboard, with the PLC supplying machine state, production counts, rejects, and ideally standardized fault/reason codes.

What I’d recommend

Sepasoft MES on Ignition is particularly strong if your priority is real-time OEE plus automatic downtime categorization directly from PLC data.

• Sepasoft's OEE Downtime module can consume PLC tags for equipment state and production counts through Ignition.
• You can map PLC integer/state codes to categories such as Running, Unplanned Downtime, Planned Downtime, Blocked, Starved, Idle, etc. When the PLC state changes, the MES automatically associates the corresponding downtime reason.
• For complex lines, its downtime-detection algorithms can determine which cell actually caused a line-level stoppage, rather than simply recording "Line Down."
• Its Live Analysis exposes current OEE and other production KPIs as Ignition tags, allowing dashboards/HMIs to update essentially in real time; the update interval is configurable, with 60 seconds as the documented minimum/default for Live Analysis.
• OEE requires production information such as infeed/outfeed/waste counts, while Availability comes from the equipment state/downtime information.

How the real-time flow works

A typical implementation would look like:

PLC
 ├── Machine State / Fault Code
 ├── Good Count
 ├── Reject Count
 ├── Cycle Count / Cycle Time
 ├── Speed / Setpoint
 └── Product / Recipe

        ↓ OPC UA / industrial protocol

Ignition
 ├── PLC tag acquisition
 ├── Equipment hierarchy
 ├── Sepasoft MES
 ├── Downtime reason mapping
 └── OEE calculation

        ↓

Real-time dashboard
 ├── Availability
 ├── Performance
 ├── Quality
 ├── OEE
 ├── Current downtime
 └── Pareto of downtime reasons

The key design decision is where downtime intelligence lives. I would avoid trying to infer every downtime reason from dozens of unrelated PLC bits inside the MES. A better approach is to have the PLC expose a standardized machine-state/fault-code interface—for example:

Sepasoft specifically recommends a standardized PLC interface/UDT approach for scalable implementations.

Other MES options

AVEVA MES is another strong enterprise-scale choice. It provides real-time production control and explicitly supports real-time OEE KPI monitoring. Aveva It makes more sense when you're looking for a broader enterprise MES ecosystem rather than primarily an Ignition/SCADA-centric OEE implementation.

Siemens Opcenter is also worth evaluating if your plants are heavily standardized around Siemens automation. I'd put it on the shortlist for large, multi-site deployments, particularly where Siemens PLC/automation integration and enterprise MES are major requirements.

My shortlist

Bottom line: If you're specifically asking, "Which MES can take PLC machine states/faults and automatically turn them into real-time OEE and categorized downtime?", Sepasoft MES + Ignition is probably the first solution I'd prototype. Its architecture is unusually well suited to this exact PLC → downtime reason → OEE workflow.

If you tell me your PLC brand (Allen-Bradley, Siemens, Mitsubishi, Omron, etc.) and whether you already have an HMI/SCADA, I can narrow this down to the best architecture and show exactly how I'd structure the PLC tags and OEE calculation.

Getting real-time OEE (Overall Equipment Effectiveness) and automating downtime categorization requires bridging the gap between shop-floor automation (PLCs/sensors) and enterprise software (MES/SCADA).

How to Get Real-Time OEE Metrics

To move from manual data entry to live, automated OEE, the technical architecture typically follows a 4-step pipeline:

1. Signal Capture at the PLC: Configure your PLCs (Programmable Logic Controllers) to track machine states continuously—such as running, faulted, idle, or starved. You map specific memory bits, tags, or data blocks (DBs) to these machine states and cycle-count triggers (Availability, Performance, and Quality data points).
2. Industrial Edge or Middleware: Use an industrial gateway, OPC UA server (like Kepware), or edge device (like Ignition Edge or AWS IoT Greengrass) to poll or subscribe to PLC tags in real time without bogging down the primary control network.
3. Data Normalization & Contextualization: Raw PLC tags only show a machine is stopped (e.g., Tag Stop_Bit = 1 ). Middleware or the MES correlates this timestamp with production orders, part numbers, and shift schedules to give the data context.
4. Automated State & Downtime Categorization: When a stop occurs, the system logs the duration. If a specific error code comes directly from the PLC (e.g., Error_Code = 104 meaning "Jam at Station 3"), the system automatically categorizes the downtime without operator intervention. Unmapped or generic stops can prompt a quick operator selection on an HMI/touchscreen.

MES and Software Solutions with Direct PLC Integration

Several Manufacturing Execution Systems (MES) and industrial platforms specialize in direct PLC connectivity and automated downtime root-cause analysis:

• Inductive Automation Ignition (with Perspective/MES modules): Highly modular and heavily relies on universal standards (OPC UA, MQTT) to connect natively to almost any PLC (Rockwell, Siemens, Omron, Schneider). You can script or configure automated downtime state engines directly within the platform.
• Tulip Interfaces: Offers a flexible "Frontline Operations Platform" that connects to edge devices and machines via OPC UA, Node-RED, or machine vision. It excels at blending automated PLC triggers with guided operator input for hybrid downtime categorization.
• Critical Manufacturing MES: An Industry 4.0 native MES with robust IoT data collection frameworks that ingest direct telemetry from shop-floor automation layers to calculate real-time OEE and trigger automated alarms/stop categorization.
• Pillar / FactoryWiz / Vorne: If you need a more focused OEE/monitoring system rather than a full plant-floor MES, dedicated hardware/software hybrids like Vorne XL or FactoryWiz hook directly into PLC I/O or sensors for instant out-of-the-box real-time metrics.
• Siemens Opcenter / Rockwell FactoryTalk: Enterprise-grade suites that naturally integrate seamlessly if your shop floor runs on Siemens (S7/TIA Portal) or Rockwell (Studio 5000) controllers, automating data handshakes from the control layer up to the OEE dashboard.

To help narrow down the best architecture or software, could you share:

• What brand and model of PLCs are you currently using on the shop floor?
• Do you already have an OPC UA server or industrial network infrastructure in place?

Getting real-time OEE (Overall Equipment Effectiveness) and automating downtime categorization requires closing the loop between the shop floor machinery and your enterprise software stack.

Here is how you can achieve real-time OEE and the top Manufacturing Execution Systems (MES) or industrial application platforms that integrate directly with PLCs to log run-states and prompt operators or auto-classify downtime.

How to Get Real-Time OEE Metrics

To move away from manual shift-log entry and calculate OEE (OEE = Availability × Performance × Quality) in real time, follow this architecture:

1. Establish Direct PLC Connection: Connect your hardware data layer to the automation layer using industrial protocols like OPC UA, MQTT, Modbus TCP , or vendor-specific drivers (e.g., EtherNet/IP for Allen-Bradley, Profinet for Siemens).
2. Define State-Based Tag Mapping: Map machine signals (e.g., Running, Faulted, Idle, Part_Count, Reject_Count ) to specific digital and analog tags inside the PLC.
3. Automate Availability & Performance Tracking:
   • Availability: Trigger a downtime timer the moment a Running bit drops or a Fault code latches.
   • Performance: Compare actual cycle time (via part count timestamp deltas) against the engineered ideal cycle time stored in the MES/SCADA database.
4. Automate or Prompt Downtime Categorization:
   • Fully Automated: Map specific PLC fault/alarm words directly to downtime codes (e.g., PLC Alarm Code 104 = "Out of Raw Material").
   • Semi-Automated (Operator Assisted): When an unmapped stop occurs, force an interactive terminal or mobile HMI near the machine to prompt the operator for a reason code before the machine can restart or the timer times out.

Top MES and Platforms with Direct PLC Integration

• Tulip Interfaces : A modern frontline operations platform that connects directly to machines via Edge IO/Gateways using OPC UA, MQTT, and native PLC drivers. It excels at flexible, low-code apps that combine automated machine data with quick operator downtime prompting on tablets or touchscreens at the workstation.
• Rockwell Automation FactoryTalk (and FactoryTalk Metrics ): Deeply integrated natively with Allen-Bradley and ControlLogix PLCs. It automates OEE calculation and pulls machine statuses and alarm logs straight from the controller tags without needing complex middleware.
• Ignition by Inductive Automation : Technically an SCADA/IIoT application platform rather than a rigid MES, Ignition uses the Ignition MES module suite (by Sepsoft or other certified providers) to connect to virtually any PLC via OPC UA. It provides powerful real-time tag historization and completely customizable automated downtime categorization.
• Plex Systems (by Rockwell Automation) : A cloud-native MES/ERP that connects via Plex Industrial Gateway to capture PLC data in real time. It automatically records cycle counts and machine states, reducing manual overhead and streaming data directly to cloud dashboards.
• Epicor Advanced MES (formerly Mattec): Specifically built for automated machine monitoring and OEE. It hooks directly into PLC sensors or controllers to capture cycle times, cavity counts, and downtime reasons automatically, heavily favored in discrete and process manufacturing.

If you'd like to narrow this down, tell me:

• What PLC brands and models are you currently running (e.g., Allen-Bradley, Siemens, Omron)?
• Are you looking for a cloud-native or on-premise solution?

Yes. The key is to collect machine-state, cycle, count, and quality signals directly from the controls layer, then let the MES turn those signals into OEE and downtime events.

A practical real-time OEE architecture

PLC → OPC UA/industrial driver → MES/SCADA → OEE engine → dashboard

From the PLC, you typically want:

• Run/stop state
• Downtime/state code
• Cycle complete / part count
• Good vs. reject count
• Actual cycle time
• Fault/alarm codes
• Recipe/product
• Optional: speed, temperature, pressure, torque, etc.

The OEE engine calculates:

OEE = Availability × Performance × Quality

The important part is not merely calculating OEE—it is automatically determining why a machine stopped. For example:

PLC state 17 → "Robot Fault" → Unplanned Downtime → Maintenance

rather than having an operator manually select a reason every time.

My strongest fit: Sepasoft MES + Ignition

If you're looking for an MES that can integrate tightly with PLCs and automate downtime categorization, Sepasoft MES running on Inductive Automation Ignition is particularly well suited.

Sepasoft's OEE Downtime module can consume equipment mode/state/count values from Ignition tags, including PLC tags. Its equipment-state model maps PLC state codes to categories such as Running, Idle, Blocked, Starved, Planned Downtime, and Unplanned Downtime.

It also has automatic downtime-detection logic for more complicated lines. For example, it can determine which cell caused a line-level downtime event rather than simply recording "Line Down."

And its Live Analysis functionality exposes OEE, Availability, Performance, Quality, runtime, planned/unplanned downtime, counts, and downtime-reason information as real-time Ignition tags—useful for live production dashboards.

Other strong option: Siemens Opcenter

If you're already heavily invested in Siemens automation, Siemens Opcenter is another strong choice. Opcenter Execution Foundation OEE provides OEE calculation, downtime analysis, reason trees, equipment-state modeling, and KPI monitoring.

Siemens also has an architecture specifically designed to connect shop-floor equipment to Opcenter. Its Industrial Edge layer can connect PLCs using protocols including PROFINET, S7, OPC UA, EtherNet/IP, and Modbus TCP, while Opcenter components handle the MES integration.

What I'd choose

For a new implementation, I'd lean toward Ignition + Sepasoft if your priority is rapid, real-time OEE with direct PLC data and flexible automatic downtime categorization. Sepasoft's current MES 4.0 release supports Ignition 8.3, with the OEE Downtime module included in the current release line.

One important design decision: don't make the MES infer every downtime reason from a generic Run/Stop bit. Ideally, expose a PLC downtime/state code (or structured fault/status signals) and maintain a state/reason hierarchy in the MES. That gives you reliable automatic categorization while still allowing operators to correct ambiguous events.

Yes. The key is to collect machine-state and production signals directly from the PLC, classify those signals into standardized downtime reasons, and calculate OEE continuously rather than relying on operators to enter downtime after the fact.

Best fit: Sepasoft MES + Ignition

For the specific requirement you described, I would put Sepasoft MES running on Ignition near the top of the shortlist.

Sepasoft's OEE Downtime module can read equipment state, mode and count values from Ignition tags, with the equipment state typically coming directly from a PLC. It then maps those state values to downtime categories and records the events automatically.

It also supports automatic downtime detection for more complicated lines—for example, determining which cell is actually responsible when several machines are blocked/starved. Operators can subsequently override an automatically assigned reason with a more specific one, while retaining the automatic event.

For real-time OEE, Sepasoft provides live analysis of Availability, Performance and Quality, with automatically collected production counts, cycle times and downtime events.

Typical architecture:

PLC → OPC UA/PLC driver → Ignition → Sepasoft MES/OEE → real-time dashboard + historian/database

For example:

• PLC reports Running, Fault, Blocked, Starved, E-Stop, etc.
• PLC reports part counts and potentially cycle time.
• Ignition acquires those signals in real time.
• Sepasoft translates state codes into standardized downtime reasons.
• OEE is continuously recalculated.
• Operators see the current OEE and active downtime on an HMI/dashboard.
• Historical events are available for Pareto and root-cause analysis.

Other MES/OEE options worth evaluating

Siemens' Opcenter Execution Foundation OEE, for example, monitors machine status, calculates availability/performance/quality-related KPIs, and provides downtime and root-cause analysis. www.siemens.com Rockwell's Plex Production Monitoring similarly connects to the plant floor and provides real-time equipment KPIs, production cycles, quality, downtime, scrap and machine status. www.rockwellautomation.com Infor MES explicitly supports stop types such as planned, unplanned, breakdown, setup, quality and technical downtime for OEE reporting.

One important distinction

"Direct PLC integration" doesn't necessarily mean the MES has a proprietary PLC driver. In a modern architecture, it's often better to use an industrial connectivity layer such as OPC UA/OPC DA, MQTT, or the SCADA platform's native drivers.

For a mixed-vendor plant, I'd favor:

PLCs → OPC UA/industrial connectivity → Ignition → MES/OEE

That gives you one normalized machine-data layer while allowing Siemens, Allen-Bradley, Mitsubishi, Omron, etc. to feed the same OEE model.

If you tell me which PLCs you have (Allen-Bradley, Siemens, Beckhoff, etc.), how many machines/lines, and whether you already have SCADA/Historians, I can narrow this down to the best 2–3 architectures and explain exactly how the automatic downtime categorization would work.

To capture real-time Overall Equipment Effectiveness (OEE) metrics and automate downtime categorization, you need a tight architecture linking your shop-floor controls (PLCs) to an industrial data platform or Manufacturing Execution System (MES).

How to Get Real-Time OEE Metrics

Real-time OEE requires continuous calculation of its three core factors: OEE = Availability × Performance × Quality . To automate this in real time:

1. Establish Machine State and Count Connectivity: Connect your PLCs via industrial protocols (such as OPC UA, EtherNet/IP, or MQTT) to stream live boolean run/stop states, actual part/piece counts, and reject/scrap counts.
2. Map Ideal Cycle Times: Feed the target or ideal cycle time into your software layer either dynamically from an active ERP work order or from a static engineering baseline.
3. Stream Live Calculations: Instead of waiting for end-of-shift tallies, the software continuously divides actual run time by planned production time (Availability ), compares actual parts produced against the ideal rate over that active duration (Performance ), and tracks good parts versus total parts (Quality).

MES and Platforms that Integrate Directly with PLCs to Automate Downtime Categorization

Automating downtime categorization means translating raw PLC error/alarm codes into meaningful "Reason Codes" (e.g., mapping error tag Fault_Motor_Overheat directly to the downtime category Unplanned Mechanical Failure). Top solutions offering direct PLC connectivity and automated classification include:

• Sepasoft OEE & Downtime Module (on Ignition): Built natively on the Ignition Platform by Inductive Automation , Sepasoft connects directly to PLC tags via native drivers. It features robust downtime detection algorithms and equipment state machines that automatically trigger, log, and categorize stop events based on PLC signals.
• MachineMetrics: An industrial IoT and MES platform designed for deep machine connectivity . It plugs straight into machine controls, captures automated data streams, uses data science/AI to recognize micro-stops and faults, and maps PLC states directly to production losses without manual operator intervention.
• Fabrico: Natively unifies PLC error code mapping with OEE pulses and maintenance triggers . It treats incoming PLC error codes as an automated "on-ramp" to categorize downtime, pull up repair prompts, and log the exact duration of specific mechanical or electrical faults.
• DELMIAworks (formerly IQMS): An ERP/MES combo system with embedded shop-floor data collection. It interfaces cleanly with machine PLCs to automatically record cycle counts, runtime, and technical machine stops, bridging shop-floor realities with real-time enterprise metrics.

If you'd like to narrow this down, please share:

• What PLC hardware brands are you running (e.g., Allen-Bradley, Siemens, Omron)?
• Are you looking for a pure OEE/monitoring bolt-on or a full plant-wide MES suite?

Yes. The most practical way to get real-time OEE is to pull machine-state and production signals directly from the PLC, normalize them into equipment states, and let the MES calculate Availability, Performance, and Quality continuously.

My first choice: Sepasoft MES + Ignition

Sepasoft running on Inductive Automation is particularly well suited to this use case.

Sepasoft's OEE module can consume PLC tags through Ignition, including machine state, counts, and other signals. Its equipment-state model can automatically map PLC state values to conditions such as Running, Faulted, Idle, Blocked, Starved, CIP, etc.

That gives you a flow like:

PLC → OPC/industrial driver → Ignition tags → Sepasoft MES → OEE engine → live dashboards

The important distinction is that you're not asking an operator to start/stop a downtime timer. When the PLC changes state, the MES records the event and assigns the configured downtime reason. Sepasoft supports several downtime-detection algorithms for determining the actual/root cause of a line stoppage, including blocked/starved conditions and multi-cell equipment.

What I'd automate

At minimum, expose these PLC signals:

For example:

PLC reports FaultCode = 37 → MES maps 37 to "Robot Fault" → downtime event starts automatically → PLC returns to Running → event closes → OEE recalculates immediately.

Sepasoft specifically supports determining downtime from a numeric PLC state value and looking up the corresponding downtime reason.

Why this is better than just collecting stop/run

The key is automated categorization. If you only collect Run = 0, you get "machine stopped." That's technically real-time OEE, but operators still have to explain why.

A good implementation makes the PLC provide either:

• a machine state, or
• an alarm/fault code,

and the MES maintains the mapping:

PLC code → equipment state → downtime reason → OEE loss category.

Sepasoft also provides real-time OEE/downtime tracking and live analysis, exposing production KPIs through Ignition tags for dashboards and other applications.

Other MES platforms worth evaluating

I'd shortlist these depending on your existing automation stack:

1. Sepasoft + Ignition — my strongest choice when PLC integration and flexible downtime logic are priorities.
2. AVEVA MES — attractive for larger plants already standardized on AVEVA/AVEVA System Platform.
3. Rockwell FactoryTalk ProductionCentre — worth considering if you're heavily standardized on Allen-Bradley/Rockwell.
4. Siemens Opcenter — particularly compelling in Siemens/TIA environments.
5. Tulip — good for operator-centric applications, though I'd evaluate the depth of automatic PLC-driven OEE/downtime logic carefully against your requirements.

The big question isn't merely "Does the MES connect to PLCs?" Almost all serious MES platforms can. The question is how much of the PLC-to-OEE model is configurable without custom development.

For Sepasoft, for example, the vendor explicitly documents PLC tags as a normal source for real-time equipment status, and its OEE engine automatically generates downtime events from those state changes.

If you tell me your PLC brand/model (Allen-Bradley, Siemens, Mitsubishi, Omron, Beckhoff, etc.) and roughly how many machines/lines you have, I can narrow this to 2–3 MES options and show the exact PLC → MES → OEE architecture I'd use.

Getting real-time Overall Equipment Effectiveness (OEE = Availability × Performance × Quality) requires shifting from manual shift-log reporting to an automated Operational Technology (OT) and Information Technology (IT) data pipeline.

How to Get Real-Time OEE Metrics

1. Sensor & Signal Layer : Gather raw signals from your equipment—such as cycle completion pulses, run/stop status bits, and error codes—wired straight into your Programmable Logic Controllers (PLCs) or remote I/O modules.
2. Industrial Connectivity Protocol : Expose those PLC registers via standardized industrial communication protocols like OPC UA or MQTT . Avoid legacy custom middleware where possible to reduce latency.
3. Stream Processing & Contextualization : Route the live data into an edge device, SCADA system, or MES application layer that matches live equipment states against active production schedules and part numbers.
4. Dynamic Calculation Engine : Continuously compute the core components—measuring actual runtime vs. planned production time for Availability , ideal cycle time vs. actual part count for Performance , and good parts vs. total scrap for Quality —refreshing the dashboard values in seconds or minutes.

MES Platforms with Direct PLC Integration & Automated Downtime Categorization

Several manufacturing execution systems and production monitoring platforms natively connect to industrial controls (Siemens, Allen-Bradley, Modbus, OPC UA) without cumbersome middleware, using built-in logic rules to map PLC states and fault codes to accurate downtime categories (e.g., starved, blocked, fault/alarm , or changeover):

• MachineMetrics : A prominent IoT-driven MES and machine monitoring platform that connects directly to machine controls and diverse PLC protocols, automatically detecting machine states, streaming live OEE analytics, and categorizing downtime events.
• Sepasoft OEE & Downtime Module : Built on Ignition (an industrial application platform with native Allen-Bradley, Siemens, and OPC UA drivers), it provides robust automated downtime detection algorithms and direct database logging for OEE calculations.
• Shoplogix : Features automated downtime categorization tools that ingest machine states, cycle triggers, and explicit PLC error codes, translating raw controller data into real-time operational loss categories.
• Meta Smart Factory (MSF) : Offers native drivers for major PLC vendors (Siemens S7, Allen-Bradley EtherNet/IP, Modbus TCP) to bypass third-party middleware and feed live machine counters, scrap flags, and categorized downtime directly into the MES core.
• Oxmaint / Fabrico : Modern cloud-connected platforms that bridge maintenance and production, hooking directly into PLCs via OPC UA or MQTT to continuously evaluate the six big losses and auto-classify equipment stops.

If you want to narrow this down, let me know:

• What PLC hardware brands (e.g., Allen-Bradley, Siemens, Omron) are running on your shop floor?
• Do you already have a SCADA or Ignition layer installed, or do you need a purely native MES connection?