Receive RS232 ASCII Weight Data on S7-1200 CM 1241 in TIA Portal

Overview

Connecting an industrial weighing scale to a SIMATIC S7-1200 PLC over RS232 requires the CM 1241 RS232 communication module, the Freeport/ASCII protocol instructions in TIA Portal, and a clearly documented serial protocol from the scale vendor. This reference walks through port configuration, point-to-point receive programming, ASCII-to-numeric conversion, and HMI tag linkage for a CPU 1212C AC/DC/Relay with a CM 1241 RS232 and a KP600 mono HMI on PROFINET, all in TIA Portal V13. The same procedure applies to TIA Portal V13 SP1, V14, V15, V15.1, V16, V17, and V18 because the underlying PtP instruction set has remained stable since V13.

System Identification and Required Components

Before any program code is written, confirm the hardware in the control cabinet. The reference system used in this guide consists of:

Verify the CM 1241 RS232 firmware revision in the TIA Portal device properties. CM 1241 RS232 modules with article number 6ES7241-1AH32-0XB0 are the standard variant introduced with SIMATIC S7-1200 FW 4.0 and are fully supported by the Freeport/ASCII instructions described below. Earlier 6ES7241-1AH30-0XB0 modules share the same instruction set but report a slightly different diagnostic bit layout. The 6ES7241-1AH32-0XB0 module can be identified by the label "RS232" above the DB9 connector and the orange terminal block retainer.

CM 1241 RS232 Module Electrical and Protocol Specifications

The CM 1241 RS232 module provides one isolated RS232 port to the PLC backplane. The official specifications are documented in the SIMATIC S7-1200 manual collection.

Source: CM 1241 RS232 specifications - SIMATIC S7-1200 Manual Collection.

For a general overview of the RS232, RS422, and RS485 family of communication modules, refer to the RS232, RS422, and RS485 - SIMATIC S7-1200 Manual Collection page. For deeper study of the same CM PtP mechanism on S7-1500 (same instruction principles, different module form factor), the official Siemens support entry is the S7-1500 CM PtP sample project: Communication via the CM PtP RS232 of the SIMATIC S7. The S7-1500 sample applies to the S7-1200 in the Freeport/ASCII message-framing portion.

DB9 Pin Assignment and Cable Wiring to a Scale Indicator

The CM 1241 RS232 presents a DB9 male connector wired as a DTE device. The most common scale interface is also a DB9 male wired as DCE. A straight-through cable (pin-to-pin) is therefore NOT correct for the data lines because it would connect the two TD outputs together and the two RD inputs together. A null-modem (crossover) cable is required, swapping TD/RD and RTS/CTS.

Pin 1 (DCD), pin 6 (DSR), and pin 8 (RI) on the CM 1241 are not connected inside the module and should be left open or jumpered to satisfy the scale's input biasing as required by the scale manual.

Use shielded twisted-pair cable (for example Belden 9925 or Lapp ETHERLINE RS232) with the shield bonded to the cabinet ground at one end only. Maximum cable length is 15 m. For runs longer than 15 m, use RS422 or RS485 with a converter, or use a serial-Ethernet converter and an S7-1200 CP 1243-1 (which adds TCP/IP serial tunneling).

Documenting the Weighing Scale Protocol

The PLC programmer must obtain the exact serial protocol from the scale vendor manual before opening TIA Portal. At a minimum, capture the following information and paste it into the project documentation:

• Baud rate, data bits, parity, stop bits, flow control
• Message terminator (CR, LF, CR+LF, ETX, custom two-character sequence)
• Optional start-of-message delimiter (STX, colon, custom character)
• Frame layout (text header, weight field, sign, decimal point, units, status bits)
• Update interval (continuous mode or on-demand by command)
• Whether the scale transmits continuously or only after a "Print" command
• Checksum method, if any (BCC, XOR, CRC, none)

Common vendor protocols include Mettler Toledo "Standard Interface" (continuous), CAS "Continuous Mode", Cardinal "Stream Mode", and generic "Send/Receive ASCII". A typical continuous frame is:

where ST is the status word, GS is the gross/net indicator, the sign and decimal point are literal ASCII characters, and the frame ends with carriage return + line feed. A second common variant is:

