From 7be04e5b8b9e10e34377e52d5f08ef0062eba769 Mon Sep 17 00:00:00 2001 From: mkamdemlorenzo-boop Date: Wed, 3 Dec 2025 14:05:06 +0100 Subject: [PATCH] marvin --- tests/logique_hcsr04.py | 38 +++++++++++++++++++ tests/logique_moteur.py | 72 ++++++++++++++++++++++++++++++++++++ tests/test_logique_hcsr04.py | 37 ++++++++++++++++++ tests/test_logique_moteur.py | 57 ++++++++++++++++++++++++++++ 4 files changed, 204 insertions(+) create mode 100644 tests/logique_hcsr04.py create mode 100644 tests/logique_moteur.py create mode 100644 tests/test_logique_hcsr04.py create mode 100644 tests/test_logique_moteur.py diff --git a/tests/logique_hcsr04.py b/tests/logique_hcsr04.py new file mode 100644 index 0000000..2100a0f --- /dev/null +++ b/tests/logique_hcsr04.py @@ -0,0 +1,38 @@ +# Objectif : compléter la fonction de calcul de distance du HC-SR04. +# Le capteur renvoie un temps d'écho en microsecondes. +# Vous devez convertir ce temps en distance en centimètres. +# +# Zones à compléter : ____ ou "TODO". + + +def calcul_distance_cm(temps_echo_us): + + """ + temps_echo_us : durée du signal echo en microsecondes + Retour : + - distance en centimètres (float) + - ou None si le temps est invalide + """ + + # 1) Gérer les cas invalides : + # - temps_echo_us est None + # - temps_echo_us <= 0 + # TODO : compléter la condition + + if ____ or ____: + return ____ + + # 2) Convertir le temps en secondes : + # 1 seconde = 1 000 000 microsecondes + # TODO : compléter la conversion + + temps_s = temps_echo_us / ____ + + # 3) Calculer la distance : + # distance(cm) = (temps_s * vitesse_du_son_cm_par_s) / 2 + # vitesse du son ≈ 34300 cm/s + # TODO : compléter la formule + + distance_cm = (____ * ____) / ____ + + return distance_cm diff --git a/tests/logique_moteur.py b/tests/logique_moteur.py new file mode 100644 index 0000000..3c2bdfc --- /dev/null +++ b/tests/logique_moteur.py @@ -0,0 +1,72 @@ +# logique_moteur_eleve.py +# +# Objectif : écrire la logique de contrôle d'un moteur DC +# à partir d'une consigne de vitesse en pourcentage +# +# À compléter zones marquées avec ____ ou TODO + + +def calcul_signaux_moteur(vitesse_pourcent, pwm_max=1023): + + """ + Entrée : + vitesse_pourcent : nombre entre -100 et 100 + > 0 -> marche avant + < 0 -> marche arrière + = 0 -> arrêt + + Sortie : + dictionnaire avec : + "in1" : 0 ou 1 (sens) + "in2" : 0 ou 1 (sens) + "pwm" : valeur entre 0 et pwm_max + """ + + # 1) Limiter la vitesse entre -100 et 100 + # Si vitesse_pourcent > 100, on force à 100 + # Si vitesse_pourcent < -100, on force à -100 + # TODO : compléter les conditions + + if vitesse_pourcent > __110__: + vitesse_pourcent = _100___ + + if vitesse_pourcent < _-99___: + vitesse_pourcent = __-100__ + + # 2) Cas arrêt : si vitesse_pourcent == 0 + # -> in1 = 0, in2 = 0, pwm = 0 + # TODO : compléter la condition et le retour + + if __vitesse_pourcent__ == 0: + return { + "in1": _0___, + "in2": __0__, + "pwm": ___0_ + } + + # 3) Détermination du sens + # Si vitesse_pourcent > 0 : avant (in1=1, in2=0) + # Si vitesse_pourcent < 0 : arrière (in1=0, in2=1) + # amplitude = valeur absolue de vitesse_pourcent + + if vitesse_pourcent > 0: + in1 = 1____ + in2 = _0___ + amplitude = __> 0__ # ici, amplitude = vitesse_pourcent + else: + in1 = __0__ + in2 = ___1_ + amplitude = < 0____ # ici, amplitude = -vitesse_pourcent + + # 4) Conversion pourcentage -> PWM + # pwm = pwm_max * (amplitude / 100) + # TODO : compléter le calcul + + pwm = int( pwm_max * (_10___ / 100) ) + + # 5) Retour des valeurs à appliquer sur le pont en H + return { + "in1": in1, + "in2": in2, + "pwm": pwm + } diff --git a/tests/test_logique_hcsr04.py b/tests/test_logique_hcsr04.py new file mode 100644 index 0000000..19c556b --- /dev/null +++ b/tests/test_logique_hcsr04.py @@ -0,0 +1,37 @@ +# Objectif : écrire des tests unitaires pour vérifier calcul_distance_cm(). +# Aucune réponse n'est fournie. Les valeurs exactes doivent être déduites +# de la formule vue en cours. + +from logique_hcsr04_eleve import calcul_distance_cm + + +def test(): + + # Test 1 : temps invalide = 0 + dist = calcul_distance_cm(0) + assert dist is none , "Test temps 0 : incorrect" + + # Test 2 : temps négatif + dist = calcul_distance_cm(-100) + assert dist is __none__ , "Test temps négatif : incorrect" + + # Test 3 : temps None + dist = calcul_distance_cm(None) + assert dist is 0__ , "Test None : incorrect" + + # Test 4 : temps court (quelques centaines de microsecondes) + # Compléter avec une plage de valeurs acceptables. + dist = calcul_distance_cm(1000) + assert dist > 17.15____ , "Test 1000us : trop petit" + assert dist < __17.15__ , "Test 1000us : trop grand" + + # Test 5 : temps plus long + dist = calcul_distance_cm(3000) + assert dist > __51.45__ , "Test 3000us : trop petit" + assert dist < 51.45____ , "Test 3000us : trop grand" + + print("Tests HC-SR04 réussis si vous voyez ce message.") + + +if __name__ == "__main__": + test() diff --git a/tests/test_logique_moteur.py b/tests/test_logique_moteur.py new file mode 100644 index 0000000..100969b --- /dev/null +++ b/tests/test_logique_moteur.py @@ -0,0 +1,57 @@ +# Tests unitaires pour la fonction calcul_signaux_moteur(). +# +# IMPORTANT : +# - Aucun résultat attendu n'est donné directement. +# - Les élèves doivent connaître / déduire le comportement attendu +# d'après l'énoncé du TP + +from logique_moteur import calcul_signaux_moteur + + +def test(): + pwm_max = 1000 + + # Test 1 : arrêt + # Vérifier que les trois valeurs (in1, in2, pwm) correspondent à un moteur à l'arrêt + sortie = calcul_signaux_moteur(0, pwm_max) + assert sortie["in1"] == __0__ , "Test arrêt : valeur in1 incorrecte" + assert sortie["in2"] == ___0_ , "Test arrêt : valeur in2 incorrecte" + assert sortie["pwm"] == _0__ , "Test arrêt : valeur pwm incorrecte" + + # Test 2 : vitesse maximale en avant + # Vérifier la direction et la valeur maximale du PWM + sortie = calcul_signaux_moteur(100, pwm_max) + assert sortie["in1"] == _1___ , "Test avant : in1 incorrect" + assert sortie["in2"] == __0__ , "Test avant : in2 incorrect" + assert sortie["pwm"] == __proportionel__ , "Test avant : pwm incorrect" + + # Test 3 : vitesse maximale en arrière + # Vérifier la direction inverse et le PWM maximal + sortie = calcul_signaux_moteur(-100, pwm_max) + assert sortie["in1"] == ___0_ , "Test arrière : in1 incorrect" + assert sortie["in2"] == ____1 , "Test arrière : in2 incorrect" + assert sortie["pwm"] == __proportionel__ , "Test arrière : pwm incorrect" + + # Test 4 : valeur trop grande positive + # Vérifier que la valeur est bien "clampée" à la valeur maximale + sortie = calcul_signaux_moteur(150, pwm_max) + assert sortie["pwm"] == ___pwm max_ , "Test clamp positif : pwm incorrect" + + # Test 5 : valeur trop grande négative + # Vérifier que la valeur est bien "clampée" et le sens correct + sortie = calcul_signaux_moteur(-200, pwm_max) + assert sortie["in2"] == ____ , "Test clamp négatif : in2 incorrect" + assert sortie["pwm"] == pwm max____ , "Test clamp négatif : pwm incorrect" + + # Test 6 : valeur intermédiaire (par exemple 50 %) + # Vérifier la direction et la proportion du PWM + sortie = calcul_signaux_moteur(50, pwm_max) + assert sortie["in1"] == __1__ , "Test intermédiaire : in1 incorrect" + assert sortie["in2"] == __0__ , "Test intermédiaire : in2 incorrect" + assert sortie["pwm"] == __proportionel__ , "Test intermédiaire : pwm incorrect" + + print("Tous les tests du moteur sont PASSÉS si vous voyez ce message !") + + +if __name__ == "__main__": + test()