- Home
- Apps
- Specialized Solutions
- Machine/PLC IoT Gateway (MQTT/OPC-UA)
Illustrative previewBridge machines & PLCs to Odoo via MQTT/OPC-UA for live counters, status, and auto production recording.
Built, installed & supported by ECOSIRE.
What is Machine/PLC IoT Gateway (MQTT/OPC-UA)?
Bridge machines & PLCs to Odoo via MQTT/OPC-UA for live counters, status, and auto production recording. Built, installed & supported by ECOSIRE. Built to order by ECOSIRE for Odoo 17, 18, 19 — indicative price from $999.00 USD; request a quote for a scoped proposal.
Key Features
Built to order, done for you
No DIY setup — a working app, built, installed and supported by ECOSIRE.
- 1
You order
Start with a one-time build price. We scope it with you at kickoff.
- 2
We build & install
ECOSIRE builds, configures and installs it on your Odoo.
- 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
- Odoo Compatibility
- Odoo 17, Odoo 18, Odoo 19
- Editions
- Enterprise & Community
- License
- Licence confirmation required
- Python Requirement
- Python 3.10+
- Database
- PostgreSQL 12+
About this Product
Your PLCs already count every cycle, flag every fault, and know when a line is running, idling, or down — but that signal never reaches Odoo. Operators still hand-key produced quantities into Manufacturing at end of shift, work-order counters lag reality by hours, and OEE analysis runs on numbers nobody fully trusts. The Machine/PLC IoT Gateway closes that gap by making your shop-floor OT layer talk directly to Odoo Manufacturing (MRP).
This is a BUILD-TO-ORDER Odoo module. It is not an existing apps.odoo.com download — ECOSIRE designs, builds, installs, and supports it for your exact machines, tag maps, and Odoo environment, with a typical one working week lead time. We ship it as a proper custom addon (a versioned __manifest__.py addon, not scripts glued into your database) so it upgrades cleanly and audits well.
At the core, the module runs a background gateway service that maintains persistent MQTT subscriptions and OPC-UA client sessions to your brokers and controllers. Incoming machine tags — cycle counters, run/idle/down states, part-present signals, alarm words — are decoded and mapped onto Odoo models. We model the connectors, tag mappings, and machine bindings as first-class models.Model records with proper fields, so everything is configurable from the Odoo UI instead of buried in a config file. Cumulative counters are converted to produced deltas using @api.depends computed fields, then posted against the right mrp.workorder / mrp.production and mrp.workcenter so produced quantity accrues automatically as parts come off the machine.
Live status is surfaced through OWL/JS dashboard views and standard Odoo list/form/kanban views, backed by automated actions and ir.cron jobs that watch for state transitions and stale feeds. Because industrial links are never perfectly reliable, the gateway buffers readings locally and replays them on reconnect, so a dropped Wi-Fi link or a rebooted broker doesn't silently lose an hour of counts. Every write is gated by ir.model.access.csv access rights and record rules, and machine data can be exposed to MES/SCADA layers over Odoo's XML-RPC / JSON-RPC API when you need two-way integration.
The result: work-order quantities that match the machine, an honest run/idle/down timeline for every work center, and OEE inputs you can defend. The build runs on Odoo 17, 18, and 19, and works on both Community and Enterprise (with the deeper MRP work-order, OEE, and PLM touchpoints lighting up on Enterprise). ECOSIRE handles the connector wiring, the tag map, the security model, the reports, and post-launch support — you get a maintainable module, not a fragile side-script.
What you get
- The complete custom Odoo addon source (versioned __manifest__.py, Python models, XML/OWL views, security CSV + record rules, QWeb reports) delivered to your Git repository — you own the code
- A commissioned tag map: the actual MQTT topics / OPC-UA node bindings for your machines mapped to work centers, products, and counters, validated against live signals during commissioning
- Gateway service deployment: the connector/buffering service installed and running against your brokers and PLCs on your Odoo 17, 18, or 19 environment (Community or Enterprise)
- Security & access configuration: ir.model.access.csv rights and record rules set up so the right roles see and control each machine feed, reviewed with your team
- Documentation set: an admin/config guide (how to add a connector, remap a tag, read the dashboard), a commissioning report, and the security model reference
- Live training session(s) for your MRP/maintenance/IT team on operating the gateway, interpreting run/idle/down status, and troubleshooting a dropped link
- A defined post-launch support & warranty window with a named contact for fixes, tag-map tweaks, and questions after go-live
- Odoo version-compatibility guarantee for your target line (17/18/19) plus an upgrade path note so the addon moves cleanly to future Odoo versions
Who this is for
Manufacturing / Plant Operations Manager
Wants work-order quantities and OEE that reflect what machines actually did, not shift-end guesses. Uses the live run/idle/down feed and downtime reasons to chase real losses instead of arguing over numbers.
Automation / Controls (OT) Engineer
Owns the PLCs, MQTT broker, and OPC-UA server. Needs a clean, secure bridge from the OT layer into Odoo without exposing controllers or writing brittle glue scripts, and cares that reconnection and buffering are handled properly.
ERP / IT Systems Lead
Responsible for keeping Odoo maintainable and upgradeable. Wants machine integration delivered as a proper versioned addon with real security (access CSV + record rules) and an API surface, not undocumented database hacks that break on the next upgrade.
How Machine/PLC IoT Gateway (MQTT/OPC-UA) Compares
| Criterion | ECOSIRE | Custom Build | Competitor | Odoo Native |
|---|---|---|---|---|
| Time to a working machine-to-Odoo bridge | one working week scoped build, commissioned against your live signals | Months of in-house R&D on connectors, buffering, and Odoo internals | Fast to install but rarely matches your exact tags/machines out of the box | Not available — Odoo core has no MQTT/OPC-UA machine ingestion |
| MQTT & OPC-UA connectors | Both included, mixable per machine, TLS/Sign-&-Encrypt secured | You build and maintain both protocol stacks yourself | Often one protocol only, or a paid add-on per protocol | None — no industrial protocol clients in standard Odoo |
| Auto produced-quantity from cycle counts | Delta-based recording to mrp.workorder/mrp.production via @api.depends, with rollover/debounce handling | Achievable but easy to get wrong (double-counts, rollover, resets) | Varies; may need your own mapping logic and often not delta-safe | Manual entry only — operators key produced qty by hand |
| Buffering & reconnection on unreliable links | Store-and-forward queue + auto-reconnect + ir.cron stale-feed watchdog | Must be designed, built, and tested by your team | Inconsistent; some drop data during outages | Not applicable |
| Fit to your machines, tags & work centers | Tag map commissioned to your exact controllers and work centers | Fully custom but on your time and risk | Generic mapping — you adapt your setup to the app's assumptions | No machine concept to map to |
| Security model (access rights + record rules) | ir.model.access.csv + record rules scoping every feed per role | Depends entirely on your implementation discipline | Whatever the vendor shipped; may be coarse-grained | Only generic Odoo access controls, no machine-feed scoping |
| Odoo version & edition coverage | Built for 17/18/19, Community & Enterprise, upgrade path guaranteed | You own every future-version migration | Often lags new Odoo releases; edition gaps common | Ships with core but offers no gateway to begin with |
| Source ownership & support | Full addon source in your repo + named post-launch support window | You own it — and you're the only one who can support it | Closed source; support tied to a per-user/subscription license | Community support only; no vendor accountability for this use case |
Frequently Asked Questions about Machine/PLC IoT Gateway
How long until the module is delivered and live?
This is a build-to-order module, so it is not an instant download. Typical lead time is one working week from a confirmed brief and access to your machine signals. The schedule depends on how many machines/tags are in scope, whether you use MQTT, OPC-UA, or both, and how quickly we can reach live signals for commissioning. After a short discovery call we give you a firm timeline and milestones (connector build, tag mapping, commissioning, training, go-live).
What support and updates do I get after launch?
Every build includes a defined post-launch support and warranty window with a named contact for bug fixes, tag-map adjustments, and questions. Because you receive the full addon source in your own repository, you are never locked in. We also provide an Odoo version-compatibility guarantee for your target version and can quote an ongoing support/maintenance plan that covers upgrades to future Odoo releases (17 → 18 → 19 and beyond) and additional machines or connectors as your shop floor grows.
Which Odoo versions and editions does this support?
The module is built for Odoo 17, 18, and 19, and runs on both Community and Enterprise. Core capabilities — MQTT/OPC-UA ingestion, tag mapping, auto counter recording, buffering, and the status dashboard — work on Community. Deeper Manufacturing touchpoints such as native work-order OEE, work-center productivity/loss reasons, and PLM links are richer on Enterprise, and we tailor the integration to whichever edition you run.
Do you support both MQTT and OPC-UA, and what if my PLCs speak something else?
Yes — the gateway ships with both an MQTT inbound connector and an OPC-UA client connector, and you can mix them across machines. If a controller only speaks Modbus TCP, Siemens S7, EtherNet/IP, or a vendor REST API, we typically bridge it into MQTT or OPC-UA at commissioning (many brokers/edge gateways do this) or extend the connector layer as part of the scoped build. Tell us your controllers and protocols in the brief and we will confirm the approach before you commit.
What happens to my production counts if the network or broker drops?
The gateway uses store-and-forward buffering: when Odoo, the broker, or the link is unreachable, readings are queued locally and replayed in order once the connection returns, so you don't silently lose an hour of counts. Connectors reconnect automatically with backoff, and an ir.cron watchdog flags any feed that has gone stale so you know a machine is offline rather than assuming it produced nothing. Counter debounce and rollover handling ensure replayed data doesn't double-count.
Is this secure, and can it write back to my machines?
Security is built in on both ends. Toward Odoo, every machine feed and configuration record is protected by ir.model.access.csv access rights and record rules, so OT data is scoped to the right roles. Toward the plant, MQTT connections use TLS with credential or client-certificate auth and OPC-UA uses Sign & Encrypt security policies. By default the gateway is read-only (inbound) for safety. Where you explicitly want two-way control, it can push setpoints or acknowledgements back via OPC-UA, and machine data can be exposed to MES/SCADA/BI over Odoo's XML-RPC / JSON-RPC API.
How does it avoid double-counting or drifting from what the machine actually made?
Machines usually report cumulative cycle counters, so the module stores the last known value per tag and computes produced deltas with @api.depends computed fields rather than trusting raw absolute numbers. It debounces duplicate pulses, handles counter rollover (16/32-bit) and machine/PLC resets, and only posts positive deltas to the linked mrp.workorder / mrp.production. During commissioning we reconcile the module's counts against the machine HMI over real shifts so you go live with numbers you can defend.
Related Modules