with leading spaces to align the weight field. A third variant, used by Avery Berkel and some Sartorius scales, is a fixed-length binary-style frame with STX and ETX delimiters and a two-character checksum. Each variant requires a different parsing strategy, which is why the raw bytes must be captured in advance.

Creating the TIA Portal V13 Project and Configuring the CM 1241 RS232 Port

1. Open TIA Portal V13, choose "Create new project", and select a path on the local hard drive. Confirm the project name. The project name should follow the site tag, for example PLANT01_S71200_SCALE.
2. Open "Devices & Networks" and add the CPU 1212C AC/DC/Relay (article number 6ES7212-1BE4x-xXB0). The slot 1 SM 1231 analog module and slot 1 CM 1241 RS232 should be inserted in their correct slots, matching the physical hardware. The CM 1241 must be inserted in a free slot to the left of the CPU (slot 101 to 105 range in the S7-1200 numbering) or to the right of the CPU in the signal board slot. The CM 1241 cannot be used as a signal board.
3. For the CM 1241 RS232, navigate to "Properties > Port configuration". Set the transmission rate, parity, data bits, and stop bits to match the scale. Leave "Flow control" set to "None" or "RTS/CTS" according to the scale manual. Click "Compile" in the project tree before downloading.
4. Add the KP600 HMI to the same project. Connect the HMI PROFINET port to the CPU PROFINET port. The HMI will be online through the CPU and will read HMI tags from the PLC tags without additional routing. Set the HMI IP address to the same subnet as the CPU (default 192.168.0.1 for CPU, 192.168.0.10 for HMI).
5. Compile and download the hardware configuration to the CPU. The CM 1241 RS232 diagnostic LEDs should be off until the PLC is in RUN and the port is active. The yellow "Tx" and "Rx" LEDs blink when characters are transmitted and received.

Receive Configuration Block: RCV_CFG and RCV_P2P Programming

For the S7-1200 with TIA Portal V13, the point-to-point instructions are in the "Instructions > Communication > PtP Communication" task card. The relevant blocks are:

• RCV_CFG (Receive configuration): defines start and end conditions for ASCII frames
• RCV_P2P (Receive point-to-point): copies received bytes into a buffer DB
• RCV_RESET (Receive reset): clears the receive buffer and status
• SEND_CFG / SEND_P2P: used to send commands such as "P\r\n" to ask the scale to transmit a single weight

Create a global DB "RCV_CFG_DB" with the following structure for ASCII framing. The byte fields below match the Freeport/ASCII configuration structure used by the CM 1241 RS232.

DATA_BLOCK "RCV_CFG_DB"
{ S7_Optimized_Access := 'FALSE' }
VERSION : 0.1
NON_RETAIN
  STRUCT
    Mode     : BYTE := 16#04;  // ASCII mode, freeport
    Baud     : BYTE := 16#06;  // 9600 baud (see table)
    Parity   : BYTE := 16#00;  // 0=None, 1=Even, 2=Odd
    FlowCtrl : BYTE := 16#00;  // 0=None
    RXTimeout: WORD := W#16#64;  // 100 ms inter-character timeout
    Options  : BYTE := 16#00;  // No block-check character
    StartCnt : BYTE := 16#01;  // 1 start condition
    Start0   : BYTE := 16#53;  // 'S' (ASCII 0x53)
    Start1   : BYTE := 16#00;  // unused
    EndCnt   : BYTE := 16#01;  // 1 end condition
    End0     : BYTE := 16#0A;  // LF (0x0A) terminator
    End1     : BYTE := 16#00;  // unused
  END_STRUCT;
END_DATA_BLOCK

Baud encoding for the CM 1241 RS232 is non-obvious; the most common values are:

Call RCV_CFG in OB100 (startup) or in OB1 once on cold restart. The instruction is edge-sensitive on the REQ input. The PORT input is a UInt and is auto-generated by TIA Portal from the module's symbolic name; in this guide it is "Local~CM1241_1".PtP_PortAddr.

// OB1 - one-shot on first scan
IF "FirstScan" THEN
  "RCV_CFG_DB".Baud := 16#06;       // 9600
  "RCV_CFG_DB".Start0 := BYTE#16#53; // 'S'
  "RCV_CFG_DB".End0   := BYTE#16#0A; // LF
  RCV_CFG(REQ := TRUE,
          PORT := "Local~CM1241_1".PtP_PortAddr,
          CONFIG_DB := "RCV_CFG_DB");
  "FirstScan" := FALSE;
