Skip to main content
IIoT Machine Connector (OPC-UA / MQTT / Modbus) — An edge agent plus a Frappe app that streams live machine telemetry into ER — 1/1Illustrative preview

An edge agent plus a Frappe app that streams live machine telemetry into ERPNext over OPC-UA,

MQTT, and Modbus, so good/scrap counts, cycle times, and downtime are captured on Job Cards automatically instead of typed in. Build-to-order:

ECOSIRE scopes, builds, installs, and supports it for your plant.

What is IIoT Machine Connector (OPC-UA / MQTT / Modbus)?

An edge agent plus a Frappe app that streams live machine telemetry into ERPNext over OPC-UA, MQTT, and Modbus, so good/scrap counts, cycle times, and downtime are captured on Job Cards automatically instead of typed in. Build-to-order: ECOSIRE scopes, builds, installs, and supports it for your plant. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $999.00 USD; request a quote for a scoped proposal.

Key Features

OPC-UA client edge agent with subscription/monitored-item support for modern CNC controllers, robots, and PLCs exposing an OPC-UA server
MQTT subscriber supporting standard topics and Sparkplug B payloads from brokers such as Mosquitto and EMQX, with QoS and TLS options
Modbus TCP and RTU polling for legacy PLCs, VFDs, and energy meters, with configurable register maps, data types, byte/word order, and scaling
New `Machine`, `Machine Signal Map`, `Machine Telemetry`, and `Downtime Log` DocTypes that model tags, mappings, and readings natively in ERPNext
Auto-mapping of each machine signal to an ERPNext Workstation and, where relevant, to the active Work Order Job Card
Real-time good-count and scrap/reject-count capture that increments Job Card completed and rejected quantities via `hooks.py` doc events and Server Scripts
Cycle-time capture per part for accurate Performance in the OEE calculation instead of shift-average guesses
Automatic downtime detection: a `scheduler_events` state machine opens a `Downtime Log` when a machine holds a stop/idle state past a configurable threshold, with reason-code prompts
OEE dashboard (Availability x Performance x Quality) computed from timestamped telemetry, filterable by machine, Workstation, shift, and date range
Store-and-forward buffering on the edge agent so readings survive network or bench outages and backfill on reconnect, keeping counts consistent
Authenticated ingestion through the Frappe REST API using scoped `@frappe.whitelist()` methods, API-key/secret auth, and a dedicated role profile — no bench-admin credentials on the shop floor
Configurable poll intervals, deadband/change-of-value filtering, and per-signal unit scaling to keep telemetry volume and DB growth sane
Live machine board and status tiles on Workstation and Job Card views via Client Scripts, with color-coded run/idle/stopped/fault states
Idempotent, edge-timestamped writes with de-duplication so retries and buffered backfills never double-count production

Built to order, done for you

No DIY setup — a working app, built, installed and supported by ECOSIRE.

  1. 1

    You order

    Start with a one-time build price. We scope it with you at kickoff.

  2. 2

    We build & install

    ECOSIRE builds, configures and installs it on your ERPNext.

  3. 3

    Go live + support

    You go live in about one working week, with two weeks of go-live support. Defects in the code we deliver are fixed free of charge.

Technical Specifications

ERPNext Compatibility
—
License
Licence confirmation required
Python Requirement
Python 3.10+
Database
MariaDB 10.6+

About this Product

Most ERPNext Manufacturing setups still capture production by hand. Operators tap "Complete" on a Job Card at the end of a shift, guess the scrap count, and downtime lives in a notebook that never reaches the ERP. The result is OEE numbers you cannot trust, backdated production entries, and no way to see a stalled line until the daily report. ERPNext core has excellent Work Order, Job Card, and Workstation DocTypes, but nothing that talks to a CNC controller, a PLC register, or an MQTT broker — the machine floor and the ERP are simply not connected.

The IIoT Machine Connector closes that gap. It is delivered in two parts: a lightweight edge agent that runs on-premise (a mini-PC or industrial gateway on the shop-floor network) and a proper Frappe app installed on your ERPNext bench. The edge agent speaks three protocols — an OPC-UA client for modern CNCs and robots, an MQTT subscriber for brokers like Mosquitto/EMQX and Sparkplug B devices, and Modbus TCP/RTU polling for legacy PLCs and energy meters. It reads machine tags on a configurable interval, buffers locally when the network drops, and posts normalized readings to ERPNext through the Frappe REST API using authenticated @frappe.whitelist() endpoints and a scoped API-key role profile.

