No-one wants to be writing the same code over and over again. Build reusable, maintainable automation systems with Asset Oriented Programming.
I provide expert consulting for developing modular, structured, and reusable PLC code using Asset Oriented Programming principles. Whether you’re starting from scratch or refactoring years of existing code, I help you establish a standard approach that reduces development time, improves maintainability, and creates truly reusable automation assets.
With many years of practicing Asset Oriented and Structured design patterns in industrial automation, I understand both the benefits and the challenges of transitioning to this approach. I’ll work with you to find the most practical path forward for your specific situation.
What Is Asset Oriented Programming?
Asset Oriented Programming (AOP) is a structured design pattern for PLC automation that treats each physical device or logical system as a self-contained “asset” with standardized interfaces, behavior, and data structures.
The core principle is simple: every asset of the same type (motor, valve, conveyor, etc.) should work exactly the same way, with the same inputs, outputs, alarms, and control logic. This standardization makes your code predictable, testable, and genuinely reusable across projects.
Key Benefits of Asset Oriented Design
- Reusability: Write once, use everywhere. Assets become drag-and-drop components across all your projects
- Maintainability: Fix or improve an asset once, and every instance benefits. No hunting through multiple projects for duplicate code
- Testability: Standard assets can be thoroughly tested in isolation, then trusted in production
- Onboarding: New engineers learn standard patterns once, then understand all your projects
- Simulation: With standardized data structures, simulation layers become straightforward to implement
- Consistency: Every motor works the same way. Every alarm follows the same pattern. No surprises.
The Structured Approach
Almost any project can benefit from a structured approach. The architecture is split into five basic layers, with additional optional layers for specific requirements:
1. Input Abstraction Layer
- Gathers information from physical hardware
- Stores signals in standardized input tags
- Isolates hardware dependencies from logic
- Provides foundation for simulation
2. Input Mapping Layer
- Copies input signals to Asset Data Blocks
- Uses User Defined Types (UDTs) for structure
- Ensures consistent data organization
- Creates standard interface for assets
3. Asset Management
- Library-managed Function Blocks control assets
- Handles alarms, status, and HMI integration
- Manages device-specific functionality
- Generates output requests and interlocks
4. Interlock Generation
- Assets create standard interlocks
- Stored in Asset Data Blocks
- Used by other devices and processes
- Optional omission for unused interlocks
5. Output Mapping Layer
- Extracts output requests from Asset Data Blocks
- Writes to physical output hardware
- Isolates control logic from I/O
- Simplifies hardware changes
Advanced Capabilities
Once the standard approach is established, additional capabilities become straightforward to implement:
System Generation
Collections of assets that work together can be packaged into versioned, library-managed System Function Blocks. A complete conveyor system, mixing system, or process unit becomes a single drag-and-drop component with all dependencies clearly defined. Systems use multiple Asset Data Blocks and may include dedicated System Data Blocks for coordination.
Alarm Management
With standardized asset structures, alarm handling becomes consistent across all devices. Alarms are raised by Asset Function Blocks in the same way for each asset type. Whether it’s a motor trip, sensor fault, or process alarm, the mechanism is identical. This consistency makes alarm configuration, documentation, and troubleshooting straightforward.
Simulation Layer
Because every signal for every asset is already defined in UDTs, building a simulation layer becomes remarkably straightforward. The simulation acts as a substitute for all input signals, isolated before they enter your Asset Function Blocks. This isolation means simulation cannot introduce errors to your process testing. If an asset behaves one way under simulation, it behaves exactly the same way with real signals.
Who Is This For?
You’re Starting From Scratch
You’re beginning a new project or building a new standard for your organization. Starting with Asset Oriented Programming from the beginning gives you the cleanest implementation and avoids the technical debt that comes from inconsistent approaches.
You Have Years of Existing Code
You’ve accumulated a large codebase over time, spanning multiple projects and programmers. Code reuse is minimal because nothing quite fits from project to project. Refactoring to Asset Oriented Programming seems daunting, but the long-term benefits justify the effort. I help you find the most practical migration path.
You Have “Loosely Standard” Code
You’ve attempted standardization before, but it’s inconsistent. Some projects follow patterns, others don’t. Function blocks exist but aren’t truly reusable. This is actually the most common starting point, and often provides good building blocks for full Asset Oriented design.
You’re Scaling Across Sites
You’re deploying similar systems across multiple locations. Without proper standardization, each site becomes a unique maintenance burden. Asset Oriented Programming makes multi-site deployments predictable and maintainable.
You’re Building a Team Standard
Different engineers approach problems differently. You need consistency so that any team member can work on any project without extensive handover. Asset Oriented Programming provides that consistency.
You Want to Reduce Technical Debt
You’re tired of maintaining duplicated code across projects. Bug fixes require changes in multiple places. Improvements don’t carry forward. Asset Oriented Programming creates a library of trusted, reusable components that improve over time.
How Consultation Works
Consultation packages are 100% tailored to your needs. There’s no one-size-fits-all approach to adopting Asset Oriented Programming.
Understanding Your Starting Point
I start by understanding where you are now. What code already exists? What patterns have you established? What constraints do you face? Starting from scratch is different from refactoring existing code, and both require different strategies.
Defining Your Goals
What are you trying to achieve? Complete reusability across all projects? Better maintainability? Faster development cycles? Simulation capability? The architecture adapts to your priorities.
Creating Your Standard
Together we develop your Asset Oriented approach. This includes:
- UDT structures for your common devices and systems
- Function Block templates and patterns
- Layer definitions and responsibilities
- Naming conventions and organizational structure
- Library management strategies
- Documentation templates and standards
Implementation Support
I can work with you to implement the approach in pilot projects, helping your team understand the patterns and develop confidence with the new structure. This hands-on work ensures the concepts become practical reality.
Knowledge Transfer
Asset Oriented Programming only succeeds if your team understands and embraces it. I provide training and documentation to ensure the approach lives beyond the initial consultation.
Platform Experience
I have experience with multiple PLC platforms:
- Siemens (TIA Portal, SIMATIC Manager)
- Allen Bradley / Rockwell Automation
- Schneider Electric
- Mitsubishi
- CODESYS-based platforms
However, the structured design principle applies to almost any modern PLC with symbolic programming capability. The concepts are platform-agnostic, even if the specific implementation details vary.
Real-World Experience
I’m not just a consultant who talks about Asset Oriented Programming – I practice it daily in real production environments. I develop and maintain automation systems for wastewater treatment plants, conveyor systems, and complex industrial processes using these exact principles.
I also create Asset Oriented Programming training content, so I’m constantly thinking about how to make these concepts clear and approachable. That teaching mindset ensures the consultation isn’t just technical implementation, but genuine understanding and capability building for your team.
Check out my LinkedIn and blog posts for examples of the work I do and the approaches I take.
Let’s Talk About Your Project
Whether you need help redesigning function blocks to be more modular, creating UDTs for future projects, establishing a complete Asset Oriented architecture, or anything in between, I can help ensure a standard approach that delivers reusable outcomes.
To get started:
- Use the form below to describe your current situation and what you’re trying to achieve
- We’ll arrange a call to discuss your needs in detail
- I’ll propose a tailored consultation approach that fits your goals, timeline, and budget
- We’ll work together to implement Asset Oriented Programming in a way that actually works for you and/or your organization
Contact me to discuss your requirements and explore how Asset Oriented Programming can transform your automation development.