IIoT ISA-95 Hierarchy

Overview

ISA-95 (IEC 62264) defines the standard equipment hierarchy for manufacturing. This skill provides guidance for modeling IIoT assets following these industry standards.

Hierarchy Levels

Equipment Hierarchy (Physical Assets)

Enterprise
└── Site
    └── Area
        └── Production Line (Work Center)
            └── Work Cell (Work Unit)
                └── Equipment Module
                    └── Control Module (Sensor/Actuator)

Automation Levels (Data Flow / ISA-95 Pyramid)

TMNL Schema Mapping

Plant

:plant

docker/iiot-db/init.sql:53

Line

:line

docker/iiot-db/init.sql:62

Machine

:machine

docker/iiot-db/init.sql:76

Sensor

:sensor

docker/iiot-db/init.sql:92

Decision Tree: Asset Classification

Modeling a physical asset?
│
├─ Facility/Building scope?
│  ├─ Multiple facilities?
│  │  └─ Use: Enterprise (extend schema if needed)
│  └─ Single facility?
│     └─ Use: Plant (ISA-95 Site/Area)
│
├─ Production sequence scope?
│  ├─ Multiple sequential steps?
│  │  └─ Use: Line (ISA-95 Work Center)
│  └─ Single processing area?
│     └─ Use: Area (optional sub-plant zone)
│
├─ Single equipment/machine?
│  ├─ Multiple coordinated units?
│  │  └─ Use: Work Cell (group of machines)
│  └─ Individual machine?
│     └─ Use: Machine (ISA-95 Equipment Module)
│
└─ Measurement/control point?
   ├─ Sensor (reads values)?
   │  └─ Use: Sensor (ISA-95 Control Module)
   └─ Actuator (writes values)?
      └─ Use: Actuator (ISA-95 Control Module)

Graph Relationships (Apache AGE)

Standard Edge Types

[:contains]

[:contains]

[:monitors]

[:controls]

[:triggered_by]

[:caused]

Creating Hierarchy in Cypher

-- Create plant (ISA-95 Site)
SELECT * FROM cypher('iiot', $$
    CREATE (:plant {
        id: 'PLANT-A',
        name: 'Chicago Assembly',
        location: 'Chicago, IL',
        timezone: 'America/Chicago'
    })
$$) AS (v agtype);

-- Create line (ISA-95 Work Center)
SELECT * FROM cypher('iiot', $$
    CREATE (:line {
        id: 'LINE-001',
        name: 'Body Assembly',
        plant_id: 'PLANT-A',
        capacity: 60  -- units per hour
    })
$$) AS (v agtype);

-- Create relationship
SELECT * FROM cypher('iiot', $$
    MATCH (p:plant {id: 'PLANT-A'}), (l:line {id: 'LINE-001'})
    CREATE (p)-[:contains]->(l)
$$) AS (e agtype);

-- Create machine (ISA-95 Equipment Module)
SELECT * FROM cypher('iiot', $$
    CREATE (:machine {
        id: 'MCH-001',
        name: 'Welding Robot Alpha',
        model: 'FANUC R-2000iC/210F',
        line_id: 'LINE-001',
        commissioned_date: '2023-01-15'
    })
$$) AS (v agtype);

-- Create sensor (ISA-95 Control Module)
SELECT * FROM cypher('iiot', $$
    CREATE (:sensor {
        device_id: 'TMP-001',
        type: 'temperature',
        unit: 'celsius',
        machine_id: 'MCH-001',
        sample_rate_ms: 1000,
        threshold_high: 30,
        threshold_critical: 35
    })
$$) AS (v agtype);

Querying Hierarchy

-- Get full path from sensor to enterprise
SELECT * FROM cypher('iiot', $$
    MATCH path = (s:sensor {device_id: 'TMP-001'})-[:monitors]->
                 (m:machine)<-[:contains]-
                 (l:line)<-[:contains]-
                 (p:plant)
    RETURN s.device_id, m.name, l.name, p.name
$$) AS (sensor agtype, machine agtype, line agtype, plant agtype);

-- Find all sensors on a specific machine
SELECT * FROM cypher('iiot', $$
    MATCH (m:machine {id: 'MCH-001'})<-[:monitors]-(s:sensor)
    RETURN s.device_id, s.type, s.unit
$$) AS (device_id agtype, type agtype, unit agtype);

