Building a connected factory requires addressing six critical challenges: data extraction, transport, storage, processing, consumption, and security. The AMRC Factory+ framework provides a comprehensive open-source solution that reimagines data management in manufacturing. This tutorial explores the Factory+ reference framework and its practical implementation through the AMRC Connectivity Stack.

Understanding Factory+ is essential for engineers and architects designing industrial IoT architectures that require standardized, scalable approaches to manufacturing data infrastructure.

‍

What is Factory+

Factory+ is a cutting-edge open-source reference framework that establishes the digital blueprints necessary for state-of-the-art connected manufacturing facilities. Developed by the Advanced Manufacturing Research Center at the University of Sheffield in the UK, Factory+ provides a unified approach to industrial data management.

Factory+ is an open, adaptable framework that completely reimagines data management in manufacturing industries. Think of it as a LEGO kit of interconnected parts that sets the stage for an Industry 4.0 architecture perfect for building today's connected factory.

‍

‍

The Infrastructure-Centric Approach

An interesting aspect of Factory+ that distinguishes it from traditional approaches: it connects components to infrastructure rather than connecting them directly to each other.

This infrastructure-centric design eliminates the point-to-point integration complexity that plagues many industrial IoT implementations, creating a more flexible and maintainable architecture.

‍

Six Key Elements of Factory+

Factory+ provides a unified approach to six key elements of manufacturing data management:

‍

1. Data Extraction

Standardized methods for getting data out of devices, PLCs, and equipment. Rather than custom integration for each device type, Factory+ defines consistent extraction patterns.

‍

2. Data Transport

Standardized mechanisms for moving data after extraction. Factory+ uses MQTT Sparkplug as its communication backbone, providing reliable, efficient message transport.

‍

3. Data Storage

Specifications for how to store data consistently across the architecture, enabling predictable data access patterns.

‍

4. Data Processing

Guidelines for how to process data in standardized ways, reducing custom processing logic.

‍

5. Data Consumption

Methods for making data available for consumption by all interested components within the smart manufacturing architecture, ensuring data accessibility.

‍

6. Data Protection

Security specifications addressing authentication, authorization, and data protection throughout the architecture.

‍

The Architectural Foundation Advantage

What's cutting edge about Factory+ is its forward-thinking approach to understanding the importance of a strong architectural base. Many industrial IoT implementations lack strong foundational architecture, leading to fragmented, difficult-to-maintain systems.

By providing comprehensive architectural specifications, Factory+ enables engineers to focus more on problem-solving rather than data management. Currently, engineers spend valuable time on data management aspects. With Factory+ handling standardized data infrastructure, engineers gain instant access to standardized data and can focus on delivering value in areas where it makes sense.

‍

Technology Stack

Factory+ uses modern, proven technologies as its foundation:

MQTT Sparkplug Pipeline: Communication backbone providing efficient, scalable messaging

OPC UA: Protocol for communication between industrial devices and accessing raw process variables from field equipment before ingesting them into the MQTT Sparkplug pipeline

JSON Schema: Data modeling language for defining consistent data structures

Kubernetes: Container orchestration platform for deploying the framework

‍

AMRC Connectivity Stack (ACS)

While Factory+ is an excellent abstract conceptual framework, the AMRC took it to the next level by developing a practical solution that implements the abstract framework: the AMRC Connectivity Stack (ACS).

ACS is a toolbox containing all open-source services that AMRC crafted to help implement the Factory+ framework from start to finish.

‍

Quick Deployment

The best part about ACS: it's quick to set up. You can deploy the AMRC Connectivity Stack onto an existing Kubernetes cluster in literally seconds using a Helm chart. That's all you need to get Factory+ rolling.

The GitHub repository for the AMRC Connectivity Stack contains all installation instructions for deploying the connectivity stack into a Kubernetes cluster, with detailed steps for successful deployment.

‍

Three Foundational Principles

Factory+ is built on three foundational principles that serve as pillars of the reference framework:

1. Edge-Driven
2. Infrastructure-Centric
3. Report by Exception