Inside ERPNext we build new DocTypes — Machine, Machine Signal Map, and Machine Telemetry (plus a Downtime Log) — that map each raw tag to a Workstation and to the fields that matter: good count, scrap/reject count, cycle time, and machine state. hooks.py doc events and Server Scripts translate incoming telemetry into ERPNext transactions: a rising good-count edge increments the linked Job Card's completed quantity, scrap increments the reject quantity, and cycle time is written for downstream OEE. A scheduler_events job runs a state machine that detects when a machine sits in stop/idle beyond a threshold and opens a Downtime Log with a reason code, so unplanned downtime is captured the moment it happens, not reconstructed later. Client Scripts add live tiles and a color-coded machine board to the Workstation and Job Card views. OEE (Availability x Performance x Quality) is then computed from real, timestamped data rather than shift-end estimates.

Because this is build-to-order, nothing is a generic download. We start with a scoping call to inventory your machines, controllers, protocols, and the exact tags/registers to read, then confirm the signal-to-Workstation mapping and downtime reason taxonomy. We build against your ERPNext version (v15 or v16), validate the whole pipeline on a staging bench with a simulated or mirrored device feed, run UAT with your team, and only then install on production with a documented rollback. You receive the full source of your version, a git repository, and a post-go-live support window. Typical delivery is one working week from confirmed scope, depending on the number of machines and protocol mix.

What you get

  • Installable source code for your version of the IIoT Machine Connector Frappe app plus the edge agent
  • On-site or remote installation and configuration on your ERPNext bench, including device/tag mapping and the edge-agent deployment
  • Technical documentation: DocType reference, signal-map schema, protocol/register configuration, API endpoints, and hooks/scheduler behavior
  • End-user guide plus a live training session for operators, supervisors, and the ERPNext admin
  • UAT on a staging bench with a simulated or mirrored device feed, sign-off checklist, and a documented rollback plan
  • Post-go-live support window for bug fixes and configuration adjustments after production cutover
  • Git repository handover with full commit history, README, and deployment/branch notes
  • OEE and downtime dashboard configuration tuned to your machines, shifts, and reason-code taxonomy

Who this is for

Smart-factory / Industry 4.0 lead

Owns the digital-factory roadmap and needs CNCs, robots, and conveyors feeding ERPNext directly over OPC-UA/MQTT/Modbus so OEE, counts, and downtime come from machines, not spreadsheets. Wants a maintainable Frappe app, not a bespoke integration black box.

Manufacturing / production manager

Lives in ERPNext Work Orders and Job Cards and is tired of unreliable, backdated production entries. Needs trustworthy real-time good/scrap counts and automatic downtime capture with reason codes to run daily standups and hit throughput targets.

ERPNext system administrator / implementation partner

Responsible for the bench, upgrades, and permissions. Needs a clean Frappe app that respects DocType conventions, `hooks.py`, role profiles, and v15/v16 compatibility, with source and a git repo so future upgrades and maintenance stay in-house.

Maintenance / reliability engineer

Cares about MTBF/MTTR and unplanned stoppages. Wants machine-state-driven downtime logs with timestamps and reasons flowing into ERPNext so patterns are visible and maintenance can be planned against real fault data.

How IIoT Machine Connector (OPC-UA / MQTT / Modbus) Compares

CriterionECOSIRECustom BuildCompetitorERPNext Native
Machine data into ERPNextEdge agent streams OPC-UA/MQTT/Modbus straight into ERPNext DocTypesDepends entirely on what your developer builds and maintainsOften a generic MQTT listener with limited protocol coverageNone — no shop-floor protocol support in core
Counts & cycle timeAutomatic good/scrap counts and per-part cycle time on Job CardsPossible but you scope and build every rule yourselfBasic count import; cycle time usually not modeledManual Job Card entry, typically at shift end
Downtime captureAuto-detected from machine state with reason-coded Downtime LogBuildable, but state-machine logic is non-trivial to get rightRarely included; manual logging if at allNotebook or manual, reconstructed after the fact
OEEAvailability x Performance x Quality from real timestamped dataOnly as accurate as the data pipeline you buildSometimes a dashboard, but fed by partial dataNot computed from machine data
Frappe-native architectureProper Frappe app: DocTypes, hooks.py, Server/Client Scripts, schedulerVaries — may bypass conventions and complicate upgradesUsually a Frappe app, quality and fit varyN/A
Fit to your machinesScoped to your exact tags, registers, and Workstation mappingFully custom but you carry all discovery and rework riskConfigure to a fixed template; edge cases need workaroundsN/A
Reliability under network lossEdge store-and-forward buffering with idempotent backfillMust be designed and tested in — often skippedFrequently drops data on disconnectN/A
Source, support & upgradesFull source, git handover, post-go-live support, v15/v16 targetYou own it and its entire maintenance burdenVendor-controlled; source and roadmap may be closedCovered by ERPNext core, but feature absent

