libplctag.NET is a .NET library providing two NuGet packages for industrial PLC communication via EtherNet/IP and Modbus TCP. The primary package (libplctag) offers a high-level, asynchronous, strongly-typed API built on top of the native libplctag C library, handling resource cleanup, exceptions, and event-driven operations. The second package (libplctag.NativeImport) exposes a low-level P/Invoke wrapper that manages platform-specific native binary loading and provides raw tag access. The architecture is a classic wrapper layer: the high-level Tag class encapsulates native handle lifecycle, attribute string generation, synchronous and async operations (using TaskCompletionSource with concurrent stacks to handle native callbacks), and exposes typed data accessors. The library targets a wide range of .NET frameworks (netcoreapp3.0 through net8.0, plus .NET Framework 4.7+), reflecting its industrial compatibility requirements. Some parts of the codebase (the generic Tag<M,T> and associated PlcMappers) are marked obsolete due to a planned API redesign (referenced as issue #406), indicating ongoing evolution.
This repository is a Java library for industrial communication protocols, providing implementations for Siemens S7 PLC, Modbus, Mitsubishi Melsec, RTSP/RTP/RTCP media streaming, and MP4 file format handling. The library features a modular architecture with clear separation by protocol, annotation-based serialization frameworks, and low-level utilities for binary data handling. It serves as an SDK for developers to integrate industrial device communication and media streaming capabilities into their applications. The code demonstrates consistent use of design patterns (builder, template method, annotation-based processing) and includes comprehensive test suites showing usage patterns.
FluentModbus is a .NET library that implements the Modbus protocol (TCP and RTU) for client and server communication. The library provides a full set of function codes (class 0, 1, and partial class 2) including read/write holding registers, coils, discrete inputs, input registers, and combined read-write operations. Both synchronous and asynchronous APIs are available. The server supports multiple unit identifiers, frame validation via a user-defined callback, events for register/coil changes, and configurable endianness. The client exposes high-level generic methods as well as low-level byte-oriented access. The codebase is well-structured with abstract base classes (MobusClient, ModbusServer), separate request handlers for TCP and RTU, and clean separation of concerns. Dependencies are minimal (logging abstractions, I/O, memory). The library includes comprehensive unit tests and samples.
FUXA is a full-stack web-based SCADA/HMI builder and runtime for industrial automation and IoT. It provides a visual editor (Angular + SVG) to create real-time dashboards, connect to field devices via 13+ protocols (Modbus, OPC UA, BACnet, Siemens S7, MQTT, etc.), and manage alarms, data acquisition (DAQ), scripting, scheduling, and user permissions. The backend (Node.js/Express) communicates with the frontend via Socket.IO for real-time device value updates. The system supports multiple time-series databases (SQLite, InfluxDB, QuestDB, TDengine) and can be deployed as a web server, Docker container, or Electron desktop app. It also integrates with Node-RED for low-code automation flows. The architecture is modular with a device driver factory pattern, JWT-based authentication, and a plugin system for extensibility. While the codebase is large and contains some monolithic components, it demonstrates solid engineering practices and has a rich set of reusable UI components and utility patterns.
This repository provides a Home Assistant custom component (solax_modbus) that integrates solar inverters from multiple brands (SolaX, Growatt, Sofar, Solis, SRNE, etc.) via Modbus TCP/serial/RTU. It exposes real-time sensor data, battery status, energy totals, and control entities (numbers, selects, switches, buttons, time) into Home Assistant. The component features a plugin architecture where each inverter brand has its own module defining entity descriptions, register maps, and inverter detection logic. It includes an energy dashboard virtual device that aggregates grid, solar, battery, and home consumption for the native Home Assistant Energy Dashboard. Advanced capabilities include remote power control (VPP modes), autorepeat loops, parallel master-slave support, and automatic bad-register quarantine. The codebase is well-tested with unit tests and CI/CD, but suffers from some duplication across plugins and hardcoded register maps.
This repository is a Home Assistant custom integration for communicating with Solarman Stick Loggers to monitor and control solar inverters. It uses Modbus TCP/RTU to read/write inverter registers, exposing the data as Home Assistant entities (sensors, switches, etc.). The integration includes a device discovery mechanism via UDP broadcast, a configuration flow for setup, and a coordinator for periodic data updates. It also provides services for arbitrary Modbus register operations. The inverter definitions are stored in YAML files that specify the register mappings and sensor configurations for various inverter models.
This repository is a comprehensive IoT device driver library for .NET nanoFramework. It provides bindings for hundreds of sensors, actuators, displays, and communication modules (e.g., BME280, SSD1306, NFC, Modbus, cellular modems, GPS). The architecture is a collection of independent driver projects, each with its own samples, tests, and documentation. Shared utility libraries (e.g., System.Device.Model, NumberHelper, SpanByte compatibility shims) support cross-cutting concerns. The codebase is actively maintained with frequent commits, but the sheer number of drivers (300+) leads to varying quality, some code duplication (e.g., SpanByte classes in multiple locations), and partially auto-generated code. Networking components like DHCP server, DNS server, and Home Assistant MQTT integration extend the library beyond raw sensor access. The primary use case is building embedded IoT applications on microcontrollers (ESP32, STM32) running nanoFramework.
VOLTTRON is a Python-based distributed control and integration platform for building and industrial control systems. It runs cooperating 'agents' (services) that communicate over a ZeroMQ/RabbitMQ message bus called VIP, supporting pub/sub, RPC, and peer-to-peer routing. The platform provides agent lifecycle management (volttron-ctl), a web UI, authentication, historians, and protocol drivers for Modbus, BACnet, and similar field protocols. In production it acts as a central hub for collecting sensor/controller data, executing actuation commands, and hosting automation logic.
modbus4j is a Java library implementing the Modbus protocol (ASCII, RTU, TCP, UDP) for industrial automation. It provides both master (client) and slave (server) functionality, supporting standard function codes (read/write coils, discrete inputs, holding/input registers, mask write) and a wide range of data types including BCD, floats, and custom swapped variants. The architecture is modular with separate transport layers, a generic messaging framework (MessageControl, WaitingRoom, Transport), and locator-based high-level access. The library includes a process image simulation for slave devices and batch read capabilities. It was originally developed for Mango Automation and has a parallel Java 1.4 backport (src_cdc) that indicates aging. The codebase shows good separation of concerns and reusable patterns but suffers from technical drift (RXTX dependency, manual byte manipulation, outdated build tools) and lack of modern testing infrastructure.