Comment obtenir la date et l'heure actuelles de GPS unsegment temps en python

J'ai le gps non segmenté temps comme ceci:

Tgps = 1092121243.0

Et j'aimerais comprendre ce que la date et l'heure, c'est que. Le début de l'heure GPS est le 6 janvier 1980. Fonction Python

datetime.utcfromtimestamp

pourrait donner secondes depuis le 1er janvier 1970 année.

J'ai trouvé suivantes:

from datetime import datetime
GPSfromUTC = (datetime(1980,1,6) - datetime(1970,1,1)).total_seconds()
curDate = datetime.utcfromtimestamp(Tgps + GPSfromUTC) 

Out[83]: datetime.datetime(2014, 8, 15, 7, 0, 43)

Je ne suis pas sûr leapseconds sont-ils inclus dans la fonction datetime ou je doit les calculer et de les soustraire du résultat?
Peut-être existe également une meilleure solution à ce problème?

OriginalL'auteur Anton Protopopov | 2015-10-29

13

GPS temps, a commencé en synchronisation avec l'heure UTC: 1980-01-06 (UTC) == 1980-01-06 (GPS). Les deux tick SI secondes. La différence entre le GPS en temps et en heure UTC augmente avec chaque (intercalaire) saut de seconde.

Pour trouver la bonne heure UTC, vous avez besoin de connaître le nombre de secondes intercalaires eu lieu avant le temps GPS:
```
#!/usr/bin/env python
from datetime import datetime, timedelta

# utc = 1980-01-06UTC + (gps - (leap_count(2014) - leap_count(1980)))
utc = datetime(1980, 1, 6) + timedelta(seconds=1092121243.0 - (35 - 19))
print(utc)
```
De sortie
```
2014-08-15 07:00:27 # (UTC)
```
où leap_count(date) est le nombre de secondes intercalaires introduite avant la date donnée. De TAI-UTC table (note: le site est la source officielle sur les secondes intercalaires. Il publie Bulletin de la C annonçant un nouveau bond en secondes):
```
1980..: 19s 
2012..: 35s
```
et donc:
```
(leap_count(2014) - leap_count(1980)) == (35 - 19)
```
Si vous êtes sous Unix, vous pouvez utiliser "right" fuseau horaire pour obtenir l'heure UTC de TAI temps
(et il est facile d'obtenir le TAI-temps à partir de l'heure GPS: TAI = GPS + 19 secondes (décalage constant)):
```
#!/usr/bin/env python
import os
import time

os.environ['TZ'] = 'right/UTC' # TAI scale with 1970-01-01 00:00:10 (TAI) epoch
time.tzset() # Unix

from datetime import datetime, timedelta

gps_timestamp = 1092121243.0 # input
gps_epoch_as_gps = datetime(1980, 1, 6) 
# by definition
gps_time_as_gps = gps_epoch_as_gps + timedelta(seconds=gps_timestamp) 
gps_time_as_tai = gps_time_as_gps + timedelta(seconds=19) # constant offset
tai_epoch_as_tai = datetime(1970, 1, 1, 0, 0, 10)
# by definition
tai_timestamp = (gps_time_as_tai - tai_epoch_as_tai).total_seconds() 
print(datetime.utcfromtimestamp(tai_timestamp)) # "right" timezone is in effect!
```
De sortie
```
2014-08-15 07:00:27 # (UTC)
```
Vous pourriez éviter la modification du fuseau horaire si vous extrayez les secondes intercalaires liste de correspondants tzfile(5). C'est une combinaison des deux premières méthodes où le saut comte de calcul à partir de la première méthode est automatisé et le autoupdating tzdata (système de package pour la base de données tz) à partir de la seconde méthode est utilisée:
```
>>> from datetime import datetime, timedelta
>>> import leapseconds
>>> leapseconds.gps_to_utc(datetime(1980,1,6) + timedelta(seconds=1092121243.0))
datetime.datetime(2014, 8, 15, 7, 0, 27)
```
où leapseconds.py peut extraire des secondes intercalaires de /usr/share/zoneinfo/right/UTC fichier (une partie de tzdata package).

Toutes les trois méthodes produisent le même résultat.

OriginalL'auteur jfs

J'utilise la fonction suivante qui compte les secondes intercalaires:

import bisect
from datetime import datetime, timedelta

_LEAP_DATES = ((1981, 6, 30), (1982, 6, 30), (1983, 6, 30),
               (1985, 6, 30), (1987, 12, 31), (1989, 12, 31),
               (1990, 12, 31), (1992, 6, 30), (1993, 6, 30),
               (1994, 6, 30), (1995, 12, 31), (1997, 6, 30),
               (1998, 12, 31), (2005, 12, 31), (2008, 12, 31),
               (2012, 6, 30), (2015, 6, 30), (2016, 12, 31))

LEAP_DATES = tuple(datetime(i[0], i[1], i[2], 23, 59, 59) for i in _LEAP_DATES)

def leap(date):
    """
    Return the number of leap seconds since 1980-01-01

    :param date: datetime instance
    :return: leap seconds for the date (int)
    """
    # bisect.bisect returns the index `date` would have to be
    # inserted to keep `LEAP_DATES` sorted, so is the number of
    # values in `LEAP_DATES` that are less than `date`, or the
    # number of leap seconds.
    return bisect.bisect(LEAP_DATES, date)

Bien sûr, vous devez mettre à jour _LEAP_DATES temps en temps, mais ces mises à jour sont assez rares.

En général, le temps GPS est constitué de deux nombres: GPS semaine et le nombre de secondes depuis le début de la semaine du GPS. Par conséquent, vous pouvez utiliser les éléments suivants:

def gps2utc(week, secs):
    """
    :param week: GPS week number, i.e. 1866
    :param secs: number of seconds since the beginning of `week`
    :return: datetime instance with UTC time
    """
    secs_in_week = 604800
    gps_epoch = datetime(1980, 1, 6, 0, 0, 0)
    date_before_leaps = gps_epoch + timedelta(seconds=week * secs_in_week + secs)
    return date_before_leaps - timedelta(seconds=leap(date_before_leaps))

Dans votre cas week = 0, donc:

In [1]: gps2utc(0, 1092121243.0)
Out[1]: datetime.datetime(2014, 8, 15, 7, 0, 27)

pour être sûr que votre code est à jour, vous devez consulter Bulletin de la C deux fois par an (et, en théorie, 4 fois par an). Vous pourriez l'utilisation "right/UTC", tzfile de solutions à base d' qui s'appuient sur les mises à jour automatiquement tzdata système de package.

OriginalL'auteur Yury Kirienko

3

Vous pouvez utiliser le astropy.le temps paquet pour ce faire:
```
from astropy.time import Time
mytime = 1172361618
t = Time(mytime, format='gps')
t = Time(t, format='iso')
print t
```
qui retourne:

2017-03-01 00:00:37.000

Je pense qu'il y a quelques petites définitions 1 seconde niveau entre le temps UNIX rapporté par astropy et la stricte POSIX définition, mais c'est proche.

OriginalL'auteur Ru887321

Vous devez vous connecter pour publier un commentaire.

De sortie

De sortie