S7-1200 UNIX Timestamp

Hi everyone, this is my first post and its a solution to someones problem... already feeling helpfull.

The problem when using T_DIFF to calculate a UTC timestamp is the limitation of its output: a TIME variable. This variable is nothing more than the total number of miliseconds. The valid range is T#-24d20h31m23s648ms to T#+24d20h31m23s647ms.

As you can see, the maximum is 24days and some hours.

The UTC, is used in seconds and it has a range of some years (consider the default 1970/01/01 and you can figure out for yourself that 24days is not enough,

At the moment I am also trying to solve this, but I'm not going to use T_DIFF.

As mferraz points out, the T_DIFF block only supports a 32-bit integer which allows about +- 24 days.

Furthermore, S7-1200 doesn't support 64-bit integers. Therefore, the time stamp has to be 32-bit unless we have some library that allow 64-bit arithmetic.

I created a naive implementation that provides a Unix timestamp as seconds. The basic approach is to call T_DIFF repeatedly, each time incrementing the unix timestamp by the range of T_DIFF and decrementing the date by that range. Eventually, T_DIFF will return a successful result.

After that, I multiply the number of failures by the T_DIFF range and then add the T_DIFF result to it.

My limited testing shows that this gives an accurate timestamp. However, this is pretty inefficient because it loops nearly 700 times.

There are many ways to optimize the approach, but I wanted to share the "simple" version.

Example is here: S7-1200 Unix Timestamp Example

When copying this, notice I create 2 FCs, ConvertToSeconds and ConvertToUnixTime.

Warning: Be sure to test this thoroughly before deploying in a real system!

You might try this SCL routine to convert DTL to Unix Time.  The expressions in the CASE statement can be compressed but were expanded to show where the numbers originate.  There also may be a more elegant method and I'm open to suggestions.  

Update May, 14 2015

Sorry, there was an error in the calculation of Unix Time in January and February of a leap year.  The new attachment contains the logic to correct this problem.

Hi.

I think it fails between 2000-01-01 and 2000-02-29:(

Hi,

You are absolutely correct.  I have attached the update to the logic to address this issue.  Thanks for the finding the problem :)

Short and fast :) 

// Function GetTimestamp()

// actDT    LDT

// TS       ULInt

// Return   UDInt

#TS := 0;

IF RD_SYS_T(OUT => #actDT) = 0 THEN

    #TS := LTIME_TO_ULINT( LDT_TO_LTIME(#actDT) ) / 1000000000;

END_IF;

#GetTimestamp := ULINT_TO_UDINT(#TS);

 my solution:

#TS_OUT := (DATE_TO_UDINT(DTL_TO_DATE(#DTL_IN)) * 86400) + (TOD_TO_UDINT(DTL_TO_TOD(#DTL_IN))/1000) + 631152000; //TS as UDINT