2.1Les conventions

Les conventions de nommage en programmation sont importantes pour plusieurs raisons :

Lisibilité et compréhension : En utilisant des conventions de nommage cohérentes, il devient plus facile de lire et de comprendre le code source, que ce soit pour vous-même ou pour d'autres développeurs qui travaillent sur le même projet. Des noms clairs et significatifs permettent de comprendre plus rapidement la fonction et l'objectif d'une variable, d'une fonction ou d'une classe.

Maintenabilité et évolutivité : Lorsque vous écrivez du code, vous le faites généralement dans un contexte donné, avec une certaine logique. Les conventions de nommage vous aident à maintenir cette logique et à rendre le code plus facile à maintenir et à évoluer au fil du temps. Si vous devez revenir sur un code après un certain temps, une convention de nommage cohérente vous permettra de retrouver plus facilement vos repères.

Collaboration : Lorsque plusieurs développeurs travaillent sur un même projet, une convention de nommage commune facilite la collaboration et la cohésion du code. Chacun peut comprendre plus facilement le code écrit par les autres membres de l'équipe, ce qui favorise le travail en équipe et la productivité.

Intégration d'outils : De nombreux outils et frameworks utilisés en programmation s'appuient sur des conventions de nommage spécifiques. En respectant ces conventions, vous facilitez l'intégration de ces outils dans votre code et bénéficiez de leurs fonctionnalités plus facilement.

Standardisation : Les conventions de nommage font partie de la standardisation de la programmation. Elles permettent de suivre des pratiques communes et de maintenir une certaine uniformité dans la communauté des développeurs. Cela facilite la compréhension et la réutilisation du code entre différents projets.

En résumé, les conventions de nommage en programmation sont essentielles pour améliorer la lisibilité, la maintenabilité, la collaboration et l'évolutivité du code. Elles font partie des bonnes pratiques de développement et contribuent à la qualité globale du logiciel.

La convention "Ultime"

Afin de garder le code compréhensible et constant, il est nécéssaire d'établir des convention. Voici un exemple de convention qui est utilisé par l'équipe de FRC - Ultime 5528.

Fichiers

Les noms de fichier utilisent des minuscules et ne contiennent pas d'espace : projetfll.py

Variables

Les variables utilisent le snake_case : nom_variable

Classes

Les classes utilisent le PascalCase : MaClasse

Fonctions

Les fonctions utilisent le camelCase et débutent par un verbe d'action : avancerTemps()

2.2Les commentaires

Les commentaires en Python sont des portions de texte que vous pouvez inclure dans votre code pour expliquer ou documenter son fonctionnement. Les commentaires ne sont pas exécutés par l'interpréteur Python et n'affectent pas le comportement du programme.

Il y a deux façons de créer des commentaires en Python :

