P2E-CHIMES

Page(s) en cours de traduction/élaboration. Page(s) under translation/construction

Carillon

Le carillon est un instrument de musique composé de cloches ou diapasons accordés sur des fréquences différentes.

Ils sont généralement couplés à des horloges mécaniques et sonne les heures, demi-heures et parfois précédé -ou pas- d'une petite mélodies.

Certain d'entre-vous reconnaîtront cette horloge de cheminée équipée d'un carillon.

Brancher

Réaliser les branchements suivants:

Pico	Pico-2-Explorer
GP28	xxx
GP27	xxx
GP20	xxxx

800px

Vérifier l'Horloge

Votre Raspberry-Pi Pico est équipé d'une horloge RTC (Real Time Clock pour Horloge Temps Réel).

Cependant, celle-ci ne reste pas à l'heure lorsque le Pico est mis hors tension.

Par chance, lorsque vous utilisez Thonny IDE avec votre Raspberry-Pi Pico, celui-ci met l'horloge RTC aussi tôt qu'une session REPL est établie (ou réinitialisée).

Thonny utilise l'heure de votre PC pour initialiser la RTC du Pico.

Vous pouvez vérifier la date et l'heure de votre Pico en utilisant les instructions suivantes dans une session REPL:

>>> from machine import RTC
>>> rtc=RTC()
>>> rtc.datetime()
(2025, 3, 19, 2, 19, 32, 23, 0)

Le tuple retourné (2025, 3, 19, 2, 19, 32, 23, 0) contient les informations suivantes:

