S7-1200 to Delta ASDA-A2 Servo: Modbus RTU and CANopen Integration

This reference covers the practical engineering path for connecting a Siemens SIMATIC S7-1200 CPU to a Delta Electronics ASDA-A2 AC servo drive system. The two viable fieldbus options on the A2 platform are Modbus RTU over RS-485 and CANopen (CiA 402). Each option is dissected in terms of hardware, parameter map, TIA Portal programming, and the multi-axis cycle time penalty that drives the architectural choice for a typical 8 to 10 servo application.

1. Hardware Architecture Overview

1.1 System Block Diagram

1.2 Component Reference List

2. Delta ASDA-A2 Communication Capabilities

The ASDA-A2 platform provides the following on its control board:

• CN1 – I/O / pulse / analog command interface (always present)
• CN2 – Encoder feedback connector
• CN3 – RS-485 / RS-232 / RS-422 communication port (Modbus RTU is the only supported protocol here)
• CN4 – Reserved slot for optional fieldbus card (CANopen, DeviceNet, EtherCAT, PROFIBUS-DP)

Two physical layers are exposed at the system level:

1. Modbus RTU (RS-485) on CN3, all ASDA-A2 variants.
2. CANopen (CiA 402 / DS-301) on CN4 with optional card or on the -M (multi-protocol) variants where CANopen is factory-installed.

2.1 Modbus Register Map Highlights

The A2 Modbus register map is detailed in the Delta ASDA-A2 user manual. The most-used addresses for cyclic motion control are:

2.2 CANopen Object Dictionary Highlights (CiA 402)

The CANopen PDO configuration for the A2 follows the CiA 402 profile. TPDO1 carries the 16-bit statusword and 32-bit actual position; RPDO1 carries controlword and 32-bit target position for Profile Position mode (PP). The A2 supports 4 TPDOs and 4 RPDOs; defaults are TPDO1 at 100 ms / RPDO1 at 100 ms, which can be tightened to 1 ms with bus load permitting.

3. Modbus RTU Integration on the S7-1200

3.1 Hardware Selection: Signal Board vs Communication Module

For a 10-servo application with bus lengths under 30 m the signal board is normally sufficient. Each RS-485 port supports up to 32 unit loads, so a single CM 1241 can address 10 A2 drives without repeaters.

3.2 A2 Modbus Parameter Setup (P2 Group)

Before connecting the S7-1200, configure these parameters on the A2 via the drive keypad:

3.3 RS-485 Wiring Topology

S7-1200 CM1241           ASDA-A2 #1         ASDA-A2 #2 ...        ASDA-A2 #N
   T/R+  (pin 3) ----+----- CN3-1 (RS-485+) ----- ... ----- CN3-1 (RS-485+)
                     |
   T/R-  (pin 8) ----+----- CN3-2 (RS-485-) ----- ... ----- CN3-2 (RS-485-)
                                                |
                                          120 Ω resistor across
                                          CN3-1 / CN3-2 at LAST
                                          slave ONLY
                                          (not at the master unless
                                          line is short and reflection
                                          an issue)
   GND   (pin 5) ----+----- CN3-5 (GND) ---------
                     |
   Shield tie to PE at the cabinet entry bulkhead; do not ground at every device

Use a daisy chain topology. Avoid star, T, or stub branches longer than 0.3 m at 115.2 kbps. Place the 120 Ω termination only at the two physical ends of the bus — not at intermediate drives.

3.4 TIA Portal Program Structure

The S7-1200 supports Modbus master mode using the MB_COMM_LOAD and MB_CLIENT instructions (FB1083 / FB1084 in the "MODBUS" library distributed with TIA Portal). Modern firmware (V4.4+) also exposes MODBUS_PLCSCAN for register polling without a per-connection FB call. For 10 axes the per-axis MB_CLIENT approach is the conventional choice because it gives independent error and timeout handling per drive.

Block organization (OB1 / OB100 / DB layout):

• OB100 (Startup) – Set bus parameters, switch all drives to Servo OFF, initialize local data.
• OB1 (Main) – Cyclic MB_CLIENT call sequence (one FB per drive, all assigned to the same MB_COMM_LOAD port).
• OB35 (Cyclic interrupt, 4 ms) – Optional fast motion loop for high-priority axes (overshadows OB1 cycle).
• OB82 / OB86 – Diagnostics on comms module failure.

3.5 Sample MB_COMM_LOAD (Starter OB100)

