Siemens S7 SFC 1 READ_CLK: Reading PLC Clock to DATE_AND_TIME DB

Overview of SFC 1 READ_CLK on Siemens S7-300/400

SFC 1 (READ_CLK) is a Siemens standard system function available in the S7-300 and S7-400 CPU operating system that reads the current CPU clock and returns it as a BCD-encoded DATE_AND_TIME (DT) value. The block is part of the System Functions library that ships with every STEP 7 Classic installation and is mirrored in the STEP 7 V5.5 System and Standard Functions Reference Manual.

The function is invoked synchronously from user code (OB1, FB, FC, OB10–OB17, OB35, OB82, OB100–OB102, OB121) and writes 8 bytes of date/time information to the address pointed at by the OUT parameter. The block also returns an RET_VAL of type INT that contains the operation status.

SFC 1 is also re-implemented in third-party softPLC controllers that emulate the Siemens S7 instruction set, including the Advantech ADAM-821x CPU manual which lists SFC 1 through SFC 4 (READ_CLK, SET_RTM, CTRL_RTM, READ_RTM) as compatible system functions.

Prerequisites

• STEP 7 V5.x (or compatible) with the Standard Library → System Function Blocks container visible in the project.
• CPU firmware ≥ the version that ships with the targeted STEP 7 service pack. SFC 1 has been present in every S7-300/400 CPU since the original release; no firmware upgrade is required.
• A configured S7 station with a CPU whose internal clock is set (use SFC 0 SET_CLK or the PLC → Set Time of Day menu in SIMATIC Manager if not).
• A source block (OB1, FB, FC) from which SFC 1 will be called.
• Optional: a data block (DB) declared with a symbolic name so the date/time can be referenced symbolically.

DATE_AND_TIME Data Format (8-Byte BCD)

The output of SFC 1 is always an 8-byte DT value. The structure is byte-aligned and stored in BCD. Each byte holds two decimal digits except byte 7 which holds milliseconds (3 digits) plus weekday.

STEP 7 provides the IEC standard functions FC 3 D_TOD_DT and the conversion blocks in the Standard Library → IEC Function Blocks for converting the DT buffer into separate DATE, TIME_OF_DAY, and integer fields. The conversion is mandatory because the raw buffer cannot be used directly for arithmetic; arithmetic operators only work on the converted types.

RET_VAL Status Word

Storage Locations for the Output

SFC 1 accepts the following OUT destinations, all of which must reserve 8 contiguous bytes:

1. Local TEMP variable in OB1, OB10, OB35, OB100, FB, FC. Declared as DATE_AND_TIME in the interface temp section. This is the default when you drag the block from the library into a network.
2. Static variable in an FB instance DB. Declared as DATE_AND_TIME under the stat section. Survives the call lifetime.
3. Global DB variable of type DATE_AND_TIME. The most common pattern for persistent storage that is also accessible from HMI tags.
4. Merker (M) area via area-crossing pointer. STEP 7 will only allow this if you pass an ANY pointer in STL; LAD/FBD will not display a Merker address directly because the variable must be DT.

Step 1: Create the Destination DB with a Symbolic Name

The most common stumbling point in the field is assigning the DT value to a variable inside a data block. STEP 7 distinguishes between the absolute DB number and the symbolic DB name; without a name, symbolic component access is impossible.

1. In the S7 Program / S7-300 station container, right-click Blocks → Insert New Object → Data Block.
2. Choose type DB (not instance DB). Address is auto-numbered, e.g. DB 2.
3. Open the Properties of the new block (right-click → Object Properties → General – Part 2) and enter the symbolic name, e.g. ClockData or data. Save.
4. Open the DB editor and declare a single variable:

   NAME      : read_time
   TYPE      : DATE_AND_TIME
   START     : 0.0  (byte offset)
   LENGTH    : 8 bytes
   COMMENT   : PLC date/time returned by SFC 1

5. Save and compile the DB.

Without step 3 the symbolic name "read_time" will not resolve to a symbol table entry and STEP 7 will display "Symbol read_time is not a component of DB" when you try to use DB2.read_time on the OUT pin of SFC 1.

Step 2: Call SFC 1 in OB1

Open OB1 in LAD or FBD. Drag System Function Blocks → SFC 1 (READ_CLK) from the library into Network 1. STEP 7 will auto-create a TEMP variable of type DATE_AND_TIME for the OUT pin.

Replace the auto-generated TEMP variable with the symbolic DB address:

• Click the OUT pin and overwrite #temp_var with "ClockData".read_time (or whatever symbolic name you assigned). STEP 7 will then display the full path DB2.read_time in the network view.
• Alternatively, leave the address in absolute form: DB2.DBX0.0 with implicit length 8 bytes. STEP 7 inserts the proper ANY pointer internally.

