Ürün ayrıntıları İngilizce olarak görüntülenir. Çeviriler yakında gelecek.
Kısa bilgiler
- Fiyat
- $799.00 USD
- ERPNext versiyonları
- —
- Kurulum süresi
- 30 dk.
- Lisans
- Bir kerelik kalıcı
- Diller
- 11 language
Tek Seferlik Satın Alma
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.
$799.00USD
Şimdi ödeme yok. Bu, ekibimize bir teklif talebi gönderir — fiyat ve sonraki adımlarla e-posta ile dönüş yapacağız.
Temel Özellikler
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
Bu Ürün Hakkında
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.
Neden IIoT Machine Connector (OPC-UA / MQTT / Modbus)
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
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 2–4 weeks from confirmed scope, depending on the number of machines and protocol mix.
Ne elde edeceksin
- 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
Bu kimin için
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.
Kuruluma genel bakış
ECOSIRE'dan indirin
Lisansı ecosire.com adresinden satın alın ve hesap kontrol panelinizden IIoT Machine Connector (OPC-UA / MQTT / Modbus) uygulamasının ZIP dosyasını indirin.
Uygulamayı bankınıza ekleyin
ZIP dosyasını tezgahınızın uygulamalar klasörüne çıkarın veya çıkarılan uygulamanın yolunu içeren "bench get-app" komutunu çalıştırın.
Sitenize yükleyin
IIoT Machine Connector (OPC-UA / MQTT / Modbus) yüklemek ve şemasını uygulamak için `bench --site SITE_NAME install-app APP_NAME` komutunu ve ardından `bench move'u çalıştırın.
Lisansınızı etkinleştirin
Sitenizdeki ECOSIRE Lisans ayarlarını açın ve lisans anahtarınızı etkinleştirin. Ücretsiz ecosire_connect ve ecosire_license_client uygulamalarını gerektirir.
IIoT Machine Connector (OPC-UA / MQTT / Modbus) Nasıl Karşılaştırılır
| Kriter | ECOSIRE | Özel Yapı | Rakip | Odoo Yerlisi |
|---|---|---|---|---|
| Machine data into ERPNext | Edge agent streams OPC-UA/MQTT/Modbus straight into ERPNext DocTypes | Depends entirely on what your developer builds and maintains | Often a generic MQTT listener with limited protocol coverage | |
| Counts & cycle time | Automatic good/scrap counts and per-part cycle time on Job Cards | Possible but you scope and build every rule yourself | Basic count import; cycle time usually not modeled | |
| Downtime capture | Auto-detected from machine state with reason-coded Downtime Log | Buildable, but state-machine logic is non-trivial to get right | Rarely included; manual logging if at all | |
| OEE | Availability x Performance x Quality from real timestamped data | Only as accurate as the data pipeline you build | Sometimes a dashboard, but fed by partial data | |
| Frappe-native architecture | Proper Frappe app: DocTypes, hooks.py, Server/Client Scripts, scheduler | Varies — may bypass conventions and complicate upgrades | Usually a Frappe app, quality and fit vary | |
| Fit to your machines | Scoped to your exact tags, registers, and Workstation mapping | Fully custom but you carry all discovery and rework risk | Configure to a fixed template; edge cases need workarounds | |
| Reliability under network loss | Edge store-and-forward buffering with idempotent backfill | Must be designed and tested in — often skipped | Frequently drops data on disconnect | |
| Source, support & upgrades | Full source, git handover, post-go-live support, v15/v16 target | You own it and its entire maintenance burden | Vendor-controlled; source and roadmap may be closed |
IIoT Machine Connector (OPC-UA / MQTT / Modbus) hakkında Sıkça Sorulan Sorular
+How long does delivery take?
This is a build-to-order product, not an instant download. Typical delivery is 2–4 weeks 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.
İlgili Modüller
Teklif isteyin
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.
- 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