org.vishia.util

Class Timeshort

java.lang.Object

org.vishia.util.Timeshort

public class Timeshort
extends java.lang.Object

This class supports working with a short time which may be count in microseconds or any other unit, and its conversion to an absolute time stamp.
It is a contradiction that must be resolved: For a time continue control the absolute time has prior no meaning. But a relative time should be exact count in steps of the control. This relative time may tuned to the real time, for example a step cycle should be exactly 0.001000 seconds (1 ms) related to the absolute time (UTC). But this cycle step width has small errors due to tolerances. Now it is not a good idea to change the running step counter for the control cycle, because then, local differences are incorrect. It should not be done.
Instead, the absolute time associated to the relative time should be noted in a longer cycle. Hence, the relative time can be associated to the correct absolute time, but with difference associations depending from the absolute time itself. Look on a simple example:

 timeShort:   0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39  
 seconds UTC:12 13  14  15 16 17  18 19 20 21  22 23 24 25 26  27 28 29 30  31 32 33  34 35 36 37 38 39 30  41 42 43  44 45 46 47 48 49
 timeAdd     12 12 12 12 12 12 12 11 11 11 11 11 11 11 11 11 11 11 11 11 11 10 10 10 10 10 10 10 10 10 10 10 10 10 10  9  9  9  9  9
 

For this example the timeShort (relative time) is ~ 6% faster then the UTC time. Realistic a relative time may have toleances in range of ppm, parts per million. For a millisecond counter it means you for 10 ppm tolerance you have a jump in the assignment every 100 second.
If you want to view a curve in a time spread of for example 10 seconds with 10000 points, one point is 1 ms, you can exactly associated the timeShort or relative time to the absolute one without error. But if you look about one hour (3600 seconds) in shift to different ranges, the association between the currently relative time and the absolute time is not unique. In order to have accurate differences everywhere, you should refrain from assigning exact times to each point. Instead use one time association from the currently relative time to the absolute one maybe in the mid of your measurement points. Then you get an timing error from 18 milliseconds on the left and right side of your measurements for the given spread of one hour, on a quartz tolerance of 10 ppm. For exact comparison to other absolute times of measurements you should currently associated any point in your spread to the absolute time. The differences are always correct.
But if you assign the exact absolute time to each point, strange differences arise at the points where the time assignment is adjusted.
In conclusion, there a two systems possible to assign the absolute time to currently relative time stamps:

• a) you store two values for each measurement point, one is the currently relative time (timeShort) and the other is the relation to a given absolute time, also as shortTime value. In the example above it is the line "timeAdd". Only ones you should store the absolute time association to your relative times minus "timeAdd". This is the time where your relative time has the zero crossing.
• b) you store only one value for each measurement point, the currently relative time (timeShort). You have a sorted table, where you can find the association from your timeShort to the absolute time. This sorted table should contain entries only on that points where the association between timeShort and timeAbs changes. For a Tolerance of 10 ppm it is one entry for 100000 measurement steps or 36 entries for one hour and 1 ms step of timeSHort.

On both variants an unsolved problem of absolute time association remains if your timeShort period is lesser than your spread of viewing. For a timeShort width of 32 bit this is +- 23 days for 1 ms step (2000000 seconds), or approximately +- 1 day for a time step of 50 us. For that reason it is helpfully that the absolute time is stored due to one measurement, which's spread must be lesser than this period. Usual the measurement are stored in separate files, and any file can get the associated absolute time for the whole spread.
Hence you can use for the both variants of measurement files:

• a) One absolute time association to your whole measurement values and two values for timeShort and timeAdd per measurement point.
• b) A not too long sorted table of time associations to your whole measurement and only one value for timeShort per measurement point.

The variant a) is better if you have the problem that the relative timeShort counting may jump or restart during the measurement period. That can be occur if a controller is reseted. It means that variant a) should favored if such is expectable.
This class helps to deal with this timing system. Instances of this class can be used even for the association between the currently relative measurement time (timeShort) and the absolute time.