// OB100 - cold restart, configure RS-485 port once
// Background DB: "ModbusPort_DB"
// Port: CM1241 RS-485 (local slot 101)
"ModbusPort_DB".REQ       := TRUE;             // execute configuration
"ModbusPort_DB".PORT      := 101;              // hardware ID of the CM 1241
"ModbusPort_DB".BAUD      := 115200;           // match P2-02 on A2
"ModbusPort_DB".PARITY    := 0;                // 0 = none, 1 = odd, 2 = even
"ModbusPort_DB".DATA_BITS := 8;
"ModbusPort_DB".STOP_BITS := 1;
"ModbusPort_DB".FLOW_CTRL := 0;                // 0 = none (RS-485 half-duplex)
"ModbusPort_DB".WAIT_TIME := 50;               // inter-character timeout 50 ms
"MB_COMM_LOAD_DB"(REQ      := "ModbusPort_DB".REQ,
                  PORT     := "ModbusPort_DB".PORT,
                  BAUD     := "ModbusPort_DB".BAUD,
                  PARITY   := "ModbusPort_DB".PARITY,
                  DATA_BITS:= "ModbusPort_DB".DATA_BITS,
                  STOP_BITS:= "ModbusPort_DB".STOP_BITS,
                  FLOW_CTRL:= "ModbusPort_DB".FLOW_CTRL,
                  WAIT_TIME:= "ModbusPort_DB".WAIT_TIME,
                  DONE     => "ModbusPort_DB".DONE,
                  ERROR    => "ModbusPort_DB".ERROR,
                  STATUS   => "ModbusPort_DB".STATUS);

3.6 Per-Axis MB_CLIENT FB (10 instances, cyclic 20 ms)

The trick that most newcomers miss: with a single RS-485 port and half-duplex master, the MB_CLIENT FBs must be sequenced, not parallel. Triggering all 10 instances on the same scan causes request collisions because the previous response has not finished. The pattern below uses a simple round-robin scheduler.

// OB1 - round-robin Modbus master, 1 axis per scan
#SlotIndex := (#SlotIndex + 1) MOD 10;        // 0..9
#ActiveInstance := "ModbusAxis_DB"[#SlotIndex].instMB_CLIENT;

IF #SlotIndex = 0 THEN                       // axis 1
    #ActiveInstance.MODE     := 4;           // 4 = read holding registers (FC 03)
    #ActiveInstance.DATA_ADDR:= 16#0000;     // status word 1 (P4-07)
    #ActiveInstance.DATA_LEN := 8;           // read 8 words back (status, command, target, actual, etc.)
    #ActiveInstance.UNIT_ID  := 1;           // Modbus slave ID = 1
END_IF;
// ... repeat for slot 1..9 with UNIT_ID := #SlotIndex + 1 and per-axis offset

// Wait for done / error before next slot in OB1
IF #ActiveInstance.DONE OR #ActiveInstance.ERROR THEN
    #NextSlot := TRUE;
END_IF;

// Single instance call (only the active one has REQ = TRUE)
"ModbusAxis_DB"[0].instMB_CLIENT.REQ := #SlotIndex = 0;
"ModbusAxis_DB"[1].instMB_CLIENT.REQ := #SlotIndex = 1;
// ... etc., one FB at a time