Frequently Asked Questions about IIoT Machine Connector

How long does delivery take?

This is a build-to-order product, not an instant download. Typical delivery is one working week from confirmed scope. The exact timeline depends on how many machines and controllers are in scope and the protocol mix (OPC-UA vs MQTT vs Modbus); a mixed fleet with legacy Modbus register mapping sits at the longer end. We confirm a firm schedule with you after the scoping call.

Which ERPNext and Frappe versions do you support?

We build against ERPNext/Frappe v15 and v16 and target your specific deployed version. The connector is a standard Frappe app installed on your bench using DocTypes, `hooks.py` doc events, Server/Client Scripts, and `scheduler_events`, so it upgrades along the normal `bench` path. Tell us your version on the scoping call and we build to match.

What machines and protocols can it connect to?

Anything that exposes OPC-UA (most modern CNCs, robots, and PLCs), publishes to an MQTT broker (including Sparkplug B), or speaks Modbus TCP/RTU (legacy PLCs, VFDs, energy meters). During scoping we inventory each machine's controller, available tags/registers, and mapping to your ERPNext Workstations. If a machine has no digital interface, we advise on a minimal sensor/gateway option.

How does the machine data actually get into ERPNext, and is it secure?

An on-premise edge agent reads the machines and posts normalized readings to ERPNext over the Frappe REST API using authenticated `@frappe.whitelist()` endpoints, an API key/secret, and a scoped role profile — no bench-admin credentials sit on the shop floor. Writes are idempotent and edge-timestamped with de-duplication, and the agent buffers locally during network outages and backfills on reconnect, so counts stay correct.

Do we own the code, and what about support and updates?

Yes. You receive the full source for your version and a git repository with commit history, so you are never locked in. Every engagement includes a post-go-live support window for bug fixes and configuration tuning. Beyond that window we offer optional support and update retainers, and because it is a maintainable Frappe app your own team or implementation partner can extend it.

How is OEE calculated, and where does downtime come from?

OEE is computed as Availability x Performance x Quality from timestamped telemetry: good/scrap counts drive Quality, captured cycle times drive Performance, and machine run/stop state drives Availability. Downtime is detected automatically by a scheduler state machine that opens a `Downtime Log` when a machine holds a stop/idle state past a configurable threshold, prompting for a reason code — no manual logging required.

Can it write production directly to Job Cards and Work Orders?

Yes. We map each machine's signals to the relevant Workstation and active Job Card, then use `hooks.py` doc events and Server Scripts to increment completed and rejected quantities as good/scrap counts arrive. Cycle times are recorded for OEE. The exact write behavior (auto-post vs supervisor confirmation) is agreed during scoping so it fits your production-control process.

Request a quote

IIoT Machine Connector

An edge agent plus a Frappe app that streams live machine telemetry into ERPNext over OPC-UA, MQTT, and Modbus, so good/scrap counts, cycle times, and downtime are captured on Job Cards automatically instead of typed in. Build-to-order: ECOSIRE scopes, builds, installs, and supports it for your plant.

  • OPC-UA client edge agent with subscription/monitored-item support for modern CNC controllers, robots, and PLCs exposing an OPC-UA server
  • MQTT subscriber supporting standard topics and Sparkplug B payloads from brokers such as Mosquitto and EMQX, with QoS and TLS options
  • Modbus TCP and RTU polling for legacy PLCs, VFDs, and energy meters, with configurable register maps, data types, byte/word order, and scaling
  • New `Machine`, `Machine Signal Map`, `Machine Telemetry`, and `Downtime Log` DocTypes that model tags, mappings, and readings natively in ERPNext

Request a Quotation

Tell us about your IIoT Machine Connector requirements and we'll send pricing, licensing options and a tailored proposal — usually within one business day.

No payment now. This sends a quote request to our team — we'll follow up by email with pricing and next steps.