-- Get all equipment in a plant (recursive)
SELECT * FROM cypher('iiot', $$
    MATCH (p:plant {id: 'PLANT-A'})-[:contains*]->(asset)
    RETURN labels(asset)[0] AS asset_type, asset.id AS id, asset.name AS name
$$) AS (asset_type agtype, id agtype, name agtype);

Extended Hierarchy (Optional)

For enterprise-scale deployments, extend the schema with additional levels:

// src/lib/iiot/schemas/assets.ts

import { Schema } from 'effect'

// Branded identifiers
export const EnterpriseId = Schema.String.pipe(Schema.brand('EnterpriseId'))
export const SiteId = Schema.String.pipe(Schema.brand('SiteId'))
export const AreaId = Schema.String.pipe(Schema.brand('AreaId'))
export const PlantId = Schema.String.pipe(Schema.brand('PlantId'))
export const LineId = Schema.String.pipe(Schema.brand('LineId'))
export const MachineId = Schema.String.pipe(Schema.brand('MachineId'))
export const DeviceId = Schema.String.pipe(Schema.brand('DeviceId'))

// Enterprise (multi-site corporation)
export const Enterprise = Schema.TaggedStruct('Enterprise', {
  id: EnterpriseId,
  name: Schema.NonEmptyString,
  industry: Schema.optional(Schema.String),
})

// Site (physical location)
export const Site = Schema.TaggedStruct('Site', {
  id: SiteId,
  name: Schema.NonEmptyString,
  enterpriseId: EnterpriseId,
  location: Schema.optional(Schema.String),
  timezone: Schema.optional(Schema.String),
})

// Area (sub-plant zone)
export const Area = Schema.TaggedStruct('Area', {
  id: AreaId,
  name: Schema.NonEmptyString,
  siteId: SiteId,
  type: Schema.optional(Schema.Literal('production', 'warehouse', 'maintenance')),
})

// Plant (our current top-level)
export const Plant = Schema.TaggedStruct('Plant', {
  id: PlantId,
  name: Schema.NonEmptyString,
  areaId: Schema.optional(AreaId),  // Optional if using simplified hierarchy
  location: Schema.optional(Schema.String),
})

// Line (production line)
export const Line = Schema.TaggedStruct('Line', {
  id: LineId,
  name: Schema.NonEmptyString,
  plantId: PlantId,
  capacity: Schema.optional(Schema.Number),
})

// Machine (equipment)
export const Machine = Schema.TaggedStruct('Machine', {
  id: MachineId,
  name: Schema.NonEmptyString,
  model: Schema.optional(Schema.String),
  lineId: LineId,
  commissionedDate: Schema.optional(Schema.DateFromString),
})

// Sensor type enumeration
export const SensorType = Schema.Literal(
  'temperature',
  'vibration',
  'humidity',
  'pressure',
  'speed',
  'current',
  'voltage',
  'flow',
  'level'
)

// Sensor (control module)
export const Sensor = Schema.TaggedStruct('Sensor', {
  deviceId: DeviceId,
  type: SensorType,
  unit: Schema.NonEmptyString,
  machineId: MachineId,
  sampleRateMs: Schema.optional(Schema.Number),
  thresholdHigh: Schema.optional(Schema.Number),
  thresholdCritical: Schema.optional(Schema.Number),
})

ISA-88 Integration (Batch Manufacturing)

For batch processes, ISA-88 provides additional concepts:

These map to the same physical hierarchy but add procedural concepts for batch control.

Best Practices

Naming Conventions

PLANT-{CODE}

PLANT-A

PLANT-CHI

LINE-{NNN}

LINE-001

LINE-042

MCH-{NNN}

MCH-001

MCH-123

{TYPE}-{NNN}

TMP-001

VIB-002

ALM-{UUID}

ALM-abc123...

Sensor Type Prefixes

TMP

VIB

HUM

PRS

SPD

CUR

VLT

FLW

LVL

Related Skills

• /iiot-unified-namespace

  - Topic hierarchy and data flow

• /nex-effect-services

  - Effect-TS service patterns

• /effect-schema-mastery

  - Schema definition patterns

References

• ISA-95 Standard
• ISA-88 Standard
• IEC 62264 (ISA-95 international)