st-gall

TP2-PROG-10 : Simuler l’horloge de la gare de St-Gall#

Objectifs pédagogiques#

  • comprendre un problème

  • être capable de traduire un algorigramme vers un programme

  • introduire le temps dans un programme informatique

  • dissocier le coeur du programme de son interface graphique

  • conduire un projet complet de sa conception à sa réalisation

Prérequis#

  • Python turtle

  • boucles for et while

  • tests if

  • fonctions

Rappels : l’horloge de la gare de St-Gall#

L’horloge de la gare de St-Gall est un projet artistique de Norbert Möslang, un musicien expérimental, luthier, photographe, mais aussi créateur d’art visuel contemporain. Elle a été installée en 2019 sur le fronton de la gare de St-Gall.

Son principe est simple : elle affiche trois lignes qu’il faut lire de droite à gauche en additionnant les puissances de 2. Les cercles pour les heures, les croix pour les minutes et les carrés pour les secondes.

Structure du code#

Le code va être structuré en deux parties :

  1. Calcul de l’heure en binaire depuis l’heure en décimal

  2. Affichage à l’aide de la tortue

La structure de donnée qui permet de stocker l’heure en binaire est une list de longueur 5 pour les heures et 6 pour les minutes et les secondes. Chaque élément de la liste est un booléen True pour 1 et False pour 0.

Le projet se déroule donc en deux étapes : construire l’heure en binaire puis dans un second temps l’afficher à l’aide de la tortue.

Exercice 1 : Conversion décimal binaire#

A partir de l’algorigramme suivant, implémentez un convertisseur de décimal à binaire. La sortie de cet algorithme doit être une liste de longueur 5 pour les heures et 6 pour les minutes et les secondes. Chaque élément de la liste est un booléen initialement affecté à False. Votre programme prendra en entrée la valeur décimale des heures, minutes et secondes.

Ainsi, la valeur binaire 101110 sera représentée sous la forme de la liste :

minutes = [True, False, True, True, True, False]

Exercice 2 : récupérer l’heure actuelle#

Un ordinateur possède une horloge interne (elle est contenue dans le processeur) qui permet de simuler le temps qui passe depuis le 1 janvier 1970 (date dénommée L’époque). On peut y accéder depuis un programme Python à l’aide d’un module : le module datetime

from datetime import datetime

Trois fonctions de ce module permettent de récupérer l’heure, les minutes et les secondes actuelles :

horloge = datetime.now()

heures = horloge.hour
minutes = horloge.minute
secondes = horloge.second

Modifiez votre programme pour qu’il affiche les trois listes heures, minutes et secondes avec l’heure actuelle

Exercice 3 : Horloge binaire en mode texte#

Une fois les heures, les minutes et secondes stockées dans une liste, il est possible de simuler le temps qui passe à l’aide d’une boucle while infinie. Attention : ce n’est plus un algorithme puisqu’il ne se termine jamais. Pour stopper le programme, il faudra le tuer (appuyer sur le stop de Thonny).

La structure du code devient :

while True :
    horloge = datetime.now()

    heures = horloge.hour
    minutes = horloge.minutes
    secondes = horloge.seconds
    
    # calcul des listes contenant les heures, minutes et secondes
    h = [False, False, False, False, False]
    ...

    m = [False, False, False, False, False]
    ...
    
    h = [False, False, False, False, False]
    ...
    
    sleep(0.5)

la fonction sleep(0.5) permet de faire dormir le programme pendant une demi-seconde

Exercice 4 : Affichage en mode turtle#

Le code est structuré de telle façon qu’à chaque seconde (0.5 secondes de calcul, 0.5 secondes de sleep), les listes h, m et s contiennent les valeurs binaires des heures, minutes et secondes actuelles. Ne reste plus qu’à afficher les cercles, croix et carrés à l’aide de la tortue.

La première étape est de créer trois fonctions qui permettrons d’afficher un cercle, une croix et un carré.

Développez donc ces trois fonctions dont les signatures sont les suivantes.

Pour les cercles :

def rond(t,s, taille, couleur):
    s = s/2.5
    ...

Pour les croix :

def croix(t,s,taille,couleur):

Pour les carrés :

def carre(t,s,taille,couleur):
    s = s/1.3
    ...

Les arguments de ces fonctions représentent :

  • t : la tortue (t = Turtle())

  • s : la taille du cercle, de la croix ou du carré

  • taille : l’épaisseur du stylo. Pour un élément à afficher on choisira 5 et pour un élément qu’il ne faut pas afficher une épaisseur de 1

  • couleur : la couleur du stylo

Le calcul de s pour les ronds et les carrés permettent de s’aligner sur la taille des croix afin que tous les éléments aient la même largeur (c’est un peu de trigonométrie). La variable s permet ainsi d’afficher n’importe quelle taille de l’horloge binaire. Pour les premiers tests, essayez de fixer s = 40

Exercice 5 : Traçage d’une liste de booléens#

Modifiez votre programme pour qu’il trace des cercles, des croix ou des carrés. Pour ce faire, créez une fonction dont la signature est la suivante :

# Fonction qui permet de tracer des ronds, des carrés et des croix
# à partir d'une liste de longueur quelconque mais déclarée
# avec des valeurs booléennes
def tracer(b,t,s,type):

où les variables sont les suivantes :

  • b est une liste de booléens

  • t est la tortue

  • s est la taille (s = 40)

  • type est une chaîne de caractères permettant de discriminer les heures, les minutes et les secondes (par exemple les caractères h, m et s). la fonction tracer(b,t,s,taille) trace les cercles, les croix et les carrés.

Exercice 6 : Tout mettre ensemble#

Il est l’heure de mettre toutes les fonctions ensembles en modifiant la boucle while infinie.

La structure du code doit ressembler à :

from datetime import datetime
from turtle import *
from time import *

# Fonction qui dessine un carré de taille et couleur précisée
def carre(t,size,taille,couleur):
    ...

# Fonction qui dessine un cercle de taille et couleur précisée
def rond(t,size, taille, couleur):
    ...
    
# Fonction qui dessine une croix de taille et couleur précisée
def croix(t,size,taille,couleur):
    ...
    
# Fonction qui permet de tracer des ronds, des carrés et des croix
# à partir d'une liste de longueur quelconque mais déclarée
# avec des valeurs booléennes
def tracer(b,t,size,type):
    ...

t = Turtle()

# On récupère la fenêtre de la tortue. On trace toutes les formes et on update la fenêtre
# il n'y a pas de tortue mais la fenêtre qui se met à joue à l'aide de la fonction update()
wn = Screen()
wn.tracer(0) 

# Boucle qui ne s'arrête jamais (dessine les éléments et dort 0.5 secondes
while True : 
    horloge = datetime.now()

    # Récupère l'heure actuelle
    heures = horloge.hour
    minutes = horloge.minute
    secondes = horloge.second

    ...

    # Construit les listes de booléens (conversion dec -> bin)
    p = 4
    h = [False, False, False, False, False]
    ...

    p = 5
    m = [False, False, False, False, False, False]
    ...
    
    p = 5
    m = [False, False, False, False, False, False]
    ...
    
    p = 5
    s = [False, False, False, False, False, False]
    ...
    
    size = 40

    ...
    tracer(h,t,size,"h")
    ...

    tracer(m,t,size,"m")
    ...
    
    tracer(s,t,size,"s")
    ...

    wn.update() 
    sleep(0.5)
    t.clear()
    t.penup()
    t.home()
    t.pendown()

A vous de jouer !