These principles align with concepts advocated by unified namespace proponents like Walker Reynolds, representing the technical minimum requirements for a unified namespace architecture.

‍

Principle 1: Edge-Driven

Edge-driven is a data exchange mechanism where data is pushed from the edge (the component producing data) whenever that data is ready, rather than being pulled by a third party using request-response polling.

This represents a fundamental shift from traditional centralized architectures where a central server or master requests information on a schedule.

Benefits of Edge-Driven Architecture:

Reduced Latency: Faster response times and ability to make real-time decisions. You can create responsive applications that only respond to events as they're pushed from the edge, rather than constantly checking status.

Energy Efficiency: Particularly important for resource-constrained devices. With edge-driven architecture, there's no need to constantly poll data, so devices conserve energy when there's no new data to share.

Better System Performance: Lightens the load on central servers or control systems, resulting in better overall system performance and stability. Less strain equals more gain on your infrastructure.

Enhanced Security: By eliminating the need to open inbound ports, edge-driven architecture minimizes the risk of unauthorized access. Communication initiated from the edge doesn't require opening ports for external access, helping keep network environments secure.

‍

Principle 2: Infrastructure-Centric

Infrastructure-centric architecture means components connect to a shared infrastructure rather than directly to each other. Instead of creating point-to-point connections between every component that needs to communicate, all components connect to a common infrastructure layer.

Benefits of Infrastructure-Centric Design:

Reduced Complexity: Eliminates the exponential growth of connection complexity as components increase. With direct connections, adding one component might require N new connections. With infrastructure-centric design, each component needs only one connection to the infrastructure.

Flexibility: Components can be added, removed, or replaced without affecting other components. Changes are isolated to the component and its connection to infrastructure.

Standardization: All components communicate using standardized patterns and protocols defined by the infrastructure, ensuring interoperability.

Scalability: Adding new components doesn't require reconfiguring existing components, enabling seamless growth.

‍

Principle 3: Report by Exception

Report by exception means components publish data only when values change rather than sending data continuously at fixed intervals regardless of whether anything changed.

Benefits of Report by Exception:

Reduced Network Traffic: Only meaningful changes are transmitted, dramatically reducing bandwidth consumption compared to continuous polling.

Lower Processing Load: Systems only process actual changes rather than repeatedly processing unchanged values.

Better Signal-to-Noise Ratio: Applications receive relevant information (changes) rather than being flooded with redundant data.

Resource Efficiency: Computing, network, and storage resources are used only when necessary.

This principle aligns perfectly with event-driven architectures where systems respond to meaningful events rather than constantly monitoring for changes.

‍

Core Components of Factory+

Factory+ defines several core components that work together to implement the framework:

‍

1. MQTT Broker

The MQTT broker serves as the central message distribution system. It receives messages from publishers (edge agents) and routes them to subscribers (applications and services).

The broker implements the infrastructure layer that enables the infrastructure-centric architecture. All components connect to the broker rather than to each other.

Factory+ specifications define requirements for MQTT broker configuration, security, and performance to ensure consistent behavior across implementations.

‍

2. Directory Service

The directory service provides a centralized registry of all components, services, and resources in the Factory+ architecture. It enables service discovery—components can query the directory to find other services they need to interact with.

The directory service maintains metadata about:

• Available edge agents and their capabilities
• Data schemas and their locations
• Service endpoints and protocols
• Authentication and authorization information

This centralized registry simplifies configuration management and enables dynamic discovery of new components.

‍

3. Edge Agent

The edge agent is the workhorse of the Factory+ reference framework. It operates at the periphery (the edge), and its role includes:

Data Gathering: Collecting data from devices using protocols like OPC UA, Modbus, or proprietary interfaces

Data Normalization: Converting data into standardized schemas regardless of source device or protocol

Message Packaging: Converting normalized data into MQTT Sparkplug messages

Message Transmission: Publishing messages to the MQTT broker

The edge agent abstracts away the complexity of different device types and protocols, presenting a consistent interface to the rest of the system.