Laboratory Management for Odoo
A made-to-order Odoo application that models the full lab workflow — sample intake, test assignment, result capture, validation, and reporting — inside your existing ERP. ECOSIRE scopes it to your lab, then builds, installs, and supports it.

Laundry & Dry-Cleaning Management
A build-to-order Odoo module that runs a laundry or dry-cleaner end to end — itemized order intake, barcode garment tracking, process-stage workflow, and pickup/delivery scheduling. ECOSIRE scopes, builds, installs and supports it for you on Odoo 17, 18 or 19.

Maintenance Asset Meter & Metrology
Meter-reading and metrology/calibration management to trigger usage-based maintenance and keep gauges in-tolerance in Odoo.

Manufacturing Backflush & Auto-Consumption
A build-to-order Odoo module that automatically backflushes component consumption when a manufacturing order or work order is completed, so high-volume production lines stop hand-recording every material move. ECOSIRE scopes, builds, installs, and supports it for your Odoo 17/18/19 environment.
Machine/PLC IoT Gateway
Bridge machines & PLCs to Odoo via MQTT/OPC-UA for live counters, status, and auto production recording. Built, installed & supported by ECOSIRE.
- MQTT inbound connector: persistent subscriptions to one or more brokers (TLS, username/password or client-cert auth), configurable topic filters, QoS, and per-topic JSON/binary payload decoders
- OPC-UA client connector: browses your PLC/SCADA address space, subscribes to nodes with monitored items and configurable sampling/publishing intervals, supports Sign & Encrypt security policies
- Tag-to-model mapping engine: bind any machine tag (cycle counter, part-present, alarm word, temperature) to a work center, product, counter, or status field through Odoo UI records — no code changes to remap a line
- Auto production recording: cumulative machine cycle counts are converted to produced deltas via @api.depends computed fields and posted to mrp.workorder / mrp.production, so produced quantity accrues in real time