industrial
Provides modular protocol stacks for industrial communication like Modbus RTU/TCP and CANopen in Zephyr.
Install
mkdir -p .claude/skills/industrial && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/10994" && unzip -o skill.zip -d .claude/skills/industrial && rm skill.zipInstalls to .claude/skills/industrial
Activation
This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.
Industrial communication protocols for Zephyr RTOS. Covers Modbus RTU (serial), Modbus TCP (Ethernet/Wi-Fi), and CANopen basics. Trigger when building factory automation controllers, industrial sensors, or medical equipment interfaces.Key capabilities
- →Implement Modbus RTU serial communication
- →Bridge industrial data via Modbus TCP
- →Integrate CANopen automation networks
- →Validate register maps with linting scripts
How it works
It use Zephyr's modular protocol stacks to handle serial and network-based industrial communication.
Inputs & outputs
When to use industrial
- →Implementing Modbus RTU for sensors
- →Bridging industrial data via Modbus TCP
- →Integrating CANopen automation networks
About this skill
Zephyr Industrial Protocols
Build robust, industry-standard communication systems using Zephyr's modular industrial protocol stacks.
Core Workflows
1. Modbus RTU (Serial)
Implement serial-based industrial communication for meters, PLCs, and sensors.
- Reference: modbus_rtu.md
- Key Tools:
CONFIG_MODBUS, RS-485 DE/RE handling, Register Mapping.
2. Modbus TCP
Bridge industrial data over standard Ethernet or Wi-Fi networks.
- Reference: modbus_tcp.md
- Key Tools: Port 502, TCP/IP networking, Client/Server patterns.
3. CANopen Basics
Integrate with complex automation networks using the CANopenNode stack.
- Reference: canopen_basics.md
- Key Tools: Object Dictionary (OD), PDO/SDO, Network Management (NMT).
Quick Start (Modbus RTU Server)
# prj.conf
CONFIG_MODBUS=y
CONFIG_MODBUS_SERIAL=y
// Initialize a server on a serial device
const struct device *dev = DEVICE_DT_GET(DT_CHOSEN(zephyr_modbus_serial));
struct modbus_iface_param param = {
.mode = MODBUS_MODE_RTU,
.server = { .node_addr = 1, .cb = &my_callbacks },
.serial = { .baud = 115200, .parity = UART_CFG_PARITY_NONE },
};
modbus_init_server(dev, param);
Professional Patterns (Reliability & Safety)
- RS-485 Hardware Handling: Always use the devicetree
uart-rs485property to handle transceiver direction signals automatically at the driver level. - Isolated Communication: Use galvanically isolated transceivers for both serial and CAN lines in factory environments to prevent damage from ground loops.
- Watchdog Integration: In industrial control, always pair your communication loops with the watchdog_reliability pattern (see specialized skill) to ensure the system enters a fail-safe state on protocol lockup.
Automation Tools
- modbus_register_lint.py: Validate register map CSV files for duplicate addresses and overlaps.
Examples & Templates
- modbus_register_map_template.csv: Starter register allocation sheet for Modbus projects.
Validation Checklist
- Modbus RTU request/response exchange succeeds against a known test slave/master.
- Modbus TCP endpoint responds on port 502 with correct register mappings.
- CANopen node transitions through expected NMT states during startup.
- Communication faults trigger safe retry or watchdog-protected recovery behavior.
Resources
- References:
modbus_rtu.md: Serial Modbus master/slave setup.modbus_tcp.md: Ethernet Modbus client/server patterns.canopen_basics.md: Object Dictionary and PDO mapping.
- Scripts:
modbus_register_lint.py: Register-map consistency checker.
- Assets:
modbus_register_map_template.csv: Register planning template.
When not to use it
- →Non-industrial communication tasks
Prerequisites
Limitations
- →Requires specific hardware support for RS-485
- →Limited to supported industrial protocols
How it compares
Unlike generic serial libraries, this provides specific industrial protocol implementations and hardware-level transceiver handling.
Compared to similar skills
industrial side by side with the closest alternatives in the catalog.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| industrial (this skill) | 0 | 2mo | Review | Intermediate |
| telegram-bot-builder | 106 | 6mo | Review | Intermediate |
| workflow-orchestration-patterns | 10 | 2mo | No flags | Advanced |
| bullmq-specialist | 25 | 6mo | No flags | Intermediate |
Try saying
Example prompts that trigger this skill in your AI assistant.
More by beriberikix
View all by beriberikix →You might also like
telegram-bot-builder
davila7
Expert in building Telegram bots that solve real problems - from simple automation to complex AI-powered bots. Covers bot architecture, the Telegram Bot API, user experience, monetization strategies, and scaling bots to thousands of users. Use when: telegram bot, bot api, telegram automation, chat bot telegram, tg bot.
workflow-orchestration-patterns
wshobson
Design durable workflows with Temporal for distributed systems. Covers workflow vs activity separation, saga patterns, state management, and determinism constraints. Use when building long-running processes, distributed transactions, or microservice orchestration.
bullmq-specialist
davila7
BullMQ expert for Redis-backed job queues, background processing, and reliable async execution in Node.js/TypeScript applications. Use when: bullmq, bull queue, redis queue, background job, job queue.
unity-mcp-orchestrator
CoplayDev
Orchestrate Unity Editor via MCP (Model Context Protocol) tools and resources. Use when working with Unity projects through MCP for Unity - creating/modifying GameObjects, editing scripts, managing scenes, running tests, or any Unity Editor automation. Provides best practices, tool schemas, and workflow patterns for effective Unity-MCP integration.
async-python-patterns
wshobson
Master Python asyncio, concurrent programming, and async/await patterns for high-performance applications. Use when building async APIs, concurrent systems, or I/O-bound applications requiring non-blocking operations.
modal
davila7
Run Python code in the cloud with serverless containers, GPUs, and autoscaling. Use when deploying ML models, running batch processing jobs, scheduling compute-intensive tasks, or serving APIs that require GPU acceleration or dynamic scaling.