nanotime.c

Go to the documentation of this file.

/**************************************************************************
 *
 *  $Id: nanotime.c 1.6 2018/12/11 11:55:06 martin REL_M $
 *
 *  Copyright (c) Meinberg Funkuhren, Bad Pyrmont, Germany
 *
 *  Description:
 *    Meinberg Library module providing functions to handle NANO_TIME
 *    and NANO_TIME_64.
 *
 * -----------------------------------------------------------------------
 *  $Log: nanotime.c $
 *  Revision 1.6  2018/12/11 11:55:06  martin
 *  Fixed compiler warnings on Windows.
 *  Revision 1.5  2018/11/21 11:24:19Z  martin
 *  Exclude non-essential header files and functions from firmware builds.
 *  Moved inclusion of stdlib.h to the header file.
 *  Revision 1.4  2018/09/20 09:46:57  martin
 *  Fixed build for some targets.
 *  Moved version dependencies to mbg:tgt.h.
 *  Revision 1.3  2018/07/16 12:39:42Z  martin
 *  Functions nano_time_64_to_tm_gps() and tm_gps_to_nano_time_64()
 *  were moved here.
 *  Account for renamed library symbol NSEC_PER_SEC.
 *  Even VS2010 doesn't provide strtoll().
 *  Revision 1.2  2017/06/12 13:54:04  martin
 *  Fixed build under Windows.
 *  Revision 1.1  2017/06/12 08:49:09Z  martin
 *  Initial revision.
 *
 **************************************************************************/

#define _NANOTIME
 #include <nanotime.h>
#undef _NANOTIME

#include <mbgtime.h>

#if !_IS_MBG_FIRMWARE
  #include <mbgerror.h>
  #include <mbgmktm.h>
  #include <str_util.h>
  #include <timeutil.h>
#endif



/*HDR*/
double nano_time_to_double( const NANO_TIME *p )
{
  double d = p->secs;

  d += ( (double) p->nano_secs ) / 1e9;

  return d;

}  // nano_time_to_double



/*HDR*/
void double_to_nano_time( NANO_TIME *p, double d )
{
  p->secs = (int32_t) d;

  d -= (double) p->secs;

  p->nano_secs = (int32_t) ( d * 1e9 );

}  // double_to_nano_time



#if !_IS_MBG_FIRMWARE

/*HDR*/
size_t snprint_nano_time( char *s, size_t max_len, const NANO_TIME *nt )
{
  size_t n = snprintf_safe( s, max_len, "%c%li.%09li",
                            _nano_time_negative( nt ) ? '-' : '+',
                            labs( (long) nt->secs ),
                            labs( (long) nt->nano_secs ) );
  return n;

}  // snprint_nano_time

#endif



#if !_IS_MBG_FIRMWARE && !defined( MBG_TGT_MISSING_64_BIT_TYPES )

/*HDR*/
void normalize_nano_time_64( NANO_TIME_64 *nt )
{
  int64_t additional_secs;

  // Step 1: Make sure nano seconds are in the interval [-10^9 + 1, 10^9 - 1]
  additional_secs = nt->nano_secs / NSEC_PER_SEC;
  nt->nano_secs -= additional_secs * NSEC_PER_SEC;
  nt->secs += additional_secs;

  // Step 2: Make sure seconds and nanoseconds have same sign if seconds is not 0
  if ( nt->secs > 0 && nt->nano_secs < 0 )
  {
    nt->secs -= 1;
    nt->nano_secs += NSEC_PER_SEC;
  }
  else if ( nt->secs < 0 && nt->nano_secs > 0 )
  {
    nt->secs += 1;
    nt->nano_secs -= NSEC_PER_SEC;
  }

}  // normalize_nano_time_64



/*HDR*/
double nano_time_64_to_double( const NANO_TIME_64 *p )
{
  double d = (double) p->secs;

  d += ( (double) p->nano_secs ) / 1e9;

  return d;

}  // nano_time_64_to_double



/*HDR*/
void double_to_nano_time_64( NANO_TIME_64 *p, double d )
{
  p->secs = (int32_t) d;

  d -= (double) p->secs;

  p->nano_secs = (int32_t) ( d * 1e9 );

}  // double_to_nano_time_64