Network 1 in STL will look like:

Network 1: Read CPU clock into DB2.read_time
      CALL  SFC   1
       RET_VAL : MW100        // error word (INT)
       OUT     : "ClockData".read_time   // DT, 8 bytes

Compile and download OB1 plus DB2. On the next OB1 cycle, SFC 1 will populate ClockData.read_time with the current clock value.

Step 3: Symbolic Access Without Renaming the DB

If you cannot or do not want to change the symbolic name of the DB, you can still access the variable symbolically by addressing the DB number directly and the symbol defined inside it:

DB2.read_time   // absolute DB + symbolic component

The two halves of the dotted name are independent: DB2 refers to the absolute number; read_time is resolved from the symbol table of DB2. As long as the DB contains a row named read_time, this syntax works without changing the DB's own symbolic name. The dot-notation is also valid for instance DBs.

Step 4: Absolute Addressing Using the P# Pointer

For STL programmers, or when the DB symbol table is intentionally minimized, the ANY pointer syntax provides byte-precise control over the destination:

Network 1 (STL): Read clock into DB2 starting at byte 0
      CALL  SFC   1
       RET_VAL : MW100
       OUT     : P#DB2.DBX0.0 BYTE 8

The P#DB2.DBX0.0 BYTE 8 ANY pointer explicitly specifies a length of 8 bytes. Without the BYTE 8 clause, the compiler may reject the call because the destination length is undefined.

Equivalent constructs using STL mnemonics:

      L     P##ClockData.read_time   // load ANY pointer
      LAR1                              // into AR1
      CALL  SFC   1
       RET_VAL : MW100
       OUT     : [AR1,P#0.0]

This pattern is useful in a generic FB that can read into any DB supplied by the caller.

Step 5: Cross-Area Storage (DB to Merker or Local)

Because the OUT parameter is typed as ANY pointer in the system interface, the destination may be located in any memory area supported by ANY pointers. The most common cases:

Setting the Clock with SFC 0 SET_CLK

Once the read is verified, the inverse function SFC 0 (SET_CLK) lets you write the clock back, for example after a battery replacement or to synchronize to an HMI command. The interface is identical to SFC 1 except the parameter is named IN rather than OUT:

Network 5: Set CPU clock from DB2.read_time
      CALL  SFC   0
       RET_VAL : MW102
       IN      : "ClockData".set_time   // DT, 8 bytes

SFC 0 also returns W#16#0000 on success and may return W#16#8081 if the input DT is invalid (year < 1990 or > 2089, month > 12, etc.). Combined with SFC 1 in a coordinated block, you can implement pass-through synchronization between a master clock (PC, GPS receiver, or another PLC) and the S7 CPU.

Verification Procedure

1. Download OB1 and DB2 to the CPU. Place the CPU in RUN.
2. Open the DB2 online view in STEP 7. The read_time field should update every OB1 cycle with the current BCD-encoded date/time.
3. Cross-check against the operator panel: PLC → Set Time of Day → Read displays the same values in human-readable form.
4. Force RET_VAL to MW100 in VAT and confirm W#16#0000.
5. Watch the values for at least one minute and confirm that the seconds counter increments at 1 Hz.
6. Optional: trigger SFC 0 from a watch table to set the clock to a known value, then read back via SFC 1 and confirm round-trip accuracy to within 1 second.

Troubleshooting Matrix

Performance and Cycle-Time Impact

SFC 1 is implemented in firmware and executes in microseconds. Calling it once per OB1 cycle adds well under 50 µs to the cycle time on a typical S7-315 or S7-416 CPU. The function is re-entrant, so multiple call sites within the same OB1 do not interfere.

If you need to timestamp many events per cycle, prefer a single SFC 1 call at the top of OB1 into a global DT buffer, then copy bytes to per-event tags using BLKMOV or FC 5 (a copy of the DT body). This minimizes the number of firmware calls and keeps the cycle time deterministic.

Cross-Platform Compatibility Notes

SFC 1 is part of the documented Siemens S7 instruction set and is emulated by several softPLC platforms:

• Siemens WinAC RTX: identical semantics; same DT layout.
• Advantech ADAM-821x series: documented in the Advantech CPU 821x manual; the same BCD encoding and RET_VAL codes apply. The hardware does not have a battery-backed RTC, so the clock must be initialized at every power-up via SFC 0.
• S7-1200 / S7-1500: SFC 1 does not exist in the S7-1200/1500 instruction set. Use the RD_SYS_T instruction (S7-1500) or DTL data type for analogous functionality. Migrating SFC 1 user code to S7-1500 requires manual conversion because the DT format is replaced by the more readable DTL structure.

Frequently Asked Questions