END_IF;

Call RCV_P2P cyclically to pull complete ASCII frames out of the hardware FIFO. A complete frame is delivered only when the end condition (LF in the example above) has been received. The DONE output pulses true for one cycle when new data has been copied into the buffer.

// OB1 - cyclic receive
RCV_P2P(REQ := "bReceiveTrigger",
        PORT := "Local~CM1241_1".PtP_PortAddr,
        BUFFER := "RxBuffer".bytes,
        LENGTH := "RxBuffer".length,
        DONE => "bRxDone",
        ERROR => "bRxError",
        STATUS => "wRxStatus");

ASCII String Parsing and Conversion to REAL

Once a complete frame has been copied into the receive buffer, convert the raw bytes to a STRING and extract the numeric portion. The example below handles a frame of the form ST,GS,+0012.34kg\r\n and produces a REAL value of 12.34 in the HMI tag.

DATA_BLOCK "RxBuffer"
{ S7_Optimized_Access := 'FALSE' }
  STRUCT
    bytes  : ARRAY[1..64] OF BYTE;
    length : UINT;
    raw    : STRING[64];
    realKg : REAL;
    valid  : BOOL;
    sign   : INT;  // +1 or -1
    wdt    : INT;  // watchdog counter, 100 ms cycle
  END_STRUCT;
END_DATA_BLOCK

// OB1 - parse a complete ASCII frame
IF "bRxDone" THEN
  // Copy bytes into a STRING, stop at LF
  "RxBuffer".raw := '';
  FOR i := 1 TO "RxBuffer".length DO
    IF "RxBuffer".bytes[i] = 16#0A THEN
      EXIT;  // stop at LF
    END_IF;
    "RxBuffer".raw := CONCAT("RxBuffer".raw,
                              CHAR_TO_STRING(BYTE_TO_CHAR("RxBuffer".bytes[i])));
  END_FOR;

  // Determine sign
  "RxBuffer".sign := 1;
  IF FIND("RxBuffer".raw, '-') > 0 THEN
    "RxBuffer".sign := -1;
  END_IF;

  // Strip the "ST,GS," prefix (6 characters) if present
  IF LEN("RxBuffer".raw) >= 6 AND
     LEFT("RxBuffer".raw, 5) = 'ST,GS' THEN
    "TempStr" := MID("RxBuffer".raw, 7, LEN("RxBuffer".raw) - 6);
  ELSE
    "TempStr" := "RxBuffer".raw;
  END_IF;

  // Strip trailing units (kg, lb, g, t)
  kPos := FIND("TempStr", 'k');
  IF kPos = 0 THEN kPos := FIND("TempStr", 'K'); END_IF;
  IF kPos > 0 THEN
    "TempStr" := LEFT("TempStr", kPos - 1);
  END_IF;
  gPos := FIND("TempStr", 'g');
  IF gPos > 0 THEN
    "TempStr" := LEFT("TempStr", gPos - 1);
  END_IF;
  lPos := FIND("TempStr", 'l');
  IF lPos > 0 THEN
    "TempStr" := LEFT("TempStr", lPos - 1);
  END_IF;

  // Convert to REAL
  "RxBuffer".realKg := STRING_TO_REAL("TempStr") * INT_TO_REAL("RxBuffer".sign);
  "RxBuffer".valid := TRUE;
  "RxBuffer".wdt   := 0;  // reset watchdog
END_IF;

// Watchdog timer - 3 second timeout at 100 ms cycle
"RxBuffer".wdt := "RxBuffer".wdt + 1;
IF "RxBuffer".wdt > 30 THEN
  "RxBuffer".valid := FALSE;
  "RxBuffer".realKg := 0.0;
END_IF;

For production code, lock the parser with a flag that is reset on a watchdog timer, and feed the parser a watchdog timeout of 3× the scale update interval. If a new frame has not been received within that window, set the HMI weight tag to 0 and raise a "comm loss" alarm. This prevents a frozen display when the cable is unplugged. The same watchdog can be used to display a "Scale offline" message on the HMI in place of the numeric field.