#ActiveInstance(REQ       := "ModbusAxis_DB"[#SlotIndex].instMB_CLIENT.REQ,
                MB_DB     := "ModbusAxis_DB"[#SlotIndex].instMB_CLIENT.MB_DB,
                MB_ADDR   := "ModbusAxis_DB"[#SlotIndex].instMB_CLIENT.UNIT_ID,
                MODE      := "ModbusAxis_DB"[#SlotIndex].instMB_CLIENT.MODE,
                DATA_ADDR := "ModbusAxis_DB"[#SlotIndex].instMB_CLIENT.DATA_ADDR,
                DATA_LEN  := "ModbusAxis_DB"[#SlotIndex].instMB_CLIENT.DATA_LEN,
                DATA_PTR  := "ModbusAxis_DB"[#SlotIndex].instMB_CLIENT.DATA_PTR,
                DONE      => "ModbusAxis_DB"[#SlotIndex].instMB_CLIENT.DONE,
                BUSY      => "ModbusAxis_DB"[#SlotIndex].instMB_CLIENT.BUSY,
                ERROR     => "ModbusAxis_DB"[#SlotIndex].instMB_CLIENT.ERROR,
                STATUS    => "ModbusAxis_DB"[#SlotIndex].instMB_CLIENT.STATUS,
                MB_STATE  => "ModbusAxis_DB"[#SlotIndex].instMB_CLIENT.MB_STATE);

For a 10-axis, 8-word-per-axis poll, the round-robin at 115.2 kbps achieves approximately 20–30 ms cycle for the complete bus update. If the application needs 5–10 ms response per axis, either split across two RS-485 ports (CM 1241 + SB) or move to CANopen.

4. CANopen Integration via HMS Anybus CM

4.1 Why the HMS Anybus CM Is the Common Path

Siemens does not produce a native CANopen communication module for the S7-1200 family. The third-party ecosystem fills that gap, and HMS Industrial Networks' Anybus CM CANopen (also referenced as "CM CANopen expansion module") is the most documented solution with TIA Portal function blocks shipped by HMS. The module mounts on the S7-1200 backplane and the CPU addresses it as a standard I/O device over the internal bus.

Capabilities of the HMS Anybus CM CANopen:

• CANopen master or slave (selectable in TIA Portal configuration)
• Baud rates: 10 kbps to 1 Mbps (auto-baud detect supported)
• Up to 127 CANopen slaves (TPDO + RPDO + SDO)
• Pre-built FB library for TIA Portal V11/V12 onward (current revisions support V15.1 through V18)
• EDS file import for non-HMS slaves (the Delta A2 ships with a standard EDS file matching CiA 402)

4.2 Hardware Installation

1. Power down the S7-1200 and clip the Anybus CM onto the left-side backplane; secure the inter-module bus connector.
2. Wire the CAN side to a 9-pin D-sub (or the CM's pluggable header, depending on variant). The CAN signals are CAN_H (pin 7) and CAN_L (pin 2 on D-sub; verify against HMS manual).
3. Install 120 Ω termination resistors at each physical end of the CAN bus. The A2's CN4 connector has an internal termination switch (S1) on some variants; enable it only if the drive is at the bus end.
4. Connect the CAN shield to PE at the cabinet bulkhead; do not daisy-chain the shield from device to device.
5. Power up. The Anybus CM should appear in the device tree of TIA Portal under "Local modules" → "Communication Module".

4.3 HMS Configuration Studio

The CM is configured using the HMS CM CANopen Configuration Studio (downloadable from the HMS website). Steps:

1. Insert the Delta A2 EDS file into the Studio project. The file is DELTA_ASDA_A2_xxxx.eds, supplied by Delta as a separate download on the drive product page.
2. Add an A2 servo node for each drive, set its node-ID (1 to 127, typically 1..10), and assign TPDO1 / RPDO1 default mappings per the CiA 402 mapping in section 2.2.
3. Set the bus baud rate (1 Mbps is recommended for sub-2 ms cycle).
4. Configure SYNC: master = Anybus CM, cycle = 2 ms (matches the A2 position loop).
5. Export the generated configuration to TIA Portal through the HMS "TIA Portal plug-in". This automatically populates the data block with input/output tags.

4.4 TIA Portal FB Use (HMS Library)

HMS provides a library with FBs such as CM_CANopen_MASTER, CM_CANopen_PDO_READ, CM_CANopen_PDO_WRITE, and CM_CANopen_SDO_READ / CM_CANopen_SDO_WRITE. The master FB must be called once per scan to keep the bus running. A typical OB1 pattern for 10 axes:

// OB1
// 1) Master heartbeat
"HMS_MASTER".EXECUTE := TRUE;
"HMS_MASTER"(EXECUTE    := TRUE,
             BUSY       => "HMS_MASTER".BUSY,
             ERROR      => "HMS_MASTER".ERROR,
             STATUS     => "HMS_MASTER".STATUS);

// 2) Per-axis PDO write (controlword + target position)
FOR #i := 0 TO 9 DO
    "Axis_PDO_Write"[#i](
        EXECUTE := "Axis_Cmd"[#i].Enable AND NOT "Axis_PDO_Write"[#i].BUSY,
        NODE_ID := #i + 1,
        PDO_NUM := 1,
        DATA_LEN:= 8,
        DATA_PTR:= "Axis_TxBuf"[#i],
        DONE    => "Axis_Cmd"[#i].PdoWriteDone,
        ERROR   => "Axis_Cmd"[#i].PdoWriteError,
        STATUS  => "Axis_Cmd"[#i].PdoWriteStatus);

    // 3) Per-axis PDO read (statusword + actual position)
    "Axis_PDO_Read"[#i](
        EXECUTE := "Axis_Cmd"[#i].Enable AND NOT "Axis_PDO_Read"[#i].BUSY,
        NODE_ID := #i + 1,
        PDO_NUM := 1,
        DATA_LEN:= 8,
        DATA_PTR:= "Axis_RxBuf"[#i],
        DONE    => "Axis_Cmd"[#i].PdoReadDone,
        ERROR   => "Axis_Cmd"[#i].PdoReadError,
        STATUS  => "Axis_Cmd"[#i].PdoReadStatus);
END_FOR;

With the master running, each PDO exchange is an independent transaction on the bus. At 1 Mbps and 2 ms SYNC, the worst-case bus update latency for all 10 axes is bounded by the CANopen inter-message gap, typically < 1.5 ms — a 10× improvement over the Modbus RTU round-robin.

4.5 CiA 402 State Machine Handling

The A2 CANopen interface follows the CiA 402 finite state automaton. The controlword sequence to reach the Operation Enabled state is:

Each step must be observed in the statusword (0x6041) before sending the next. The recommended interval is 10–50 ms between transitions to avoid race conditions during A2 boot.

5. Cycle Time and Multi-Axis Performance

5.1 Modbus RTU Performance Model

For a 10-axis, 8-register cyclic poll at 115.2 kbps, 8-N-1:

• Bytes per Modbus RTU transaction (FC 03, 8 words response):
  Request = 8 bytes (slave, FC, addrHi, addrLo, qtyHi, qtyLo, CRC, CRC)
  Response = 21 bytes (slave, FC, byteCount, 16 data, CRC, CRC)
• Inter-frame gap: 3.5 character times (silence delimiter) = 3.5 × 10/115200 = 0.30 ms
• Total bytes per axis: 29 → at 115.2 kbps with start/stop bits = 11.52 kB/s effective payload throughput per char = 87 µs per char × 29 = 2.52 ms
• Total bus cycle: 10 × 2.52 ms + 10 × 0.30 ms = 28.2 ms for a complete poll of 10 axes

This is the practical floor for a 10-axis Modbus RTU bus on the S7-1200 with stock CM 1241. Doubling the baud rate to 230.4 kbps halves the cycle, but the A2 P2-02 code 0x0007 must be selected and 230.4 kbps is at the edge of the A2's RS-485 transceiver spec in electrically noisy cabinets.

5.2 CANopen Performance Model

For the same 10-axis system at 1 Mbps, CiA 402 PDO1 in/out (8 bytes payload each):

• Frame size: 8 bytes data + 28 bits overhead = 92 bits total. At 1 Mbps = 92 µs per frame.
• One RPDO + one TPDO per axis = 184 µs per axis.
• 10 axes plus SYNC frame: 10 × 184 + 92 = 1932 µs ≈ 2.0 ms for the complete bus cycle.

CANopen delivers roughly an order-of-magnitude improvement in deterministic cycle time. For motion applications where target-position must update every 5–10 ms, this is decisive.

5.3 Decision Matrix

6. Servo Drive Setup Common to Both Paths

Regardless of the comms interface, the A2 itself must be placed into a controllable mode:

1. Set control mode: P1-01 = 0x0001 selects Position Mode (Pr) for canned motion; 0x0002 selects Position Mode (Pt) for external pulse / direct register input; 0x0003 selects Speed Mode (S); 0x0004 selects Torque Mode (T). For fieldbus position commands, use Pt mode (P1-01 = 0x0002) and set the position source to register (P4-13 / P4-14) via P1-00 = 0x0002.
2. Enable servo via fieldbus: P0-03 must be set to a value that allows the digital inputs and fieldbus to enable the drive. Typical: P0-03 = 0x0001 (uses DI SON input) or 0x0002 (uses fieldbus controlword). The A2 firmware allows either by OR-ing in software with the register control bit.
3. Set electronic gear ratio: P1-44 / P1-45 (numerator) and P1-46 / P1-47 (denominator). The combined ratio maps motor pulses to user units. For a 17-bit encoder (160000 pulses per rev) commanding 1 motor revolution per user pulse: P1-44=1, P1-45=0, P1-46=160000, P1-47=0.
4. Tune the drive: Use the Delta ASDA-Soft software and the auto-tuning wizard before connecting the fieldbus command stream. A2 default gains are intentionally conservative; expect instability on the first PTP motion if P2-00 / P2-32 (velocity / position loop gains) are not set.
5. Configure alarm response: P0-01 (alarm reset via register), P0-02 (alarm stop method), and the comms-related alarms (AL020, AL021, AL022) are the most important to test under fieldbus operation.

7. Commissioning & Verification Procedure

1. Start with a single axis wired and a single MB_CLIENT test in TIA Portal. Set MB_CLIENT to read 8 words from address 0x0000 (statusword). Verify in the watch table that the values update and the status changes from 16#7000 to 16#0000 on DONE.
2. Set the drive into Servo On by writing 0x0001 to the command word at address 0x0002. Verify the drive display shows on and the motor holds position against a slight external disturbance (clamp the shaft with a soft hand force; it should resist without surging).
3. Issue a small position command (e.g., +1000 pulses) to the 32-bit position register at 0x0006/0x0007. Use in-position signal (status bit) to confirm closure.
4. Once one axis is working, replicate to the other nine. Use a sequential FOR loop in OB1 to commission one axis at a time and log results in a global DB for verification.
5. For the multi-axis, switch to the round-robin scheduler (section 3.6). Measure the round-trip latency by toggling a digital output from the S7-1200 and capturing the response bit on the drive within a S7-1200 OB35 cyclic task; the delta is the bus cycle.
6. Test fault scenarios: disconnect the RS-485 cable mid-run and confirm that MB_CLIENT.ERROR rises and the drive's AL020 alarm is raised within the configured P2-05 timeout.
7. For the CANopen path, the equivalent verification uses the HMS master FB's status and a S7-1200 watch table on the PDO data buffers. Use an oscilloscope on CAN_H / CAN_L to confirm the 1 Mbps physical layer and correct bus termination.

8. Troubleshooting Matrix

9. Engineering Best Practices

• Unique IDs, always. Set P2-01 (Modbus) or node-ID (CANopen) to a unique value on every drive. The most common field bug is two drives with ID 1; both reply to the master's poll and corrupt the data.
• Keep PDO mappings simple. Map the minimum required objects in each RPDO/TPDO. Mapping 8 objects on every PDO and running at 1 kHz is a recipe for bus errors. The 4-byte object (target position, actual position) plus 2-byte controlword/statusword is enough for most applications.
• Use shielded twisted-pair and proper shield bonding. RS-485 and CANopen both fail in unpredictable ways when the shield is not correctly bonded. Treat the shield as a single-point low-impedance ground connection to PE at the cabinet entry bulkhead.
• Plan the alarm word response path. On a bus loss, define whether the S7-1200 commands all drives to Servo Off (safe state) or leaves them in their last commanded state. The standard practice in motion control is to command a controlled stop on the S7-1200 side and let the A2 ramp down via P5-37 (deceleration time).
• Version the EDS file. Delta updates the A2 firmware regularly (current generation is v1.046 / sub 0x010F for ASDA-A2). Re-import the EDS file whenever the drive firmware is upgraded; new firmware can ship with new object dictionary entries that the old EDS doesn't expose.
• Test the worst case first. During commissioning, force 10 axes to move simultaneously and look for bus errors. The behaviour under coordinated load is often completely different from single-axis testing.

10. Extended Notes on the A2 Communication Card Variants

The A2 platform ships with several CN4 card options, each defining what physical interface is exposed:

For users who would like to keep the A2 in its natural PROFINET / PROFIBUS ecosystem, the Delta A2-PR (PROFINET) variant is also available, but this guide focuses on the two most-asked protocols: Modbus RTU and CANopen.

11. Summary of Selection Logic

Use the following decision shortcut when evaluating a new application:

1. If the machine's required bus cycle on a 10-axis system is ≤ 5 ms, use CANopen via the HMS Anybus CM and the -M (CANopen-equipped) ASDA-A2 variant.
2. If the required bus cycle is 20–30 ms and the application is supervisory (status read / setpoint write at low rate), use Modbus RTU on RS-485 with the CM 1241. This is the cheaper path.
3. If the application requires 5–20 ms cycle, the choice depends on hardware budget. The Modbus path can be made to work with 2 RS-485 ports (one for axes 1–5, one for axes 6–10) at the cost of the second CM 1241 module; the CANopen path achieves it with a single HMS CM.

Either path delivers a robust integration when the A2 is properly configured (P1-01, P0-03, P1-00, electronic gear ratio, gains) and the S7-1200 program follows the round-robin discipline. Field debug time drops sharply if the initial wiring and bus parameters are validated with a single-axis test before scaling to the full fleet.