• Année
• Mois
• Jour
• Jour de la semaine (0=Lundi)
• Heure
• Minute
• Secondes
• millisecondes (lorsque disponible

Il est bien entendu possible possible de modifier l'heure d'une horloge RTC en fournissant un tuple avec les informations de la nouvelle date.

A noter que le jour de le semaine et les millisecondes peuvent être remplacés par 0.

>>> from machine import RTC
>>> rtc=RTC()
>>> rtc.datetime( (2025, 2, 10, 0, 03, 55, 27, 0) )

Code

Le script chimes.py est disponible dans le dépôt dédié au Pico-2-Explorer.

 1 from micropython import const
 2 from machine import RTC
 3 from rtplay import *
 4 import time
 5 
 6 HOUR_CHIME = const( 1 )
 7 HALF_HOUR_CHIME = const( 2 )
 8 
 9 rtc = RTC()
10 buzzer = RingTonePlayer( Pin.board.GP13 )
11 
12 def next_chime( _now ):
13     """  Calculate Next 1/2 H and Next Hour chimes time
14 
15      Parameters:
16         _now : rtc datetime  (Y,M,D,wD,h,m,s,ms)
17      
18      returns:
19         Time in seconds (since Jan 1, 2000)
20     """
21     # mktime datetime (Y,M,D,h,m,s,wD,yD)
22     if _now[5]<30: # Minutes < 30 => Chimes at next 30 mins
23         mktime_data = ( _now[0], _now[1], _now[2], _now[4], 30, 0, _now[3], 0 )
24         chime_type = HALF_HOUR_CHIME
25         hour = _now[4]
26     else: # Shime next Hour
27         chime_type = HOUR_CHIME
28         if _now[4]+1 > 23: # > 23H
29             # Next day at 00:00
30             # Transform in seconds
31             mktime_data = ( _now[0], _now[1], _now[2], _now[4], _now[5], _now[6], _now[3], 0 )
32             secs = time.mktime( mktime_data )
33             # Add a day
34             next_day_secs = secs + 24*60+60 + 30*60
35             # Decode this new date
36             mktime_data = time.localtime( next_day_secs )
37             # Zeroing the Hours, Minutes (shime the at first second)
38             mktime_data = ( mktime_data[0], mktime_data[1], mktime_data[2], 0, 0, 1, 0, 0 )
39             hour = 0
40         else:
41             # Next Hour & Zeroing minutes, seconds
42             mktime_data = ( _now[0], _now[1], _now[2], _now[4]+1, 0, 0, 0, 0 )
43             hour = _now[4]+1
44     
45     # Return seconds, Half or full Hour chime, related Hour
46     return time.mktime( mktime_data ), chime_type, hour
47 
48 
49 _now = rtc.datetime()
50 _next_chime_secs, _chime_type, _hour = next_chime( _now )
51 
52 in_day_time = lambda hour : 7 <= hour <= 21
53 
54 while True:
55     # rtc datetime (Y,M,D,wD,h,m,s,ms)
56     _now = rtc.datetime()
57     # mktime datetime (Y,M,D,h,m,s,wD,yD)
58     _mktime_data = ( _now[0], _now[1], _now[2], _now[4], _now[5], _now[6], _now[3], 0 )
59     _now_secs = time.mktime( _mktime_data ) # Secs since Jan 1, 2000
60     
61     print( "Now = %r (%i secs)" % ( _now, _now_secs ) )
62     print( "Chime at %i secs" % _next_chime_secs )
63     print( "Chime time = %r " % ( time.localtime( _next_chime_secs ), ) )
64     print( "-" * 40 )
65     
66     # It is time to play a Chime 
67     if _now_secs > _next_chime_secs:
68         if in_day_time( _hour ):
69             if _chime_type == HOUR_CHIME:
70                 buzzer.play_str( "We'reRea:d=4,o=6,b=140:8d,8d,8e,8e,f,e,2p,2e,8d,8d,8e,8e,f,e,8d,8d,8e,8f,2p,8d5,16p,8d5,16p,16d5,32d5,32d5,8f,8p,8d,8p,8d5,16p,8d5,16p,16d5,32d5,32d5,8f,8d,8d,8a,8d5,16p,8d5,16p,16d5,16d5,8f,8p,8d" )
71                 time.sleep( 2 )
72                 for i in range( _hour if _hour < 13 else _hour-12 ):
73                     buzzer.play_tone( 1500, 200 )
74                     time.sleep_ms( 800 )
75             else: # Half-Hour
76                 buzzer.play_str( "SexyEyes:d=16,o=6,b=125:b5,8p,32b5,32p,b5,p,32b5,p,32p,f#,8p,32f#,32p,f#,p,f#,p,e,8p,32e,32p,e,p,32e,p,32p,g#,8p,32g#,32p,g#,p,g#,p,f#6,8p,32f#,32p,f#,p,32f#,p,32p,a#,8p,32a#,32p,a#6,p,32a#,p,32p,b,8p,32b" )
77         # Calculate time of the next chime 
78         _next_chime_secs, _chime_type, _hour = next_chime( _now )
79           
80     time.sleep( 5 )

Une fois le script lancé, celui-ci joue une mélodie toutes les heures et toutes les demi-heures. Il faut donc être patient pour le voir fonctionner.

Après la mélodie horaire, le buzzer effectue un nombre de "beep" correspondant à l'heure signalée.

Retour REPL

Outre les sonneries, les activités du script affiche des messages toutes les 5 secondes dans la session REPL:

----------------------------------------
Now = (2025, 3, 20, 3, 17, 2, 22, 0) (1742490142 secs)
Chime at 1742491800 secs
Chime time = (2025, 3, 20, 17, 30, 0, 3, 79) 
----------------------------------------
...
...
----------------------------------------
Now = (2025, 3, 20, 3, 17, 8, 37, 0) (1742490517 secs)
Chime at 1742491800 secs
Chime time = (2025, 3, 20, 17, 30, 0, 3, 79) 
----------------------------------------
Now = (2025, 3, 20, 3, 17, 8, 42, 0) (1742490522 secs)
Chime at 1742491800 secs
Chime time = (2025, 3, 20, 17, 30, 0, 3, 79) 
----------------------------------------

La valeur Now présente la date et heure en provenance de l'horloge RTC. Cette information est affichée sous deux formes:

1. Tuple ( Année, Mois, Jour, Jour_de_la_semaine, Heure, Minutes, Secondes, 0 ) produit par rtc.datetime() puis le nombre de secondes écoulées depuis 1ier Janvier 2000 (produit par time.mktime().
2. Chime at est l'heure en secondes (depuis le 1ier Jan 2000) à laquelle le carillon doit jouer la prochaine fois
3. Chime Time est la représentation, sous forme de tuple, de l'information Chime at. Le format est, cette fois, sensiblement différent avec (Année, Jour, Mois, Heures, Minutes, Secondes, Jour_de_la_semaine, Jour_de_l_annee) puisqu'il provient de la fonction time.localtime()

Quelques explications

Commençons par analyser le corps du programme du s'étend des lignes 49 à 80.

• Ligne 49 : obtention de la date et l'heure tel que connu par l'horloge RTC. _raw contient un tuple au format (Y,M,D,wD,h,m,s,ms), autrement dit (Année, Mois, Jour, jour_de_la_semaine, Heure, Minute, Seconde, 0) avec Lundi=0.
• Ligne 50 : l'appel next_chime( _now ) détermine l'heure du prochain carillon (Heure ou Heure-et-demi) à jouer. La fonction next_chime() retourne 3 informations :
  • _next_chime_secs : Date et heure à laquelle il faut jouer le prochain carillon (soit l'heure fixe, soit la demie-heure). Ce temps s'exprime en secondes (depuis 1ier Jan 2000).
  • _chime_type : Indique s'il faut jouer le carillon pour l'heure fixe (HOUR_CHIME=1) ou pour la demie-heure (HALF_HOUR_CHIME=2).
  • _hour : L'heure concernée par le carillon (entre 0 et 23).

---

Traduction augmentée réalisée par Meurisse. D pour shop.MCHobby.be - Licence CC-BY-SA.