‍

4. Data Schema

Without proper context and structure, data collected from manufacturing equipment isn't useful for making sense of operations. When collecting data from multiple device types and variants and putting it into a common architecture, the challenge of creating context from unlabeled, unstructured data always presents itself.

To address this issue, Factory+ includes a data schema specification that allows new and existing models to be represented across the framework in a modular, reusable, and consistent format.

Data Schema Benefits:

Standardized Collection: Data is gathered in a standardized manner from the start

Eliminates Manual Processing: No need for manual data contextualization that's typically required when integrating PLC data

Consistency: All data follows the same structural patterns, simplifying application development

Reusability: Schema definitions can be reused across multiple installations and device types

‍

Factory+ Schema Specification

Factory+ schema allows creating new models using JSON Schema, but importantly, it's not meant to replace existing specifications like OPC UA companion specifications or MTConnect. Rather, it provides guidelines for using JSON Schema to create custom models that will be understood within the Factory+ reference framework.

The AMRC has developed a collection of models utilized internally and released as open-source resources, providing starting points for common manufacturing scenarios.

Factory+ schemas use JSON Schema version 2020-12, a vocabulary that emphasizes structure and enables validation of JSON components.

Schema Rules:

All Factory+ schemas must adhere to specific rules:

• Must use JSON Schema 2020-12
• Must use integer version numbers to control schema version
• Must include specific metadata elements
• Must follow defined patterns for representing Sparkplug metrics
• Must support composition and inheritance patterns

The Factory+ reference framework provides detailed examples showing:

• How metrics are defined
• What must be included in schema definitions
• Schema UUID usage
• Reusability patterns
• Composition versus inheritance approaches
• Sparkplug metric representation

‍

Implementation Approach

Implementing Factory+ in a manufacturing facility follows a systematic approach:

‍

1. Deploy the Infrastructure

Install the AMRC Connectivity Stack on a Kubernetes cluster using the provided Helm chart. This establishes the MQTT broker, directory service, and supporting services.

‍

2. Define Data Schemas

Create or adopt data schemas for your equipment types. Use existing AMRC schemas where applicable or define custom schemas following Factory+ guidelines.

‍

3. Deploy Edge Agents

Install edge agents on appropriate edge devices or gateways. Configure them to connect to your equipment using appropriate protocols (OPC UA, Modbus, etc.) and to the MQTT broker.

‍

4. Develop Applications

Build applications that subscribe to relevant topics on the MQTT broker to consume data. Applications use the data schemas to understand message structure and meaning.

‍

5. Iterate and Expand

Add new equipment types, edge agents, and applications incrementally. The infrastructure-centric design enables gradual expansion without disrupting existing components.

‍

Benefits of Factory+

Adopting the Factory+ framework provides numerous advantages:

Reduced Integration Time: Standardized patterns and pre-built components accelerate deployment

Lower Maintenance: Infrastructure-centric design isolates changes, reducing maintenance burden

Vendor Independence: Open standards prevent vendor lock-in

Scalability: Architecture supports growth from pilot projects to enterprise-wide deployments

Security: Built-in security specifications address authentication, authorization, and data protection

Community Support: Open-source approach enables community contributions and shared learning

‍

Summary

AMRC Factory+ provides a comprehensive open-source reference framework for smart manufacturing that addresses the six critical elements of industrial data management: extraction, transport, storage, processing, consumption, and protection. Built on three foundational principles—edge-driven, infrastructure-centric, and report by exception—Factory+ creates scalable, maintainable architectures.

The AMRC Connectivity Stack implements Factory+ concepts through deployable open-source services, enabling rapid deployment on Kubernetes clusters. Core components including the MQTT broker, directory service, edge agents, and data schemas work together to provide standardized data infrastructure that allows engineers to focus on problem-solving rather than data management.

By adopting Factory+, organizations establish strong architectural foundations that support digital transformation initiatives, enabling flexible, scalable connected manufacturing systems that deliver long-term value.

‍