HMI Tag Configuration on the KP600 Comfort Panel

Once "RxBuffer".realKg holds a valid REAL, expose it to the HMI:

1. In the PLC tag table, create an HMI-accessible tag "Scale_Weight_kg" with address %DB100.DBD0 (or any symbolic name pointing to the REAL field of the receive buffer). Check the "Accessible from HMI" box in the tag properties.
2. In the HMI project tree, right-click "HMI Tags" and select "Add new tag". Set the connection to the S7-1200 PROFINET link, name the tag Weight_kg, and bind it to the PLC tag Scale_Weight_kg.
3. Set the acquisition mode to "Cyclic in operation" with a 200 ms cycle. The HMI polls the value at 5 Hz, which is fast enough for a 1 Hz scale update.
4. Insert a numeric output field on the KP600 screen. In the properties, set the "Process value" to Weight_kg, format to "99999.99 kg", and add a visibility animation that hides the field when RxBuffer.valid is false (showing a "No Data" text box instead).
5. Add a status indicator LED that turns red on RxBuffer.valid == FALSE for more than 3 seconds. The result is a single-screen, self-diagnostic weighing display.

Reading the Scale on Demand with SEND_P2P

For applications that must read the weight only when the operator presses a button (for example, a batching system), use SEND_P2P to send a "Print" command. The Mettler Toledo and CAS scales both accept a "P" character followed by CR+LF as a single-shot trigger.

// OB1 - send "P\r\n" on operator button
IF "btnPrint" AND NOT "btnPrintOld" THEN
  "TxBuffer".bytes[1] := 16#50;  // 'P'
  "TxBuffer".bytes[2] := 16#0D;  // CR
  "TxBuffer".bytes[3] := 16#0A;  // LF
  "TxBuffer".length   := 3;
  SEND_P2P(REQ := TRUE,
           PORT := "Local~CM1241_1".PtP_PortAddr,
           BUFFER := "TxBuffer".bytes,
           LENGTH := "TxBuffer".length,
           DONE => "bTxDone",
           ERROR => "bTxError",
           STATUS => "wTxStatus");
  RCV_RESET(REQ := TRUE,
            PORT := "Local~CM1241_1".PtP_PortAddr);
END_IF;
"btnPrintOld" := "btnPrint";

After the SEND_P2P call, the receive buffer is cleared and the next RCV_P2P call will return only the new frame. The "Print" command works for Mettler Toledo, CAS, Cardinal, and most Sartorius scales with default settings. For Avery Berkel scales, the equivalent command is "T\r\n" or the ASCII character 0x05 (ENQ) followed by the scale address byte.

Verification, Commissioning Checklist, and Online Diagnostics

After the program is downloaded, go through the following steps with the scale powered and stable:

1. Online > "Go online" with the CPU. Open the CM 1241 RS232 properties to confirm that the diagnostics view shows "No fault" and the configured baud rate. The yellow "Rx" LED on the module front should blink every time the scale transmits.
2. Open a watch table on "RxBuffer".bytes and "RxBuffer".length. Apply a known test weight to the scale. The first byte of bytes should be 0x53 ('S') within the configured cycle time, and length should jump to a non-zero value each time a frame arrives. If length stays at 0, check the start and end characters in RCV_CFG_DB against the actual scale frame.
3. Place a 10.00 kg calibrated mass on the scale. Confirm that Scale_Weight_kg reads 10.00 within ±0.02 kg (the typical scale repeatability of an industrial bench scale).
4. Remove the test mass and confirm that the displayed weight returns to 0.00 ±0.02 kg. A sticky reading usually indicates the wrong end-character in RCV_CFG_DB, causing the parser to read two frames as one and concatenate the digits.
5. Unplug the DB9 cable while the scale is still transmitting. Within 3 seconds the HMI status indicator should turn red and the numeric field should be hidden. Plug the cable back in; the indicator must clear on the next valid frame.
6. Cycle the power on the scale. The PLC should re-acquire the weight reading within 5 seconds without manual intervention. If not, check that RCV_CFG is called again in OB100 (startup) so the port is re-initialized.

Status word interpretation for the CM 1241 RS232 RCV_P2P block:

Troubleshooting Matrix