DO NOT USE This is pre-alpha. It will not work!
A C library designed to make industrial network protocol implementations simple, clear, and bulletproof.
The Protocol Toolkit is built around three core principles:
- Global managers for common resources (timers, sockets, memory)
- Minimal APIs with just the functions you need
- Single-protocol focus - optimized for applications implementing one protocol
- No complex abstractions - direct, straightforward interfaces
- Simplified resource handling with allocators that support destructors
- Separation of long-term vs. ephemeral data for optimal memory management
- Type-safe serialization using Protocol Description Language (PDL)
- Structured protocol definitions that are easy to read and maintain
- Consistent error handling throughout the library
- Comprehensive documentation with real-world examples
- Cross-platform support for common tasks with unified APIs
- Built-in serialization/deserialization that handles endianness and validation
- Memory safety with built-in buffer management and automatic cleanup
- Robust error handling with clear error codes and recovery paths
- Timeout management for all network operations
- Extensive testing to ensure reliability in industrial environments
- Thread-safe primitives for low-level concurrent operations
- Platform abstraction that works consistently across operating systems
Industrial network protocols are complex, but implementing them shouldn't be. Traditional approaches often result in:
- Fragile, hard-to-maintain code
- Memory leaks and buffer overflows
- Inconsistent error handling
- Poor performance under load
Protocol Toolkit solves these problems by providing:
- Pre-built, tested components for common protocol needs
- Type-safe message serialization that eliminates parsing errors
- Unified event handling for timers, sockets, and protocol events
- Clear patterns that make protocol code predictable and maintainable
Currently supported protocols:
- Modbus TCP/RTU - Complete implementation with client and server
- EtherNet/IP - Device discovery and basic CIP messaging
- More protocols planned based on community needs
#include "ptk_timer.h"
#include "ptk_modbus.h"
// Initialize the toolkit
ptk_timer_init();
ptk_modbus_init();
// Create a simple Modbus client
ptk_modbus_client_t client = ptk_modbus_client_create("192.168.1.100", 502);
// Read holding registers with automatic timeout
uint16_t values[10];
int result = ptk_modbus_read_holding_registers(client, 0, 10, values);
if (result == 0) {
printf("Successfully read %d registers\n", 10);
} else {
printf("Read failed: %s\n", ptk_modbus_error_string(result));
}
// Cleanup is automatic
ptk_modbus_client_destroy(client);- Global timer system - Simple, efficient timers for timeouts and periodic tasks
- Smart memory management - Allocators with destructors for automatic cleanup
- Event framework - Unified handling of socket and timer events
- Error handling - Consistent error codes and recovery mechanisms
- Cross-platform threading - Mutexes, condition variables, and thread primitives
- Modbus - Complete client/server with all function codes
- EtherNet/IP - Device discovery, explicit messaging, and I/O
- Type-safe parsing - PDL-generated serialization code
- Protocol Description Language - Generate serialization code from simple definitions
- Code generator - Automatic creation of type-safe protocol handlers
- Testing utilities - Built-in support for protocol testing and validation
- Logging system - Unified logging with configurable levels and outputs
- Buffer management - Efficient, safe buffer operations with bounds checking
- Serialization/deserialization - Automatic handling of endianness and data types
- Threading primitives - Mutexes, condition variables, and thread-safe operations
- Platform abstraction - Windows, Linux, macOS, and embedded systems support
The toolkit is designed with clear separation of concerns:
Application Layer
├── Protocol APIs (Modbus, EtherNet/IP, etc.)
└── Protocol-Specific Logic
Protocol Toolkit Core
├── Timer System (ptk_timer.h)
├── Memory Management (ptk_alloc.h)
├── Buffer Management (ptk_buf.h)
├── Event Framework (ptk_event.h)
├── Logging System (ptk_log.h)
├── Threading Support (ptk_thread.h)
├── Serialization (ptk_serialize.h)
└── Error Handling (ptk_error.h)
System Layer
├── Socket Operations
├── Threading Primitives
└── Platform Abstraction
// Create a timeout for a protocol request
ptk_timer_t timeout = ptk_timer_create_oneshot(5000, handle_timeout, &request);
// Create a keepalive timer
ptk_timer_t keepalive = ptk_timer_create_repeating(30000, send_keepalive, connection);
// Cancel when no longer needed
ptk_timer_cancel(timeout);// Define protocol structure in PDL
struct ModbusRequest {
uint16_t transaction_id;
uint16_t protocol_id;
uint16_t length;
uint8_t unit_id;
uint8_t function_code;
uint16_t start_address;
uint16_t quantity;
};
// Generated serialization code handles endianness and validation
ptk_buf_t buffer = ptk_buf_create(256);
modbus_request_serialize(&request, buffer);// Create allocator with automatic cleanup
ptk_allocator_t alloc = ptk_allocator_create_with_destructor(cleanup_connection);
// Allocate long-term data (persists across requests)
connection_t *conn = ptk_alloc_long_term(alloc, sizeof(connection_t));
// Allocate ephemeral data (freed automatically after request)
request_buffer_t *req = ptk_alloc_ephemeral(alloc, sizeof(request_buffer_t));
// Cleanup happens automatically when allocator is destroyed
ptk_allocator_destroy(alloc); // Calls destructors automatically// Create mutex for thread-safe operations
ptk_mutex_t mutex = ptk_mutex_create();
// Use condition variables for coordination
ptk_cond_t cond = ptk_cond_create();
// Thread-safe logging
ptk_log_info("Connection established to %s:%d", host, port);
ptk_log_error("Failed to read register %d: %s", reg, ptk_error_string(err));
// Cleanup is automatic
ptk_mutex_destroy(mutex);
ptk_cond_destroy(cond);// Create buffer with bounds checking
ptk_buf_t buf = ptk_buf_create(1024);
// Safe operations with automatic bounds checking
ptk_buf_write_uint16_be(buf, transaction_id); // Big-endian
ptk_buf_write_uint16_le(buf, register_count); // Little-endian
ptk_buf_write_bytes(buf, data, data_len);
// Automatic cleanup
ptk_buf_destroy(buf);# Clone the repository
git clone https://github.com/your-org/protocol_toolkit.git
cd protocol_toolkit
# Build with CMake
mkdir build
cd build
cmake ..
make
# Run tests
make test
# Install
make installCurrent Status: Alpha Development
The Protocol Toolkit is under active development. Current focus areas:
- ✅ Core timer and memory management APIs
- ✅ Modbus TCP/RTU implementation
- ✅ EtherNet/IP device discovery
- 🔄 Smart allocators with destructors
- 🔄 Cross-platform threading primitives
- 🔄 Type-safe serialization system
- 🔄 Unified logging system
- 🔄 Enhanced buffer management
- 🔄 Comprehensive error handling
- 📋 Complete EtherNet/IP implementation
- 📋 Additional protocol support
We welcome contributions! Please see CONTRIBUTING.md for guidelines.
Key areas where we need help:
- Protocol implementations
- Cross-platform testing and validation
- Documentation and examples
- Performance optimization
- Platform-specific optimizations
Protocol Toolkit is dual-licensed:
- Mozilla Public License 2.0 (MPL-2.0) - See LICENSE-1.MPL
- GNU Lesser General Public License 2.1 (LGPL-2.1) - See LICENSE-2.LGPL
Choose the license that best fits your project's needs.
- libplctag - Popular PLC communication library
- Your project here - let us know if you're using Protocol Toolkit!
Making industrial network protocols simple, clear, and bulletproof.