/*HDR*/
size_t snprint_nano_time_64( char *s, size_t max_len, const NANO_TIME_64 *nt )
{
  size_t n = snprintf_safe( s, max_len, "%c%" PRId64 ".%09" PRId64,
                            _nano_time_negative( nt ) ? '-' : '+',
                            _abs64( nt->secs ),
                            _abs64( nt->nano_secs ) );
  return n;

}  // snprint_nano_time_64



static __mbg_inline /*HDR*/
void div_nano_time_64( NANO_TIME_64 *p, long div, long mul )
{
  #if defined( MBG_TGT_MISSING_LLDIV_T )
    //### TODO: Test this code
    int64_t rem = p->secs % div;
    p->secs /= div;
    p->nano_secs = ( rem * mul ) + ( p->nano_secs / div );
  #else
    lldiv_t lldt = lldiv( p->secs, div );
    p->secs = lldt.quot;
    p->nano_secs = ( lldt.rem * mul ) + ( p->nano_secs / div );
  #endif

}  // div_nano_time_64



#if !defined( MBG_TGT_MISSING_STRTOLL )

static __mbg_inline /*HDR*/
void str_to_nano_time_64( const char *s, NANO_TIME_64 *p, int base, int frac_digits )
{
  char *cp = NULL;

  p->secs = strtoll( s, &cp, base );

  if ( *cp == '.' )  // fractions may follow
  {
    char *ep = NULL;

    cp++;  // skip '.'

    p->nano_secs = strtoll( cp, &ep, base );

    if ( p->nano_secs )  // only if fractions not 0
    {
      int l = (int) ( ep - cp );

      while ( l < frac_digits )
      {
        p->nano_secs *= base;
        l++;
      }

      while ( l > frac_digits )
      {
        p->nano_secs /= base;
        l--;
      }

      if ( p->secs < 0 )
        p->nano_secs = -p->nano_secs;
    }
  }

}  // str_to_nano_time_64



/*HDR*/
void str_s_to_nano_time_64( const char *s, NANO_TIME_64 *p )
{
  str_to_nano_time_64( s, p, 10, 9 );

}  // str_s_to_nano_time_64



/*HDR*/
void str_ms_to_nano_time_64( const char *s, NANO_TIME_64 *p )
{
  // First do the same conversion as for a string representing seconds
  str_s_to_nano_time_64( s, p );

  // Now we have the value in milliseconds
  // Divide by 1000 to get seconds
  div_nano_time_64( p, 1000, 1000000UL );

}  // str_ms_to_nano_time_64

#endif  // !defined( MBG_TGT_MISSING_STRTOLL )



/*HDR*/
int nano_time_64_to_tm_gps( TM_GPS *tm_gps, const NANO_TIME_64 *nt )
{
  struct tm tm = { 0 };
  time_t t = cvt_to_time_t( nt->secs );
  int rc = mbg_gmtime( &tm, &t );

  if ( mbg_rc_is_success( rc ) )
  {
    tm_gps->year = tm.tm_year + 1900;
    tm_gps->month = tm.tm_mon + 1;
    tm_gps->mday = tm.tm_mday;
    tm_gps->yday = tm.tm_yday;
    tm_gps->wday = tm.tm_wday;
    tm_gps->hour = tm.tm_hour;
    tm_gps->min = tm.tm_min;
    tm_gps->sec = tm.tm_sec;
    tm_gps->frac = 0;         //### TODO convert fractions
#if defined( MBG_TGT_POSIX )
    tm_gps->offs_from_utc = tm.tm_gmtoff;
#endif
  }

  return rc;

}  // nano_time_64_to_tm_gps



/*HDR*/
int tm_gps_to_nano_time_64( NANO_TIME_64 *nt, const TM_GPS *tm )
{
  time_t t = mbg_mktime( tm->year - 1900, tm->month - 1, tm->mday - 1, tm->hour, tm->min, tm->sec );

  if ( t != (time_t) -1 )
  {
    nt->secs = (uint64_t) t;
    nt->nano_secs = 0;    //### TODO: convert fractions
    return 1;
  }

  return 0;

}  // tm_gps_to_nano_time_64

#endif  // !_IS_MBG_FIRMWARE && !defined( MBG_TGT_MISSING_64_BIT_TYPES )