exercice base roulante

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

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 > 100:
+        vitesse_pourcent = 100
+
+    if vitesse_pourcent < -100:
+        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 = 100      # ici, amplitude = vitesse_pourcent
+    else:
+        in1 = _0___
+        in2 = _1___
+        amplitude = -100      # ici, amplitude = -vitesse_pourcent
+
+    # 4) Conversion pourcentage -> PWM
+    #    pwm = pwm_max * (amplitude / 100)
+    # TODO : compléter le calcul
+
+    pwm = int( pwm_max * (__10000 / 100) )
+
+    # 5) Retour des valeurs à appliquer sur le pont en H
+    return {
+        "in1": in1,
+        "in2": in2,
+        "pwm": pwm
+    }

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 ____ , "Test temps 0 : incorrect"
+
+    # Test 2 : temps négatif
+    dist = calcul_distance_cm(-100)
+    assert dist is ____ , "Test temps négatif : incorrect"
+
+    # Test 3 : temps None
+    dist = calcul_distance_cm(None)
+    assert dist is ____ , "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 > ____ , "Test 1000us : trop petit"
+    assert dist < ____ , "Test 1000us : trop grand"
+
+    # Test 5 : temps plus long
+    dist = calcul_distance_cm(3000)
+    assert dist > ____ , "Test 3000us : trop petit"
+    assert dist < ____ , "Test 3000us : trop grand"
+
+    print("Tests HC-SR04 réussis si vous voyez ce message.")
+
+
+if __name__ == "__main__":
+    test()

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"] == 1000____ , "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"] == 1000____ , "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"] == _1000___ , "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"] == __1__ , "Test clamp négatif : in2 incorrect"
+    assert sortie["pwm"] == _1000___ , "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"] == 500____ , "Test intermédiaire : pwm incorrect"
+
+    print("Tous les tests du moteur sont PASSÉS si vous voyez ce message !")
+
+
+if __name__ == "__main__":
+    test()