Commentaires sur une seule ligne : Pour ajouter un commentaire sur une seule ligne, vous utilisez le symbole dièse (#). Tout ce qui suit le symbole dièse sur la même ligne est considéré comme un commentaire et est ignoré par l'interpréteur Python. Voici un exemple :

# Ceci est un commentaire sur une seule ligne

#diametre_roues=83.265
diametre_roues=45.6
            

Commentaires sur plusieurs lignes : Pour créer un commentaire sur plusieurs lignes, vous pouvez utiliser une paire de triples guillemets (""") pour encadrer le commentaire. Tout ce qui se trouve entre les triples guillemets ou les triples apostrophes est considéré comme un commentaire et est ignoré par l'interpréteur Python. Voici un exemple :

"""
Ceci est un commentaire
sur plusieurs lignes
"""

"""
tournerDeuxRoues(90)
avancerDistance(200)
tournerDeuxRoues(45)
avancerTemps(3)
tournerDeuxRoues(45)
"""
            

Les commentaires sont utiles pour plusieurs raisons :

• Documenter votre code : Les commentaires aident à expliquer le fonctionnement et la logique de votre code, ce qui facilite la compréhension pour vous-même et pour les autres développeurs qui pourraient lire votre code.
• Ignorer temporairement du code : Vous pouvez commenter une ou plusieurs lignes de code pour les désactiver temporairement, sans avoir à les supprimer. Cela peut être utile lorsque vous déboguez votre code ou que vous voulez tester différentes parties de votre programme.
• Fournir des informations supplémentaires : Vous pouvez utiliser des commentaires pour fournir des informations supplémentaires sur des variables, des fonctions ou d'autres éléments de votre code, ce qui peut être utile lors de la collaboration avec d'autres développeurs.

Il est généralement recommandé de commenter votre code de manière appropriée pour rendre votre code plus lisible et compréhensible. Cependant, veillez à ne pas abuser des commentaires et à les maintenir à jour au fur et à mesure que vous modifiez votre code, afin qu'ils restent pertinents et exacts.

2.3Les variables

En Python, il existe plusieurs types de variables que vous pouvez utiliser pour stocker différents types de données. Voici quelques-uns des types de variables couramment utilisés :

Entiers (int) :

Les entiers représentent les nombres entiers sans décimales. Par exemple, 1, 10, -5 sont des entiers. En Python, vous pouvez effectuer des opérations arithmétiques sur les entiers tels que l'addition (+), la soustraction (-), la multiplication (*) et la division (/).

#Exemple d'entier
mon_entier = 5528
            

Flottants (float) :

Les flottants représentent les nombres à virgule flottante, c'est-à-dire les nombres décimaux. Par exemple, 3.14, 2.5, -0.5 sont des flottants. Les opérations arithmétiques, y compris les opérations entre entiers et flottants, sont également possibles.

#Exemple de flottant
mon_flottant = 22.369
            

Chaînes de caractères (str) :

Les chaînes de caractères représentent une séquence de caractères. Elles sont utilisées pour stocker du texte. Par exemple, "Bonjour", 'Python', "42" sont des chaînes de caractères en Python. Vous pouvez effectuer des opérations sur les chaînes de caractères, telles que la concaténation (combinaison de deux chaînes) et l'extraction de sous-chaînes.

#Exemple de chaîne de caractères
ma_chaine = "Ligue LEGO FIRST"
            

Booléens (bool) :

Les booléens représentent des valeurs de vérité, soit True (Vrai) soit False (Faux). Ils sont souvent utilisés dans les expressions conditionnelles et les boucles pour prendre des décisions. Par exemple, une expression comme 5 > 3 renverra la valeur booléenne True.

#Exemple de booléen
mon_booleen = True
            

Les instructions if, elif et else sont utilisées pour créer des structures conditionnelles, c'est-à-dire des blocs de code qui sont exécutés en fonction de certaines conditions.

L'instruction if est utilisée pour exécuter un bloc de code uniquement si une condition donnée est évaluée à True. Voici un exemple :

x = 10
if x > 5:
    print("x est supérieur à 5")
                

Dans cet exemple, le bloc de code indenté sous l'instruction if sera exécuté car la condition x > 5 est évaluée à True.

L'instruction elif (qui signifie "else if" en anglais) est utilisée pour vérifier une condition supplémentaire si la condition précédente dans la structure if est évaluée à False. Voici un exemple :

x = 10
if x > 5:
    print("x est supérieur à 5")
elif x < 5:
    print("x est inférieur à 5")
                

Dans cet exemple, le premier bloc de code n'est pas exécuté car la condition x > 5 est évaluée à False. Ensuite, la condition x < 5 est vérifiée dans le bloc elif, mais elle est également évaluée à False. Par conséquent, aucun des blocs de code sous les instructions if et elif n'est exécuté.

L'instruction else est utilisée pour exécuter un bloc de code si toutes les conditions précédentes dans la structure if et elif sont évaluées à False. Voici un exemple :

x = 10
if x > 5:
    print("x est supérieur à 5")
elif x < 5:
    print("x est inférieur à 5")
else:
    print("x est égal à 5")
                

Dans cet exemple, la condition x > 5 est évaluée à True, donc le premier bloc de code est exécuté et affiche x est supérieur à 5. Si la valeur de x était inférieure à 5, le deuxième bloc de code aurait été exécuté. Si aucune des conditions précédentes n'était satisfaite, le bloc de code sous l'instruction else aurait été exécuté.

Il est important de noter que les structures conditionnelles if, elif et else peuvent être imbriquées les unes dans les autres pour prendre en compte des conditions multiples et complexes dans votre code.

2.5Les boucles

La boucle "for"

La boucle for en Python est utilisée pour itérer sur une séquence d'éléments tels qu'une liste, une chaîne de caractères, un tuple, un dictionnaire, etc. Elle permet d'exécuter un bloc de code de manière répétée pour chaque élément de la séquence.

La syntaxe générale de la boucle for en Python est la suivante :

for element in sequence:
    # bloc de code à exécuter pour chaque élément
                

• element est une variable qui prend successivement la valeur de chaque élément de la séquence à chaque itération.
• sequence est la séquence sur laquelle la boucle for itère.

Voici un exemple concret pour mieux comprendre son fonctionnement :

fruits = ["pomme", "banane", "orange"]
    for fruit in fruits:
    print(fruit)
                

Résultat :

pomme
banane
orange
            

Dans cet exemple, la boucle for itère sur la liste fruits. À chaque itération, la variable fruit prend la valeur de l'élément en cours. Le bloc de code à l'intérieur de la boucle est exécuté pour chaque élément, et ici, il se contente d'afficher chaque fruit.

On peut également utiliser la fonction range() pour générer une séquence de nombres entiers et itérer sur celle-ci. Par exemple :

for i in range(1, 5):
    print(i)
            

Résultat :

1
2
3
4
            

Dans cet exemple, la boucle for itère sur la séquence de nombres générée par range(1, 5), qui inclut les nombres de 1 à 4 (le nombre 5 est exclus). À chaque itération, la variable i prend la valeur du nombre en cours, et le bloc de code à l'intérieur de la boucle est exécuté.

Il est également possible d'utiliser l'instruction break pour interrompre prématurément la boucle, ou continue pour passer à l'itération suivante sans exécuter le reste du bloc de code.

La boucle "while"

La boucle while est utilisée pour exécuter un bloc de code tant qu'une condition spécifiée est vraie. Elle vérifie d'abord la condition, puis exécute le bloc de code tant que la condition est vraie. La syntaxe générale de la boucle while est la suivante :

while condition:
    # bloc de code à exécuter
            

Voici un exemple pour illustrer son fonctionnement :

i = 1

while i <= 5:
    print(i)
    i += 1
            

Dans cet exemple, la boucle while vérifie d'abord si i est inférieur ou égal à 5. Si la condition est vraie, le bloc de code à l'intérieur de la boucle est exécuté, puis la valeur de i est augmentée de 1. Le processus se répète tant que la condition i <= 5 est vraie. Le code affichera donc :

1
2
3
4
5
            

Il est important de faire attention lorsque vous utilisez une boucle while pour vous assurer que la condition finira par devenir fausse, sinon vous risquez de vous retrouver dans une boucle infinie qui ne se terminera jamais.

2.6Les fonctions

Pour créer une fonction en Python, vous pouvez suivre les étapes suivantes :

• Utilisez le mot-clé def suivi du nom de la fonction et de parenthèses ouvertes et fermées.
  Par exemple : def actionDetail():
• À l'intérieur des parenthèses, vous pouvez spécifier les paramètres de la fonction, séparés par des virgules, si la fonction nécessite des entrées. Par exemple : def actionDetail(parametre1, parametre2):
• Ensuite, vous écrivez le bloc de code qui constitue le corps de la fonction, en l'indentant. Cela signifie que toutes les lignes de code à l'intérieur de la fonction doivent être décalées vers la droite par rapport à la ligne de définition de la fonction. Par exemple :

def calculerDistance(parametre1, parametre2):
    # Code de la fonction
    instruction1
    instruction2
    ...                
                

Vous pouvez inclure des instructions de retour (return) dans le corps de la fonction si vous souhaitez renvoyer une valeur à l'appelant de la fonction. Par exemple :

def somme(a, b):
    resultat = a + b
    return resultat
            

Une fois la fonction définie, vous pouvez l'appeler en utilisant son nom suivi de parenthèses ouvertes et fermées. Si la fonction a des paramètres, vous pouvez leur passer des valeurs entre les parenthèses. Par exemple :

somme(2, 3)
            

C'est l'essentiel pour créer une fonction en Python. Vous pouvez définir des fonctions avec ou sans paramètres, et elles peuvent retourner ou non des valeurs. Les fonctions sont un outil puissant pour organiser et réutiliser votre code, en le divisant en blocs logiques et en encapsulant des fonctionnalités spécifiques.

2.7La console

print()

La fonction print() est utilisée pour afficher des informations à la sortie standard, généralement la console. Elle permet d'afficher du texte ou des valeurs de variables, ce qui est utile pour déboguer du code, afficher des messages à l'utilisateur ou simplement afficher des résultats.

Les paramètres de la fonction print() sont les suivants :

objet1, objet2, ..., sont les objets (valeurs ou variables) que vous souhaitez afficher. Vous pouvez spécifier autant d'objets que vous le souhaitez, en les séparant par des virgules.

sep (facultatif) est l'argument de séparation entre les objets. Par défaut, il est défini sur un espace (' '), ce qui signifie que les objets sont séparés par des espaces lorsqu'ils sont affichés. Vous pouvez le modifier en spécifiant une autre chaîne de caractères.

print("Hello, world!")  # Affiche simplement une chaîne de caractères
# Sortie : Hello, world!

x = 10
y = 20
print("La valeur de x est", x, "et la valeur de y est", y)
# Sortie : La valeur de x est 10 et la valeur de y est 20
print("La somme de x et y est", x + y)
# Sortie : La somme de x et y est 30

nom = "Alice"
age = 25
print("Je m'appelle", nom, "et j'ai", age, "ans.", sep='|', end='!')
# Sortie : Je m'appelle|Alice|et j'ai|25|ans.!
            

Erreurs courantes

Voici quelques-unes des erreurs les plus courantes qui peuvent apparaître dans la console :

• SyntaxError: C'est une erreur de syntaxe qui se produit lorsque le code Python ne suit pas la syntaxe correcte. Cela peut être dû à des parenthèses manquantes, une indentation incorrecte, des guillemets non fermés, etc.
• NameError: Cette erreur se produit lorsqu'une variable ou une fonction est utilisée avant d'être définie. Cela peut être dû à une faute de frappe dans le nom de la variable ou à une portée incorrecte de la variable.
• TypeError: Cette erreur se produit lorsque des opérations incompatibles sont effectuées sur des types de données incorrects. Par exemple, additionner une chaîne de caractères avec un entier ou appeler une fonction sur un objet qui ne prend pas en charge cette opération.
• AttributeError: Cette erreur se produit lorsqu'un attribut n'est pas trouvé pour un objet donné. Cela peut se produire si vous essayez d'accéder à un attribut qui n'existe pas pour cet objet.
• ZeroDivisionError: Cette erreur se produit lorsqu'une division par zéro est effectuée. Diviser un nombre par zéro est une opération invalide et génère cette erreur.

3.1À propos de Pybricks

Pybricks est une plateforme de programmation qui permet d'utiliser Python pour programmer les ensembles LEGO, y compris LEGO Mindstorms, SPIKE Prime, et autres produits LEGO utilisant des Smart Hubs (comme le LEGO Technic Hub). Pybricks remplace les environnements de programmation basés sur des blocs par un environnement Python, tout en étant spécifiquement conçu pour interagir avec le matériel LEGO.

Pybricks est également disponible sous forme de programmation par blocs.

Découvrir Pybricks

3.4Créer un projet

À la racine de votre dossier, créer un fichier avec l'extension .py. Par exemple : programme.py

Copier le code suivant, il vous permettra de bien débuter votre code. N'oubliez pas de bien commenter celui-ci, cela permettra de mieux s'y retrouver et d'informer sur ce qu'il produit.

#####################################################################################
# On charge nos librairies ici

from pybricks.hubs import PrimeHub
from pybricks.pupdevices import Motor, ColorSensor, UltrasonicSensor
from pybricks.parameters import Button, Color, Direction, Port, Side, Stop, Axis 
from pybricks.robotics import DriveBase
from pybricks.tools import wait, StopWatch


#============================================================================
#Information sur le robot
#============================================================================

"""
Port A : Moteur de la roue gauche
Port B : Moteur de la roue droite
Port C : Capteur de couleur
Port D : Moteur pour mécanisme - gauche
Port E : Moteur pour mécanisme - droit
Port F : Vide
"""


#============================================================================
#Paramètre du robot
#============================================================================

diametre_roue = 56     # -> en millimètres
distance_roue = 79     # -> en millimètres

roue_gauche = Motor(Port.A, Direction.COUNTERCLOCKWISE)
roue_droite = Motor(Port.B)

capteur_couleur = ColorSensor(Port.C)

mecanisme_gauche = Motor(Port.D)
mecanisme_droit = Motor(Port.E)


#============================================================================
#Initialisation du hub et du robot
#============================================================================

hub = PrimeHub()
robot = DriveBase(roue_gauche, roue_droite, diametre_roue, distance_roue)
            

3.5Le Hub

Afin d'utiliser le hub, vous devez d'abord l'initialiser. Par la suite vous aurez accès à la lumière autour du bouton principal, à l'affichage (5x5), aux boutons et à l'état de la batterie.

Pybricks : Hub

Initialiser le hub

#============================================================================
#Initialisation du hub et du robot
#============================================================================

hub = PrimeHub()
            

Vérifier l'état de la batterie

#Afficher le voltage dans la console
print(hub.battery.voltage())

Une batterie faible pourrait nuire grandement à la performance du robot. Voici une fonction qui permet de vérifier l'état de la batterie.

#============================================================================
#FONCTION : VOLTAGE DE LA BATTERIE
#============================================================================

voltage_maximum = 8372

"""
Le maximum varie d'une batterie à l'autre. Indiquer ici la
mesure lorsque la batterie est chargée à son max.
"""

def verifierBatterie():
    etat_batterie = ((hub.battery.voltage() / voltage_maximum *100)) 

    print("*** Le voltage est à "+str(etat_batterie)+"% (" + str(hub.battery.voltage())+")")
    print("*** Le voltage lorsque pleinement chargé est aux alentours de "+str(voltage_maximum))


verifierBatterie()
            

Modifier la couleur de la lumière de statut

#Afficher la couleur rouge
hub.light.on(Color.RED)

#Couleurs disponibles
"""
Color.RED
Color.ORANGE
Color.YELLOW
Color.GREEN
Color.CYAN
Color.BLUE
Color.VIOLET
Color.MAGENTA
Color.WHITE
"""

#Eteindre la lumière
hub.light.off()

    

Affichage dans la matrice 5x5

#Afficher un nombre
hub.display.number(2)

#Afficher un caractère
hub.display.char("A")

#Afficher un texte
hub.display.text("Banane", 500, 50)
"""
Dans cet exemple, chaque lettre sera affichée 500ms et
il y aura une pause de 50ms entre chaque lettre
"""

    

3.5Le Robot

Le robot, c'est votre base pilotable. C'est à partir de cet élément que vous allez définir tous les paramètres de déplacement du robot

Pybricks : Robotics & Drivebase

Initialiser le robot

#============================================================================
#Initialisation du robot
#============================================================================

diametre_roue = 56      # -> en millimètres
distance_roue = 79      # -> en millimètres

roue_gauche = Motor(Port.A, Direction.COUNTERCLOCKWISE)
roue_droite = Motor(Port.B)

robot = DriveBase(roue_gauche, roue_droite, diametre_roue, distance_roue)

            

Avancer à l'infini

while true
    robot.drive(350, 0)

"""
Le premier chiffre indique la vitesse en mm/s.
Le second chiffre indique le taux de virage en degré/s.
"""

Avancer à une distance précise

robot.straight(500)
    
"""
On indique la mesure en mm. Dans cet exemple, le robot avancera de 500 mm (50cm).
"""
    

On peut aussi paramètrer le robot pour ajouter de l'accélération et une correction de trajectoire avec le gyroscope.

#On indique d'utiliser le gyro pour corriger la trajectoire
robot.use_gyro(True)

#On indique les paramètres de déplacement
vitesse = 300 #mm/s
acceleration_deplacement = 100 #mm/s²
vitesse_virage = 300 #deg/s
acceleration_virage = 100 #deg/s²

robot.settings(vitesse, acceleration_deplacement, vitesse_virage, acceleration_virage)

#On fait avancer le robot de 500mm
robot.straight(500)

Virage avec le gyroscope

#On indique d'utiliser le gyro pour corriger la trajectoire
robot.use_gyro(True)    

#On indique les paramètres de déplacement
vitesse = 300 #mm/s
acceleration_deplacement = 100 #mm/s²
vitesse_virage = 300 #deg/s
acceleration_virage = 100 #deg/s²

robot.settings(vitesse, acceleration_deplacement, vitesse_virage, acceleration_virage)

#On fait tourner le robot de 90 degré dans le sens horaire
robot.turn(90)

#On fait tourner le robot de 180 degrés dans le sens horaire
robot.turn(-180)

#On fait tourner le robot de 90 degrés dans le sens horaire avec un rayon de 100mm
robot.curve(100, 90)

Arrêter le robot

robot.stop()
    

Remettre l'angle et la distance du robot à 0

robot.reset()
        

Angle du robot

#Afficher l'angle du robot dans la console
print(robot.angle())
        

Boussole

#============================================================================
#FONCTION : BOUSSOLE
#============================================================================

def boussole():
    robot.reset()
    while True:
        #Affichage de l'angle sur la matrice
        hub.display.text(str(robot.angle())) 

    
boussole()   
        

3.5Le Robot

Pybricks : Motors with rotation sensors

Déclarer un moteur

#============================================================================
#Moteurs
#============================================================================

moteur = Motor(Port.D)
            

Déclarer un moteur avec paramètres

Vous pouvez déclarer la direction du moteur ainsi que la configuration des engrenages. Avec la configuration des engrenages, il est possible par la suite de faire tourner votre mécanisme de l'angle désiré. Pybrick s'occupe du calcul.

#============================================================================
#Moteurs
#============================================================================

moteur = Motor(Port.D, Direction.CLOCKWISE, gears=[40, 24, 8])
            

Démarrer la rotation du moteur

moteur = Motor(Port.D)

#On démarre la rotation du moteur (vitesse en degré/seconde)
moteur.run(150);
        
            

Effectuer un rotation d'un angle précis ou en secondes

moteur = Motor(Port.D)

#On démarre la rotation du moteur (vitesse en degré/seconde, angle en degré)
moteur.run_angle(150, 150);

#On démarre la rotation du moteur (vitesse en degré/seconde, durée en seconde)
moteur.run_time(150, 1000);
        
            

Type d'arrêt du moteur

moteur = Motor(Port.D)

moteur.run(150)
wait(200)
#Le moteur s'arrête graduellement grâce à la friction
moteur.stop()

moteur.run(150)
wait(200)
#Le moteur s'arrête graduellement grâce à la friction et au voltage généré par le moteur
moteur.brake()

moteur.run(150)
wait(200)
#Le moteur s'arrête net et maintient sa position
moteur.hold()
            

Angle du moteur

moteur = Motor(Port.D)

#Afficher l'angle de rotation du moteur dans la console
print(moteur.angle())
        
            

Réinitialiser l'angle de rotation du moteur

moteur = Motor(Port.D)

moteur.reset_angle(0)
        
            

Activer le moteur jusqu'à ce qu'il soit bloqué.

moteur = Motor(Port.D)

#On fait tourner le moteur jusqu'à ce qu'il bloque (vitesse en degré/s)
moteur.run_until_stalled(150)