Simple Field Bus Protocol (SFBP)

A lightweight, low-power communication protocol for distributed automation.

Overview

The Simple Field Bus Protocol (SFBP) is a custom-designed protocol developed to support peer-to-peer, event-driven communication across RS-485 or sub-GHz radio networks. Designed with simplicity, robustness, and determinism in mind, SFBP enables reliable messaging between autonomous nodes in distributed systems — with minimal bandwidth and processing overhead.

Characteristics

Supports up to 126 devices per network segment
Broadcast and direct addressing supported
Both synchronous (connected) and asynchronous (datagram) messaging
Efficient for small payloads; supports fragmented transmission for larger data
Multi-master capable: peer-to-peer communication without central coordinator
Hardware-agnostic: works over RS-485 or sub-GHz radio
Ultra-compact frame size: only 11 bytes per packet

Applications

Distributed control, typically over RS-485 and/or 833 MHz radio
Local automation with no master node required
Event-driven messaging in industrial and building automation

Protocol Documentation and Software

Download the official papers and technical notes:

Download software:

SFBP.dll Windows dynamic library (32-bit) SFBP.zip (includes documentation and examples).

SFBP vs Modbus

While Modbus remains widely used in legacy industrial systems, SFBP offers a more flexible, modern design tailored for distributed, event-driven automation. Here’s a comparison:

Feature	SFBP	Modbus
OSI Model Coverage	Spans from Data Link up to part of the Application layer; flexible for custom extensions	Mainly covers Application and Presentation layers; assumes master-slave physical stack
Topology	Multi-master, peer-to-peer (distributed)	Master-slave (centralized)
Communication Style	Supports connected (ACK-based) and datagram (unconnected) messaging	Request/response only (master must always poll)
Broadcast Support	Yes (native)	Limited (depends on function codes and implementation)
Message Size Optimization	Very compact: 11-byte packets for minimal overhead	Variable, often larger depending on function code
Physical Layer	Independent (RS-485, RS-232, radio, etc.)	Usually tied to RS-232/RS-485; Ethernet in Modbus TCP variant
Extensibility	Custom application logic, sessions, and fragmentation left open to the developer	Rigid structure with fixed function codes
Ideal Use Case	Distributed, event-driven control systems	Legacy polling-based industrial control

Conclusion

SFBP was designed from the ground up to support modern, distributed automation environments where devices need to act independently, respond quickly to events, and scale without centralized bottlenecks. While Modbus may remain useful for legacy integrations, SFBP offers a leaner, more adaptable alternative for peer-to-peer systems, embedded intelligence, and next-generation automation applications.

SFBP DLL Implementation Notes

Into the ZIP file are available examples and documentation for using the SFBP dynamic library in C/C++, Visual Basic and C#.
Here are provided information about the working concepts.

How SFBP.DLL Works

When calling OpenCOM a hWnd argument is required. This is because the DLL begins to subclass the given Window handle.
In background SFBP.DLL start an apartment thread and then registers for private messages that Windows will send to the application, which in turn are intercepted by the DLL via subclassing.

Once the communication channel needs to be closed, calling CloseCOM automatically destroy the thread and released the allocated resources.
This also keep the DLL from calling back the host application (no more events are generated). Now the application should call SetClientHWND(0) to unsubclass the window.

Therefore before calling OpenCOM you should be sure that the WinForm is actually loaded so the handle is valid. In addition before calling OpenCOM you should also call SetCallbackEvents to register your delegate functions (see InitializeCallbacks below ).

Example with C#:

		public partial class MainForm : Form
		{
			public MainForm()
			{
				InitializeComponent();
				// Force handle creation up front:
				var h = this.Handle;
			}

			protected override void OnLoad(EventArgs e)
			{
				base.OnLoad(e);
				// Register callbacks first
				NSCCOMhelper.InitializeCallbacks();

				// OpenCOM wants an HWND to subclass:
				int result = NSCCOMhelper.OpenCOM((int)this.Handle);
				if (result != 0)
					MessageBox.Show("Failed to open COM: " + result);
			}

			protected override void OnFormClosing(FormClosingEventArgs e)
			{
				// Cleanly close communication and unsubscribe subclass:
				NSCCOMhelper.CloseCOM();
				NSCCOMhelper.SetClientHWND(0);	// Stop thread, release buffers, etc.
				base.OnFormClosing(e);			// Unsubclass the window
			}
		}

More examples are available in the documentation included into the ZIP file.