Bonjour Habr.
Il est probable que beaucoup de personnes qui achètent une horloge ou une station météo aient vu sur l'emballage le logo Radio Controlled Clock ou même Atomic Clock. C'est très pratique, car il suffit de poser l'horloge sur la table et elle se réglage automatiquement sur l'heure exacte après un certain temps.
Voyons comment cela fonctionne et écrivons un décodeur en Python.
Il existe différents systèmes de synchronisation du temps. Le plus populaire en Europe est le système allemand , au Japon, il existe son propre système , aux États-Unis, il y a un système , et ainsi de suite. La suite portera sur DCF77, car c'est le plus actuel et accessible à la réception dans certaines régions de la partie européenne de la Russie et dans les pays voisins (les habitants de l'Extrême-Orient peuvent avoir un avis opposé, mais ils peuvent également recevoir et analyser le signal japonais ;).
Tout ce qui suit parlera de DCF77.
Réception du signal
DCF77 est une station longue-vague fonctionnant à une fréquence de 77,5 kHz, envoyant des signaux en modulation d'amplitude. La station, d'une puissance de 50 kW, est située à 25 km de Francfort, elle a commencé à fonctionner en 1959 et en 1973, des informations sur la date ont été ajoutées à l'heure exacte. La longueur d'onde à une fréquence de 77 kHz est très grande, donc la taille du champ d'antenne est également assez conséquente (photo de Wikipédia) :
Avec une telle antenne et la puissance fournie, la zone de réception couvre pratiquement toute l'Europe, la Biélorussie, l'Ukraine et une partie de la Russie.
Tout le monde peut enregistrer le signal. Pour cela, il suffit de se rendre sur un récepteur en ligne , de choisir la fréquence 76,5 kHz et la modulation USB. Une image semblable à celle-ci devrait apparaître :
Là-bas, nous cliquons sur le bouton download et enregistrons un fragment d'une durée de quelques minutes. Bien sûr, avec un « vrai » récepteur capable d'enregistrer la fréquence de 77,5 kHz, il est possible de l'utiliser.
Bien sûr, en recevant des signaux radio de l'heure exacte via Internet, nous n'obtiendrons pas vraiment l'heure exacte - le signal est transmis avec un retard. Mais notre objectif est simplement de comprendre la structure du signal, pour cela les enregistrements sur Internet suffisent largement. En réalité, des appareils spécialisés pour la réception et le décodage sont utilisés, dont il sera question ci-dessous.
Ainsi, nous avons obtenu un enregistrement, commençons son traitement.
Décodage du signal
Téléchargeons le fichier avec Python et regardons sa structure :
from scipy.io import wavfile
from scipy import signal
import matplotlib.pyplot as plt
import numpy as np
sample_rate, data = wavfile.read("dcf_websdr_2019-03-26T20_25_34Z_76.6kHz.wav")
plt.plot(data[:100000])
plt.show()
Nous observons une modulation d'amplitude typique :
Pour simplifier le décodage, prenons l'enveloppe du signal en utilisant la transformation de Hilbert :
analytic_signal = signal.hilbert(data)
A = np.abs(analytic_signal)
plt.plot(A[:100000]) Le résultat agrandi :
Lissont les anomalies dues aux interférences à l'aide d'un filtre passe-bas, et calculons la moyenne, qui sera utile pour le parsing.
b, a = signal.butter(2, 20.0/sample_rate)
zi = signal.lfilter_zi(b, a)
A, _ = signal.lfilter(b, a, A, zi=zi*A[0])
avg = (np.amax(A) + np.amin(A))/2 Le résultat (ligne jaune) : un signal pratiquement rectangulaire, qui est assez facile à analyser.
Parsing
Tout d'abord, nous devons obtenir la séquence binaire. La structure du signal est très simple.
Les impulsions sont divisées en intervalles de seconde. Si la distance entre les impulsions est de 0,1 s (c'est-à-dire que la durée de l'impulsion elle-même est de 0,9 s), nous ajoutons un « 0 » à la séquence binaire ; si la distance est de 0,2 s (c'est-à-dire une durée de 0,8 s), nous ajoutons un « 1 ». La fin de chaque minute est marquée par une « longue » impulsion de 2 s, et la séquence binaire est réinitialisée, avec un nouveau début.
Ce qui précède peut être facilement écrit en Python.
sig_start, sig_stop = 0, 0
pos = 0
bits_str = ""
while pos < cnt - 4:
if A[pos] avg:
# Début du signal
sig_start = pos
if A[pos] > avg and A[pos+1] < avg:
# Fin du signal
sig_stop = pos
diff = sig_stop - sig_start
if diff 0.85*sample_rate and diff 1.5*sample_rate:
print(bits_str)
bits_str = ""
pos += 1
Nous obtenons ainsi une séquence de bits, dans notre exemple pour deux secondes, elle ressemble à ceci :
0011110110111000001011000001010000100110010101100010011000
0001111100110110001010100001010000100110010101100010011000
D'ailleurs, il est intéressant de noter qu'il y a une "deuxième couche" de données dans le signal. La séquence de bits est également codée par . Théoriquement, cela devrait assurer un décodage plus robuste même en cas de signal affaibli.
Notre dernière étape : obtenir les données elles-mêmes. Les bits sont transmis une fois par seconde, donc nous avons au total 59 bits, dans lesquels beaucoup d'informations sont codées :
Les bits sont décrits dans , et ils sont tout à fait fascinants. Les 15 premiers bits ne sont pas utilisés, bien qu'il y ait eu des projets d'utilisation pour les systèmes d'alerte et de défense civile. Le bit A1 indique que l'heure suivante, l'horloge sera avancée à l'heure d'été. Le bit A2 indique qu'une , qui est parfois utilisée pour corriger l'heure en fonction de la rotation de la Terre. Les autres bits codent les heures, les minutes, les secondes et la date.
Pour ceux qui souhaitent expérimenter par eux-mêmes, le code de décodage est fourni sous le spoiler.
Code source
def decode(bits):
if bits[0] != '0' or bits[20] != '1':
return
minutes, hours, day_of_month, weekday, month, year = map(convert_block,
(bits[21:28], bits[29:35], bits[36:42], bits[42:45],
bits[45:50], bits[50:58]))
days = ('Dimanche', 'Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi', 'Dimanche')
print('{dow}, {dom:02}.{mon:02}.{y}, {h:02}:{m:02}'.format(h=hours, m=minutes, dow=days[weekday],
dom=day_of_month, mon=month, y=year))
def convert_ones(bits):
return sum(2**i for i, bit in enumerate(bits) if bit == '1')
def convert_tens(bits):
return 10*convert_ones(bits)
def right_parity(bits, parity_bit):
num_of_ones = sum(int(bit) for bit in bits)
return num_of_ones % 2 == int(parity_bit)
def convert_block(bits, parity=False):
if parity and not right_parity(bits[:-1], bits[-1]):
return -1
ones = bits[:4]
tens = bits[4:]
return convert_tens(tens) + convert_ones(ones)
En lançant le programme, nous verrons une sortie comme celle-ci :
0011110110111000001011000001010000100110010101100010011000
Mardi, 26.03.19, 21:41
0001111100110110001010100001010000100110010101100010011000
Mardi, 26.03.19, 21:42
Voilà toute la magie. L'avantage de ce système est que le décodage est extrêmement simple et peut être réalisé sur n'importe quel microcontrôleur basique. Il suffit de mesurer la durée des impulsions, d'accumuler 60 bits, et à la fin de chaque minute, on obtient l'heure exacte. Comparé à d'autres méthodes de synchronisation du temps (comme le GPS, par exemple, ou encore pire, Internet :), cette synchronisation radio nécessite pratiquement aucune énergie — pour donner un exemple, une station météo domestique ordinaire fonctionne environ un an avec deux piles AA. C'est pourquoi même des montres-bracelets sont réalisées avec une synchronisation radio, sans parler bien sûr des horloges murales ou des horloges de gare extérieures.
La commodité et la simplicité du DCF attirent également les amateurs de bricolage. Pour seulement 10 à 20 $, on peut acheter un module prêt à l'emploi avec une antenne et un récepteur intégré avec une sortie TTL, qui peut être connecté à une Arduino ou un autre contrôleur.
Des bibliothèques prêtes à l'emploi ont déjà été écrites pour Arduino et Cependant, il est de notoriété publique que quoi que l'on fasse sur un microcontrôleur, on obtient soit une horloge, soit une station météorologique. Avec un tel appareil, obtenir l'heure exacte n'est vraiment pas difficile, à condition bien sûr d'être dans une zone de réception. Et on peut même accrocher l'inscription « Horloge Atomique » sur les montres et expliquer à tous ceux qui le souhaitent que l'appareil se synchronise réellement à l'aide d'horloges atomiques.
Ceux qui le souhaitent peuvent même moderniser les vieilles montres de grand-mère en y installant un nouveau mécanisme de synchronisation radio :
On peut en trouver un sur ebay avec les mots-clés « Mouvement à Radio Commandé ».
Et enfin, un conseil pour ceux qui ont lu jusqu'ici. Même s'il n'y a pas de transmetteur de signal radio à des milliers de kilomètres à la ronde, il n'est pas difficile de générer soi-même un tel signal. Il existe sur Google Play un programme nommé « Émulateur DCF77 » qui émet un signal dans des écouteurs. Selon l'auteur, si vous enroulez le fil des écouteurs autour de la montre, elle captera le signal (je me demande comment, car des écouteurs ordinaires ne produiront pas de signal à 77kHz, mais il est probable que la réception se fasse grâce aux harmoniques). Pour ma part, sur Android 9, le programme n'a pas fonctionné du tout — je n'ai simplement pas eu de son (ou peut-être que je ne l'ai pas entendu — 77kHz après tout :), mais peut-être que d'autres auront plus de chance. Certains, cependant, fabriquent également un véritable générateur de signaux DCF, qui peut être facilement réalisé avec le même Arduino ou ESP32 :
(source )
Conclusion
Le système DCF s'est avéré en effet assez simple et pratique. Avec un récepteur peu coûteux et facile à utiliser, on peut avoir l'heure précise partout et tout le temps, bien sûr dans une zone de réception. Il semble que même malgré la numérisation généralisée et l'« Internet des objets », de telles solutions simples seront encore demandées longtemps.
Source : habr.com
