CanKit.Pro.CANopen 1.2.3

CanKit.Pro.CANopen

Experimental CANopen (CiA 301) node implementation for CanKit.Pro. Provides an in-process ICanOpenNode that combines a local Object Dictionary, an SDO server + client, an NMT slave state machine with a heartbeat producer/consumer, a SYNC producer/consumer, structured EMCY encoding and static TPDO/RPDO mapping — all composed on the CanKit.Pro L2 pipeline (ICanBusService / IProtocolActor / DeadlineScheduler), exactly like CanKit.Pro.IsoTp, CanKit.Pro.J1939Tp and CanKit.Pro.Uds.

Coverage

This is a subset of CiA 301, not a complete implementation of it. What the subset covers is every Must, Should and (formerly deferred) Could requirement from SRS §4.3.2 — the requirements this repository set itself:

Not implemented

CiA 301 features outside SRS §4.3.2 that a conformance tester or a foreign master will expect and not find here:

• Communication-parameter OD objects: 0x1005/0x1006/0x1007 (SYNC COB-ID, cycle period, sync window length), 0x1016/0x1017 (heartbeat consumer/producer time), 0x1200ff (SDO server parameters), 0x1400ff/0x1600ff and 0x1800ff/0x1A00ff communication records. PDO mapping is configured through the API (ConfigureTpdo/ConfigureRpdo) and, for the mapping records only, through dynamic mapping over SDO; a master cannot configure this node purely over the OD.
• Transmission types beyond TpdoTransmission (event-driven, event-timer, every SYNC): the CiA 301 byte values 0 (synchronous-acyclic), 2–240 (every n-th SYNC) and 252/253 (RTR-triggered) are not honored, and there are no RTR-triggered PDOs at all.
• Inhibit time and sync window length — a change-of-state TPDO is not rate-limited, and a synchronous TPDO is not suppressed once the sync window has closed.
• Dummy mapping entries (0x0001–0x0007), used to pad an RPDO to a peer's layout.
• Life guarding on the producer side (§7.2.8.3.3): this node answers guarding RTRs and can act as a guarding master, but does not supervise its own guard time as a producer.
• Reset-Communication semantics: the NMT command is accepted, but communication parameters are not re-initialized from the OD, because they do not live in the OD (see above).

Open items

• CiA 302 boot-up sequence details. Classic SDO segmented transfers carry a server-side idle timeout (CanOpenNodeOptions.SdoServerTimeout, default 5 s) matching the block transfer guard, and block transfer retransmits from the first unconfirmed segment on a partial sub-block ACK (CiA 301 §7.2.4.3.15, bounded by CanOpenNodeOptions.SdoBlockMaxRetransmissions, default 3); the pst>0 fallback from block to segmented transfer is still not implemented (pst=0 is forced).
• PDO mapping is byte-aligned only (bit lengths must be multiples of 8); bit-granular mapping entries are rejected with an SDO abort.

SDO block transfer

SdoDownloadAsync auto-selects the block codec when the payload reaches CanOpenNodeOptions.SdoBlockThresholdBytes (default 128 bytes). SdoUploadAsync keeps the classic expedited/segmented path under SdoTransferMode.Auto (size unknown up front); pass SdoTransferMode.Block to force block upload. Callers can also force Expedited / Segmented / Block on either API. The block size advertised by this node is CanOpenNodeOptions.SdoBlockSize (default 127; peers with a smaller window renegotiate downward). CRC-16/XMODEM is exchanged when both endpoints set the "cc" / "sc" bit (SdoBlockCrcSupported, default true).

Node-guarding

StartNodeGuardingConsumer(nodeId, guardTime, lifeTimeFactor) polls 0x700 + nodeId with an RTR every guardTime and raises NodeGuardingTimeout after guardTime × lifeTimeFactor without a valid reply. The producer side answers the RTR with (toggle << 7) | state and flips the toggle bit on every reply; heartbeat and node-guarding are mutually exclusive on the same producer (RespondToNodeGuardingRtr gates the reply, and an active heartbeat producer takes precedence per CiA 301 §7.2.8.3).

Quick start

using CanKit.Core;
using CanKit.Pro.CANopen;

using var bus = CanBus.Open("virtual://demo/0",
    cfg => cfg.SetProtocolMode(CanProtocolMode.Can20).Baud(500_000));

using var node = CanOpen.OpenNode(bus, nodeId: 0x11);

// FR-CO-001: populate the local OD.
node.ObjectDictionary.AddU32(0x1000, 0x00, 0x00030191, OdAccess.ReadOnly); // device type
node.ObjectDictionary.AddU32(0x2000, 0x00, 0xDEADBEEF);

// FR-CO-002: SDO expedited read from another node on the same bus.
var value = await otherNode.SdoUploadAsync(serverNodeId: 0x11, index: 0x1000, subindex: 0x00);

// FR-CO-008: heartbeat producer + local consumer for a peer.
node.StartHeartbeatProducer(TimeSpan.FromMilliseconds(200));
node.AddHeartbeatConsumer(producerNodeId: 0x12, timeout: TimeSpan.FromMilliseconds(500));
node.HeartbeatTimeout += (s, e) => Console.WriteLine($"missed HB from 0x{e.ProducerNodeId:X2}");

// FR-CO-007: bring the network up as an NMT master.
await node.SendNmtCommandAsync(NmtCommand.Start, targetNodeId: 0);

See tests/CanKit.Pro.Tests/TestCases/CANopen for end-to-end examples that exercise every FR-CO requirement over the CanKit.Adapter.Virtual loopback bus.

Layout

CanKit.Pro.CANopen/
  CanOpen.cs                 // factory
  CanOpenNode.cs             // implementation of ICanOpenNode
  CanOpenNodeOptions.cs
  CanOpenCobId.cs            // pre-defined connection set constants
  ObjectDictionary.cs, OdEntry.cs
  Nmt/NmtState.cs            // NMT enum + command specifier
  Sdo/                       // codec, abort codes, exception, block-transfer codec + mode enum
  CanOpenNode.SdoBlock.cs    // partial: SDO block transfer (client + server)
  CanOpenNode.NodeGuarding.cs // partial: node-guarding consumer + producer
  Pdo/PdoMapping.cs          // mapping + transmission types
  Emcy/EmcyMessage.cs        // 8-byte encode/decode

Install

dotnet add package CanKit.Pro.CANopen

# plus a CanKit adapter for the hardware you actually talk to, e.g.
dotnet add package CanKit.Adapter.Virtual   # loopback, no hardware

Dependencies: CanKit.Abstractions, CanKit.Pro.Actor, CanKit.Pro.RawCan, CanKit.Pro.Reliability.

Part of CanKit.Pro — higher CAN protocol layers built on top of CanKit, which is consumed as a NuGet package rather than forked.

License

MIT — see LICENSE. CanKit itself is a separate project licensed under Apache-2.0; see THIRD-PARTY-NOTICES.md.