Field Summary

Fields

Modifier and Type	Field and Description
private long	absTime Any absolute timestamp to the absTime_short.
private float	absTime_Millisec7short Milliseconds for 1 step of shorttime.
private int	absTime_short The shorttime-stamp to the absTime timestamp.
static int	version Version, history and license.

Constructor Summary

Constructors

Constructor and Description
Timeshort()
Timeshort(Timeshort src)

Method Summary

Modifier and Type	Method and Description
long	absTimeshort(int timeshort) Returns the absolute time in milliseconds after 1970 to a given timeshort.
void	clean()
boolean	isCleaned()
float	millisec7short() Returns the factor between milliseconds / shorttime_difference
float	millisecShort(int timeshort) Returns the milliseconds after the last setTimePoint(long, int, float) according to the given timeshort.
void	setTimePoint(long date, int timeshort, float millisecPerTimeshort)
static boolean	sleep(long millisec) Universal wait routine without necessity of a try-catch wrapping.
int	timeshort4abstime(long date) Returns the timeshort steps to the given date according to the last setTimePoint(long, int, float).

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

version

public static final int version

Version, history and license.

• 2016-03-06 Hartmut new: clean() and isCleaned() to set a new pair of absTime_short and absTime.
• 2016-03-06 Hartmut new: set data to private, access only via methods! (Why they were public?)
• 2013-04-30 Hartmut new: sleep(long) as wrapper around Thread.sleep() without Exception.
• 2012-10-14 Hartmut created as util class from well known usage.

Copyright/Copyleft: For this source the LGPL Lesser General Public License, published by the Free Software Foundation is valid. It means:

1. You can use this source without any restriction for any desired purpose.
2. You can redistribute copies of this source to everybody.
3. Every user of this source, also the user of redistribute copies with or without payment, must accept this license for further using.
4. But the LPGL is not appropriate for a whole software product, if this source is only a part of them. It means, the user must publish this part of source, but doesn't need to publish the whole source of the own product.
5. You can study and modify (improve) this source for own using or for redistribution, but you have to license the modified sources likewise under this LGPL Lesser General Public License. You mustn't delete this Copyright/Copyleft inscription in this source file.

If you intent to use this source without publishing its usage, you can get a second license subscribing a special contract with the author.

See Also:

Constant Field Values

absTime_short

private int absTime_short

The shorttime-stamp to the absTime timestamp. Set with GralCurveView#setTimePoint(long, int, float).

absTime

private long absTime

Any absolute timestamp to the absTime_short. Set with GralCurveView#setTimePoint(long, int, float).

absTime_Millisec7short

private float absTime_Millisec7short

Milliseconds for 1 step of shorttime.

Constructor Detail

Timeshort

public Timeshort()

Timeshort

public Timeshort(Timeshort src)

Method Detail

absTimeshort

public long absTimeshort(int timeshort)

Returns the absolute time in milliseconds after 1970 to a given timeshort.

setTimePoint

public void setTimePoint(long date,
                         int timeshort,
                         float millisecPerTimeshort)

clean

public void clean()

isCleaned

public boolean isCleaned()

millisec7short

public float millisec7short()

Returns the factor between milliseconds / shorttime_difference

Returns:

millisecShort

public float millisecShort(int timeshort)

Returns the milliseconds after the last setTimePoint(long, int, float) according to the given timeshort.

timeshort4abstime

public int timeshort4abstime(long date)

Returns the timeshort steps to the given date according to the last setTimePoint(long, int, float).

Parameters:

date - The current date, it should be later than the date on the setTimePoint(...)

Returns:

timeshort steps to the date in respect to the time point.

sleep

public static boolean sleep(long millisec)

Universal wait routine without necessity of a try-catch wrapping.

Parameters:

millisec -

Returns:

true if it was interrupted.