Bac NSI pratique 2026 sujet 23 : Trames météo, codage BCD et contrôle de parité

def decoder_temperature(self):
    valeur = int(self._trame[16:28], 2)
    self._temperature = (valeur - 900) / 10

def decoder_humidite(self):
    bits = self._trame[28:36]
    if bits == '10100000':
        self._humidite = 100
    else:
        dizaines = int(bits[:4], 2)
        unites = int(bits[4:], 2)
        self._humidite = 10 * dizaines + unites

t = Transmission('0010101011001000010010001100011000101101')
assert t.get_temperature() == 26.4
assert t.get_humidite() == 62
assert t.get_id() == 42

La tranche de température comprend 12 bits et s’arrête avant l’indice 28. Pour l’humidité, lire les huit bits comme un entier binaire donnerait 98 au lieu de 62 : il faut lire deux quartets, puis composer 10×dizaines+unités. Le cas 100% est traité avant cette règle. Ces méthodes stockent leurs résultats dans _temperature et _humidite pour que les accesseurs et l’affichage fournis puissent les utiliser.

def est_valide(self):
    blocs = [self._trame[0:8], self._trame[8:16],
             self._trame[16:28], self._trame[28:36]]
    for i in range(4):
        parite = blocs[i].count('1') % 2
        if parite != int(self._trame[36+i]):
            return False
    return True

Les blocs n’ont pas tous la même longueur :8,8,12 et 8 bits. Il faut donc respecter les découpages du tableau au lieu de couper systématiquement par 8. Sur l’exemple, leurs nombres de 1 sont 3,3,4 et 3 : les restes modulo 2 forment 1101. Un seul écart suffit à rejeter la trame. Cette version suppose encore la structure bien formée ; la question 4 lèvera cette hypothèse.

Le fichier réel contient 314 lignes. Trois ont une longueur incorrecte : lignes 73 et 126 de 41 bits, ligne 111 de 38 bits. Les conversions de tranches courtes peuvent parfois réussir silencieusement, puis l’accès à un bit de contrôle absent provoquer IndexError. Une chaîne non binaire provoquerait ValueError dans int(...,2), même si ce fichier ne contient pas ce cas. Il faut aussi distinguer les trames bien formées mais invalides : trois parités sont fausses (lignes 8,53,114) et une température vaut−28,6°C (ligne 255), sous la limite du sujet.

Le filtrage intervient après la construction de tous les objets. Un constructeur qui lève une exception interrompt donc la liste complète avant même est_valide. Attraper uniquement une erreur au moment du tracé serait trop tard. L’export fourni se termine par un saut de ligne, donc trames.pop() supprime bien une ligne vide ici ; pour un autre fichier sans ce saut final, cette stratégie supprimerait une vraie trame. splitlines() serait une amélioration indépendante du lecteur.

On valide d’abord la forme : chaîne de 40 caractères tous binaires. Une trame mal formée conserve des attributsNone et est_valide renvoieFalse, sans faire échouer le constructeur. Pour une trame bien formée, on décode, puis on vérifie les contraintes de mesure et la parité. Un quartet BCD de 10 à 15 est refusé, sauf l’exception exacte 10100000. Voici une classe complète compatible avec analyse.py :

class Transmission:
    def __init__(self, trame):
        self._trame = trame
        self._id = None
        self._temperature = None
        self._humidite = None
        self.decoder()

    def structure_valide(self):
        return (isinstance(self._trame, str) and len(self._trame) == 40
                and all(bit in '01' for bit in self._trame))

    def decoder(self):
        if not self.structure_valide():
            return
        self.decoder_id()
        self.decoder_temperature()
        self.decoder_humidite()

    def decoder_id(self):
        self._id = int(self._trame[:8], 2)

    def decoder_temperature(self):
        self._temperature = (int(self._trame[16:28], 2) - 900) / 10

    def decoder_humidite(self):
        bits = self._trame[28:36]
        dizaines, unites = int(bits[:4], 2), int(bits[4:], 2)
        if bits == '10100000':
            self._humidite = 100
        elif dizaines <= 9 and unites <= 9:
            self._humidite = 10 * dizaines + unites
        else:
            self._humidite = None

    def est_valide(self):
        if not self.structure_valide():
            return False
        if self._temperature is None or self._temperature < -10:
            return False
        if self._humidite is None:
            return False
        blocs = [self._trame[:8], self._trame[8:16],
                 self._trame[16:28], self._trame[28:36]]
        return all(bloc.count('1') % 2 == int(self._trame[36+i])
                   for i, bloc in enumerate(blocs))

    def get_id(self):
        return self._id

    def get_temperature(self):
        return self._temperature

    def get_humidite(self):
        return self._humidite

    def __repr__(self):
        return f'ID : {self._id} / Temp. : {self._temperature}°C / Hum. : {self._humidite}%'

L’analyse affiche 314 trames reçues et 307 valides. Les trois erreurs de taille, trois erreurs de parité et une température trop basse sont distinctes dans ce fichier. Les températures retenues vont de 22,7 à 34,2°C ; la série commence vers 26,4°C et se termine à 24,3°C. Le graphique montre l’ordre des mesures retenues, pas une échelle temporelle connue : les lignes rejetées disparaissent de l’abscisse.

La parité détecte toute inversion isolée dans un bloc ou son bit de contrôle, mais pas forcément deux inversions dans le même bloc : leur effet sur la parité peut s’annuler. Elle ne garantit donc ni l’exactitude absolue ni l’authenticité du message. La présence d’un champ appelé clé de sécurité ne suffit pas à fournir une vérification cryptographique ; le sujet ne donne aucun protocole d’authentification à inventer.

Les validations s’organisent dans un ordre qui évite les exceptions : forme du message, conversions, contraintes des champs, puis cohérence des bits de contrôle. Un bon jeu de tests isole chaque niveau. Une trame de 39 bits doit être refusée sans accès hors limites ; une trame contenant x doit être refusée avant int ; une humidité BCD avec un chiffre 11 doit être rejetée ; une température exactement −10 doit rester acceptable ; une inversion unique doit faire échouer la parité. Le décompte sur le fichier réel complète ces tests ciblés, mais ne remplace pas les cas limites absents de ce fichier.