Essayons de programmer par étape le suivi de ligne
Affichons le niveau de batterie car si celle-ci est inférieure à un certain niveau, le comportement du robot devient incohérent :
Sous le lancement du MBOT CyberPi crée les variables suivantes :
vitesse_droite : pour gérer la vitesse du moteur EM1
vitesse_gauche : pour gérer la vitesse du moteur EM2
vitesse_maxi : vitesse maximum du robot
vitesse_mini : vitesse moyenne du robot
position : poids de la position du robot par rapport à la ligne noire
correction : correction à appliquer aux moteurs pour suivre la ligne noire
Gestion du bouton B pour lancer le suivi de ligne puis l’arrêter
Tester le bouton B , les leds s’allument en vert puis en rouge
Calcul pour lancer les moteurs en fonction de la position du robot par rapport à la ligne noire
Teste, le robot roule tout droit
Faire tourner le robot
Teste des valeurs de position de -2 à 2 :
Teste le robot pour qu’il tourne plus ou moins à gauche ou à droite
Une première version pour un Suivi de ligne
Plus de détail :
Capteur central pour aller tout droit :
Détail du si :
Et les 4 capteurs du Quad RGB du MBOT :
Teste le suivi de ligne
Tu peux rajouter plus de précision :
Plus de détail sur le rajout :
Modifie le suivi de ligne avec le calcul du PID
derivee : afin de suivre quand le robot passe de gauche à droite de la ligne noire
Kp : pour accentuer ou diminuer pour prendre le angles droits,
1 ne fait rien
< 1 diminue l’angle des virages
> 1 augmente l’angle des virages
Kd : pour empêcher le robot de faire des zigzags
0 ne fait rien
0 à 3 diminuer les zigzags en ligne droite
Tu peux jouer sur ces deux valeurs pour ajuster ton suivi de ligne surtout pour le passage de la ligne en pointillé :
Passage d’un obstacle
Si le robot reste bloqué devant un obstacle, l’objectif est de détecter qu’il est à l’arrêt, et qu’il tente de franchir l’obstacle sans y parvenir.
Ce blocage peut être identifié par un état de secousses répétées pendant une certaine durée. Lorsque le robot est reconnu dans cet état, une stratégie de forçage est déclenchée : le robot recule légèrement, puis effectue une accélération franche vers l’avant afin de franchir l’obstacle.
Puis rajouter l’appel de la fonction dans le code :
Lors de nos participations à la RoboCup Junior, nous avons constaté que notre robot rencontrait des difficultés dans les virages très serrés. Il avait tendance à zigzaguer, à se balancer de gauche à droite et parfois à perdre la ligne, en particulier lorsque celle-ci est en pointillée.
L’année dernière, sur nos mBot 2, nous avons ajouté un capteur central, ce qui a permis d’améliorer le suivi de ligne.
Afin de progresser cette année, nous devons nous reposer plusieurs questions, notamment :
le choix d’une traction avant ou arrière ;
le positionnement des capteurs, afin d’éviter qu’ils ne s’éloignent du sol lors des montées de pente ;
la maîtrise du robot lors des descentes.
Pour résoudre ces problèmes, nous devons revoir :
l’adhérence du robot au sol, en choisissant des pneus en caoutchouc de meilleure qualité ;
le choix d’un suivi de ligne basé sur un calcul PID, afin d’améliorer la stabilité et la précision du robot
Traction avant ou traction arrière : avantages et inconvénients
Le choix entre une traction avant (roues motrices à l’avant) et une traction arrière (roues motrices à l’arrière) a un impact important sur :
le suivi de ligne
la montée et la descente des pentes
l’évitement et le franchissement des obstacles
Traction avant (moteurs à l’avant). les avantages
Bon guidage de la trajectoire
Les roues motrices tirent le robot
Le robot suit plus facilement la direction des capteurs
Intéressant pour le suivi de ligne précis
Meilleur passage des petits obstacles
Les roues motrices montent directement sur l’obstacle
Moins de risque de rester bloqué
Robot plus stable en descente
Le poids vers l’avant aide à garder le contrôle
Moins de risque de « glissade »
Traction avant (moteurs à l’avant). Inconvénients
Moins d’adhérence en montée
Le poids se déplace vers l’arrière
Les roues avant peuvent patiner
Problème d’adhérence sur des pentes fortes (25 %)
Direction plus sensible
Peut surcorriger dans les virages serrés
Demande un réglage PID précis
Traction arrière (moteurs à l’arrière). Avantages
Meilleure adhérence en montée
Le poids du robot repose sur les roues motrices
Très efficace sur les pentes raides (25%)
Robot plus stable en ligne droite
Le robot est “poussé” plutôt que tiré
Moins de patinage
Traction arrière (moteurs à l’arrière). Inconvénients
Suivi de ligne moins précis
Les roues arrière poussent le robot
Risque de dérapage de l’arrière
Virages serrés plus difficiles
Passage d’obstacles plus délicat
Les roues avant ne sont pas motrices
Elles peuvent buter sur l’obstacle
Moins de contrôle en descente
Le robot peut accélérer trop vite
Risque de perte de contrôle, glissade surtout avec les roues bidirectionnelles
Choix d’un suivi de ligne basé sur un calcul PID
Le suivi de ligne simple, qui consiste à tourner à gauche ou à droite selon les capteurs, n’est pas suffisant. Il est nécessaire d’utiliser un système plus précis pour permettre au robot de rester bien centré sur la ligne.
Pourquoi utiliser un calcul PID pour suivre une ligne ?
Le PID est une méthode de calcul utilisée pour corriger automatiquement un mouvement. Le PID (Proportionnel – Intégral – Dérivé) est un algorithme de régulation inventé au début du XXᵉ siècle, notamment grâce aux travaux de Nicolas Minorsky en 1922, lors de l’étude du pilotage automatique des navires, pour aider à guider des bateaux sans les faire osciller.
Aujourd’hui, le PID est utilisé partout :
dans les avions
dans les voitures
dans les robots
dans les machines industrielles
Chaque fois qu’un système doit être stable et précis, on utilise un PID.
Pourquoi le PID est utile pour notre robot ?
Le PID aide le robot à :
mieux prendre les virages
éviter les balancements
suivre la ligne de manière fluide
mieux passer les lignes en pointillée
Grâce aux moteurs avec encodeurs, notre robot avance droit. Nous utilisons donc seulement une partie du PID (P et D), ce qui est suffisant et plus simple.
Conclusion
Le calcul PID permet à notre robot de :
mieux suivre la ligne
être plus stable
être plus performant en compétition
C’est pour cela que nous devons expérimenter ce calcul pour améliorer notre robot en RoboCup Junior.
Quelque indications pour le mettre en œuvre avec le MBOT 2.
Les capteurs disent au robot où est la ligne :
Ligne au centre → erreur = 0
Ligne à gauche → erreur négative
Ligne à droite → erreur positive
Utilise une variable « position » pour affecter un poids d’erreur en fonction des capteurs, voir cet exemple :
Kp accentue proportionnellement l’erreur de positionnement par rapport à la ligne noire, Kp veut dire coefficient proportionnel.
Il sert à dire au robot : « Plus je suis loin de la ligne, plus je corrige fort. »
Si Kp est petit → le robot corrige doucement (il peut sortir de la ligne)
Si Kp est grand → le robot corrige fort (il peut zigzaguer)
Kd – Calmer le robot, Kd veut dire coefficient dérivé. Il va permettre de se remettre bien droit sur la ligne droite suite à des virages, notamment pour que le robot se positionne pour suivre une ligne en pointillée.
Il sert à dire au robot : « Attention, tu corriges trop vite, ralentis un peu. »
Kd faible → le robot zigzague
Kd plus grand → le robot devient plus stable
Kd trop grand → le robot devient lent à réagir
Ensemble : Kp + Kd
Kp fait tourner le robot vers la ligne
Kd empêche le robot de faire des zigzags
Ensemble, ils permettent au robot de :
suivre la ligne correctement
rester stable
passer les virages serrés plus facilement
Comment les régler :
Mettre Kd = 0 au départ
Augmenter Kp jusqu’à ce que le robot suive la ligne
Si le robot zigzague → augmenter Kd
Ajuster jusqu’à obtenir un mouvement fluide.
Configure MBLOCK pour le suivi de ligne
Utilise le bouton extension
Rajoute ces deux éléments :
Premier essai de fonctionnement du MBOT
Premier téléchargement
Teste ton programme
Teste une programmation des moteurs
Teste ton programme
Essayons de programmer par étape le suivi de ligne
Affichons le niveau de batterie car si celle-ci est inférieure à un certain niveau, le comportement du robot devient incohérent :
Sous le lancement du MBOT CyberPi crée les variables suivantes :
vitesse_droite : pour gérer la vitesse du moteur EM1
vitesse_gauche : pour gérer la vitesse du moteur EM2
vitesse_maxi : vitesse maximum du robot
vitesse_mini : vitesse moyenne du robot
position : poids de la position du robot par rapport à la ligne noire
correction : correction à appliquer aux moteurs pour suivre la ligne noire
Gestion du bouton B pour lancer le suivi de ligne puis l’arrêter
Tester le bouton B , les leds s’allument en vert puis en rouge
Calcul pour lancer les moteurs en fonction de la position du robot par rapport à la ligne noire
Teste, le robot roule tout droit
Faire tourner le robot
Teste des valeurs de position de -2 à 2 :
Teste le robot pour qu’il tourne plus ou moins à gauche ou à droite
Une première version pour un Suivi de ligne
Plus de détail :
Capteur central pour aller tout droit :
Détail du si :
Et les 4 capteurs du Quad RGB du MBOT :
Teste le suivi de ligne
Tu peux rajouter plus de précision :
Plus de détail sur le rajout :
Modifie le suivi de ligne avec le calcul du PID
derivee : afin de suivre quand le robot passe de gauche à droite de la ligne noire
Kp : pour accentuer ou diminuer pour prendre le angles droits,
1 ne fait rien
< 1 diminue l’angle des virages
> 1 augmente l’angle des virages
Kd : pour empêcher le robot de faire des zigzags
0 ne fait rien
0 à 3 diminuer les zigzags en ligne droite
Tu peux jouer sur ces deux valeurs pour ajuster ton suivi de ligne surtout pour le passage de la ligne en pointillé :
Passage d’un obstacle
Si le robot reste bloqué devant un obstacle, l’objectif est de détecter qu’il est à l’arrêt, et qu’il tente de franchir l’obstacle sans y parvenir.
Ce blocage peut être identifié par un état de secousses répétées pendant une certaine durée. Lorsque le robot est reconnu dans cet état, une stratégie de forçage est déclenchée : le robot recule légèrement, puis effectue une accélération franche vers l’avant afin de franchir l’obstacle.
Puis rajouter l’appel de la fonction dans le code :
Créer un Folder à votre nom pour mettre toutes vos créations :
Changer la couleur d’un part
local part = script.Parent
part.Touched:Connect(function(hit)
part.BrickColor = BrickColor.random()
part.Material = Enum.Material.Neon
end)
Un part mortel :
local HumanoidFinder = require(game.ReplicatedStorage.HumanoidFinder)
local part = script.Parent
part.Touched:Connect(function(hit)
-- On utilise la fonction du module pour tester
local humanoid, character = HumanoidFinder.Get(hit)
if humanoid then
humanoid:TakeDamage(10)
end
end)
Rendre tout petit le joueur :
local HumanoidFinder = require(game.ReplicatedStorage.HumanoidFinder)
local part = script.Parent
part.Touched:Connect(function(hit)
-- On utilise la fonction du module pour tester
local humanoid, character = HumanoidFinder.Get(hit)
if humanoid then
humanoid.BodyHeightScale.Value = 0.4
humanoid.BodyWidthScale.Value = 0.4
humanoid.BodyDepthScale.Value = 0.4
humanoid.HeadScale.Value = 0.4
end
end)
Faire glisser un part avec un clickDetector :
local part = script.Parent
local clickDetector = part.ClickDetector
clickDetector.MouseClick:Connect(function(player)
part.Anchored = false
part.AssemblyLinearVelocity = Vector3.new(0, 0, 50)
end)
Part pour voler avec un clickDetector :
local AntiGravity = require(game.ReplicatedStorage.AntiGravity)
local part = script.Parent
local clickDetector = part.ClickDetector
clickDetector.MouseClick:Connect(function(player)
part.Anchored = false
AntiGravity.Start(part)
part.AssemblyLinearVelocity = Vector3.new(0, 10, 10)
end)
Téléportation d’un point A à un point B :
local HumanoidFinder = require(game.ReplicatedStorage.HumanoidFinder)
-- Ressource sur le modèle de téléportation
local teleports = script.Parent
-- Récupération des objets sur les plateformes
local teleportA = teleports.TeleportA
local teleportB = teleports.TeleportB
-- Quand un joueur touche la première plateforme,
-- il est téléporté sur la seconde
-- on vérifie qu'il s'agit bien d'un personnage
teleportA.Touched:Connect(function(hit)
local humanoid, character = HumanoidFinder.Get(hit)
if humanoid then
character:PivotTo(CFrame.new(teleportB.Position))
end
end)
Grandir, Sauter, Courir plus vite :
local UserInputService = game:GetService("UserInputService")
local replicatedStorage = game:GetService("ReplicatedStorage")
local runScalePlayer = replicatedStorage:WaitForChild("RunScalePlayer")
local HumanoidFinder = require(replicatedStorage.HumanoidFinder)
local humanoid, character = HumanoidFinder.GetLocal()
local function onKeyPress(input, gameProcessed)
if not humanoid then return end
if input.KeyCode == Enum.KeyCode.F and not gameProcessed then
humanoid.JumpHeight += 8
end
if input.KeyCode == Enum.KeyCode.G and not gameProcessed then
humanoid.JumpHeight -= 8
end
print(input.KeyCode)
if input.KeyCode == Enum.KeyCode.X and not gameProcessed then
humanoid.WalkSpeed += 10
end
if input.KeyCode == Enum.KeyCode.Z and not gameProcessed then
humanoid.WalkSpeed -= 10
end
if input.KeyCode == Enum.KeyCode.Q and not gameProcessed then
runScalePlayer:FireServer(0.5)
end
if input.KeyCode == Enum.KeyCode.E and not gameProcessed then
runScalePlayer:FireServer(-0.5)
end
end
-- Connecter la fonction à l'événement InputBegan
UserInputService.InputBegan:Connect(onKeyPress)
Touches du clavier :
F sauter plus haut
G sauter moins haut
X courir plus vite
W courir moins vite
A grandir
E plus petit
Menu disponible pour le joueur :
local screenGui = script.Parent
local open = screenGui.OpenButton
local screen = screenGui.Screen
local close = screen.CloseButton
local scaleUpPlayer = screen.ScaleUpPlayerButton
local scaleDownPlayer = screen.ScaleDownPlayerButton
local runSlowerPlayer = screen.RunSlowerPlayerButton
local runFasterPlayer = screen.RunFasterPlayerButton
local jumpUpPlayer = screen.JumpUpPlayerButton
local jumpDownPlayer = screen.JumpDownPlayerButton
local replicatedStorage = game:GetService("ReplicatedStorage")
local runScalePlayer = replicatedStorage:WaitForChild("RunScalePlayer")
local runScalePlayer = replicatedStorage:WaitForChild("RunScalePlayer")
local HumanoidFinder = require(replicatedStorage.HumanoidFinder)
local StarterPlayer = game:GetService("StarterPlayer")
local humanoid, character = HumanoidFinder.GetLocal()
screen.Visible = false
open.MouseButton1Click:Connect(function()
screen.Visible = not screen.Visible
open.Visible = not open.Visible
end)
close.MouseButton1Click:Connect(function()
screen.Visible = not screen.Visible
open.Visible = not open.Visible
end)
scaleUpPlayer.MouseButton1Click:Connect(function()
runScalePlayer:FireServer(0.5)
end)
scaleDownPlayer.MouseButton1Click:Connect(function()
runScalePlayer:FireServer(-0.5)
end)
runSlowerPlayer.MouseButton1Click:Connect(function()
humanoid.WalkSpeed -= 10
end)
runFasterPlayer.MouseButton1Click:Connect(function()
humanoid.WalkSpeed += 10
end)
jumpUpPlayer.MouseButton1Click:Connect(function()
humanoid.JumpHeight += 8
end)
jumpDownPlayer.MouseButton1Click:Connect(function()
humanoid.JumpHeight -= 8
end)
Créer une arme fatale :
Créer un objet Tool puis un part renommer Handle :
Pour réduire à l’impuissance vos adversaires :
local HumanoidFinder = require(game.ReplicatedStorage.HumanoidFinder)
local part = script.Parent
part.Touched:Connect(function(hit)
if not hit then return end
local humanoid, character = HumanoidFinder.Get(hit)
if humanoid then
humanoid:TakeDamage(10)
end
end)
Le défi proposé consiste à programmer un robot capable de suivre un couloir au centre, de s’arrêter en fin de couloir, puis de choisir une nouvelle direction en privilégiant une possibilité d’un nouveau couloir à droite.
Le robot est équipé de trois capteurs de collision :
Un capteur avant : détecte la fin du couloir ou un obstacle frontal.
Un capteur latéral droit : permet de rester centré dans le couloir et de vérifier si un passage existe à droite.
Un capteur latéral gauche : même rôle que le droit, mais du côté gauche.
Suivre le couloir au centre
Tant que le capteur avant ne détecte pas la fin du couloir :
le robot avance,
il vérifie la distance avec les murs grâce aux capteurs gauche et droit,
si l’un des murs est trop proche, il s’en éloigne légèrement pour rester centré.
Détection de fin de couloir
Lorsque le capteur avant détecte un obstacle frontal ou l’absence de mur en face :
le robot s’arrête,
il regarde à droite, puis à gauche, pour déterminer s’il existe un nouveau couloir dans l’une de ces directions.
Choix de la direction
Si un passage existe à droite, il tourne à droite et avance.
Sinon, si un passage existe à gauche, il tourne à gauche et avance.
Sinon, aucune direction n’est possible : le robot effectue un demi-tour.
Algorithme simplifié
répéter :
si capteur avant détecte fin du couloir :
arrêter le robot
si côté droit ouvert :
tourner à droite
sinon si côté gauche ouvert :
tourner à gauche
sinon :
faire demi-tour
sinon :
si mur trop proche à droite : se décaler à gauche
sinon si mur trop proche à gauche : se décaler à droite
sinon avancer au centre du couloir
Comment collaborer à plusieurs sur un même projet Roblox Studio
Travailler en équipe dans Roblox Studio permet à l’équipe de créer ensemble un même jeu, en temps réel. Vous apprendrez à vous organiser, à dialoguer, et à partager des responsabilités comme dans un vrai studio de jeux vidéo !
Pourquoi collaborer ?
Les avantages :
L’équipe travaille sur le même projet, en temps réel.
Chaque membre de l’équipe peut utiliser ses points forts : script, construction…
Tous les membres partagent ses idées et se complètent : l’équipe produit un jeu plus riche et mieux pensé.
Vous apprenez à communiquer comme de vrais développeurs.
Les risques si on ne s’organise pas :
Modifier un objet qu’un autre membre est en train de changer peut générer des conflits.
Effacer par erreur le travail d’un autre membre.
Oublier d’enregistrer ou écraser la version des autres.
Règles importantes pour bien travailler en équipe :
Communiquer avant de modifier un élément du jeu.
Ne jamais supprimer un objet sans prévenir.
Toujours sauvegarder régulièrement.
Respecter les rôles définis dans l’équipe (scripteur, designer…).
ATTENTION Un seul membre de l’équipe doit créer le jeu de base
Les deux grandes étapes
Étape 1 — Un membre crée le jeu et ajoute les collaborateurs de l’équipe
Dans chaque équipe, un seul membre crée le projet Roblox Studio.
Ouvre Roblox Studio
Se connecter avec un compte 123codage inscrit sur l’ordinateur : 123codageXX (XX entre 01 et 10 selon le numéro du PC).
Crée un nouveau projet
Choisir Baseplate pour commencer.
Active la collaboration
Dans le menu du haut : Fenêtre → Collaboration → Création en équipe
Un bouton “Sauvegarder sur Roblox” apparaît → clique dessus.
Donne un nom et une description au projet
Vous devez décider en groupe :
le nom du jeu,
une courte description (quel est le but du jeu ?).
Puis clique sur Sauvegarder.
Roblox studio se relance.
Ajoute les collaborateurs
Toujours dans : Fenêtre → Collaboration → Gérer les collaborateurs
Dans la zone de recherche, taper 123codage.
Sélectionner les comptes des membres de l’équipe (par exemple : 123codage01, 123codage05, etc.). → Le numéro du PC est marqué sur la tour.
Pour chaque membre :
Modifier ses droits
Choisir Modifier (autorise à tester et modifier le jeu)
La première étape est terminée ! Tu viens de créer un projet partagé et tu as ajouté les membres de l’équipe.
Étape 2 — Les autres membres ouvrent le projet partagé
Chaque membre de l’équipe doit maintenant accéder au projet :
Tu apprendras à construire un véhicule en utilisant les moteurs CC et le programmer pour le déplacer.
A déplacer ton robot.
A utiliser les moteurs à courant continu.
Tu vas construire un robot véhicule autonome qui va avancer et reculer. Tu programmeras ton robot pour sauver des blessés et les emmener à l’hôpital.
Construis ton robot :
Le tableau des assignations
Clique sur le menu Edition en haut de l’écran et choisis Paramètres des ports. Clique ensuite sur le bouton Tout décocher . Puis indique tous les éléments que tu as rajoutés sur ton robot.
Valide tes modifications en cliquant sur le bouton OK
Programme le moteur à courant continu
Tu vas programmer les deux moteurs à courant continu pour déplacer ton véhicule.
Assemble ces blocs
Puis clique sur le menu Exécuter en haut de l’écran et choisis Transférer Que constates-tu ? Comment se déplace ton véhicule ? Les deux roues tournent-elles ?
Concevoir un mini-projet : un « arbre de Noël » avec 3 LED qui s’allument au claquement de mains.
Liste du matériel
Etape 01 : Le tableau des assignations
Clique sur le menu Edition en haut de l’écran et choisis Paramètres des ports. Clique ensuite sur le bouton Tout décocher . Puis indique tous les éléments que tu as rajoutés sur ton robot.
Cable et valide tes modifications en cliquant sur le bouton OK Attention au positionnement du câble gris sur la carte ARDUINO !!!
Etape 02 : Crée des animations
Tu vas créer 5 animations :
Allume toutes les leds
Eteins toutes les leds
Allume la led0
Allume la led1
Allume la led2
Pour cela tu vas créer 5 fonctions :
TOUTES_LES_LED_ON
TOUTES_LES_LED_OFF
LED0_ON
LED1_ON
LED2_ON
Code les 5 fonctions pour allumer ou éteindre les LEDs en choisissant « on » ou « off ».
Puis testes le fonctionnement des fonctions en mode test :
Après l’affichage du tableau des capteurs clique sur l’étiquette de chaque « Fonction » pour tester l’animation des diffréntes LEDs. Clique sur « Exécuter » puis sur « Activer le test »
Tu animes ton arbre de Noël en cliquant sur chaque fonction.
Etape 02 : Teste le chronomètre
Ta mission : Maintenant, automatises l’animation pour ne plus avoir besoin de cliquer sur chaque animation. Code les animations pour qu’elles se succédent indéfiniment.
Une solution Automatise ton spectacle d’animation lumineux en utilisant le « chronomètre » pour cadencer ton animation. Teste le fonctionnement du « chronomètre ». Dans « Capteurs », coche l’affichage de « chronomètre ».
Utilise le « chronomètre » pour allumer ta LED au bout de 2 secondes.
Agence ces instructions sous « démarrer le programme « Clique sur « Exécuter » puis sur « Activer le test »
Clique sur le drapeau vert en haut à droite de l’écran pour lancer l’exécution de ton programme.
Un bord blanc apparaît pour indiquer que le programme s’exécute. Que constates-tu ? Le chronomètre evolue-t-il ? La LED s’allume-t-elle ? Le bord blanc disparait-il ?
La LED s’allume et le bord blanc disparaît au bout de 2 secondes.
Etape 03 : Automatise tes animations
Ta mission : Fais clignoter ta LED toutes les secondes. Pour cela, crée une variable « ANIMATION ». Elle prendra les valeurs suivantes :
0 éteinte
1 allumée
Toutes les secondes la variable ANIMATION passe de la valeur 0 à 1, la LED s’allume et s’éteint ainsi toutes les secondes.
Clique sur le menu Exécuter en haut de l’écran puis choisis Transférer
Utilise les animations que tu avais crées pour utiliser plusieurs LEDs :
Clique sur le menu Exécuter en haut de l’écran puis choisis Transférer
Tu peux améliorer ton code pour le rendre plus lisible :
Crée une fonction INIT pour regrouper les instructions au lancement de ton programme :
Ton code est ainsi plus facile à comprendre.
Clique sur le menu Exécuter en haut de l’écran puis choisis Transférer
Etape 04 : Encore plus d’animations
Continue à améliorer ton animation des LEDs. Allume les trois LEDs, puis la LED0, puis la LED1, puis la LED2.
Tu peux inventer autant d’animations que tu souhaites. A toi d’être imaginatif, tu peux faire varier la variable ANIMATION à plus de 4 animations. A toi de trouver les animations et de faire attention à modifier dans la fonction INIT le nombre maximum d’animation.
Code tes animations puis clique sur le menu Exécuter en haut de l’écran puis choisis Transférer
Etape 05 : Commande tes animations d’un clap de main
Code pour que ton spectacle se lance par un clap des mains puis s’arrête par un nouveau clap des mains. Le son de ton clap de main dure un certain temps. Les instructions suivantes te permettent de détecter un son puis de détecter quand le son se termine :
Il est important d’attendre que le son du claquement de mains soit terminé. Sinon, ton programme risque de détecter un nouveau claquement alors que le premier n’est pas encore fini !
À chaque claquement de mains, ton robot allume ou éteint les LED.
Maintenant programme pour que sur un clap des mains le spectacle de lumière se lance puis tu peux l’arrêter par un nouveau clap des mains. Ton spectacle doit être magnifique, faire clignoter toutes les LEDs en même temps, les faire clignoter successivement …
Crée une variable « ON » qui va mémoriser l’état de ton animation :
1 en fonctionnement
0 éteinte
Puis une fonction qui teste le microphone pour allumer ou éteindre l’animation :
Insère ta fonction « SI_ON » dans le code principal et conditionne le lancement de ton animation en fonction de la variable « ON ».
Clique sur le menu Exécuter en haut de l’écran puis choisis Transférer
Tu vas construire et programmer un feu de circulation nouvelle génération ! Ta mission : aider le gouvernement à simplifier les feux pour réduire la consommation d’énergie tout en assurant la sécurité de tous les usagers.
🚦 Ce que tu vas apprendre
À monter un circuit avec 4 LEDs, un capteur de pression et une alarme sonore.
À programmer un feu de circulation en gérant le temps et les conditions de passage.
À utiliser des notions essentielles en programmation :
VARIABLES : pour mémoriser des informations (ex. : état du feu).
FONCTIONS : pour rendre ton code plus clair et plus facile à modifier.
À faire des choix logiques pour assurer la sécurité des piétons et des véhicules.
🕹️ Découvrir le rôle des couleurs
Couleur
Signification
Action attendue
🟢 Vert
Passage autorisé
Les voitures roulent
🟡 Orange
Attention, changement
Prépare à s’arrêter
🔴 Rouge
Passage interdit
Les voitures s’arrêtent
Mais… ton défi est de supprimer une couleur ! Tu devras donc imaginer une nouvelle logique à deux couleurs :
🧠 Ta mission
Le gouvernement français souhaite réaliser des économies d’énergie. Tu dois créer un feu bicolore intelligent (vert + rouge) capable de :
Réguler la circulation des véhicules.
Avertir avant le passage au rouge grâce au clignotement.
Laisser passer les piétons avec un capteur de pression (bouton).
Activer une alarme quand un piéton peut traverser.
🧩 Matériel nécessaire
1 carte microcontrôleur
4 LEDs (rouge, verte)
1 capteur de pression ou bouton poussoir
1 buzzer ou alarme sonore
Clique sur le menu Edition en haut de l’écran et choisis Paramètres des ports. Clique ensuite sur le bouton Tout décocher . Puis indique tous les éléments que tu as rajoutés sur ton robot.
LED A0 Vert pour véhicule
LED A1 Rouge pour véhicule
LED A2 Vert pour piéton
LED A3 Rouge pour piéton
Cable et valide tes modifications en cliquant sur le bouton OK
Etape 01 : gère le passage des véhicules
Dans un premier temps, tu devras allumer la LED verte pour avertir les automobilistes qu’ils peuvent passer, puis, après un certain délai, allumer la LED rouge pour interdire le passage des véhicules.
Assemble les blocs puis clique sur le menu Exécuter en haut de l’écran et choisis Transférer
Etape 03 : Faire clignoter pour avertir
Tu devras faire clignoter la LED verte pour avertir les automobilistes que le feu va passer au rouge et qu’ils doivent se préparer à arrêter leur véhicule.
Assemble les blocs puis clique sur le menu Exécuter en haut de l’écran et choisis Transférer.
Etape 04 : Amélioration de ton code
En utilisant des fonctions, tu vas réorganiser ton code pour le rendre plus lisible et faciliter son évolution..
Assemble les blocs puis clique sur le menu Exécuter en haut de l’écran et choisis Transférer
Les fonctions permettent de regrouper plusieurs blocs qui réalisent une même action (par exemple : « attention_vehicule »). Elles évitent de répéter le même code plusieurs fois, ce qui rend le programme plus court et plus clair. Elles facilitent la lecture du programme, car chaque fonction porte un nom qui décrit son rôle. Elles rendent le code plus facile à modifier ou à corriger, car une seule modification dans la fonction s’applique partout. Enfin, elles aident à mieux organiser sa pensée comme un vrai programmeur, en découpant le problème en petites étapes logiques.
Etape 05 : Gérer le passage pieton
Tu vas gérer les LEDs verte et rouge du piéton en fonction de celles du passage des véhicules.
Tu vas gérer le passage piéton :
quand les véhicules ont l’autorisation de passer, le piéton doit attendre ;
quand les véhicules sont à l’arrêt, le piéton peut traverser.
Clique sur le menu Exécuter en haut de l’écran et choisis Transférer
Etape 06 : Faire clignoter pour avertir le piéton
Tu vas faire clignoter la LED verte du piéton pour l’avertir que le feu va bientôt passer au rouge.
Clique sur le menu Exécuter en haut de l’écran et choisis Transférer
Etape 07 : Avertissement sonore pour les piétons non-voyants
Tu vas déclencher le buzzer lorsque les piétons peuvent passer pour avertir les personnes non-voyantes.
Clique sur le menu Exécuter en haut de l’écran et choisis Transférer
Etape 08 : Gérer les temps d’attentes
Nous allons utiliser des variables pour fixer des temps d’attente différents : un pour les conducteurs et un autre pour les piétons.
Clique sur le menu Exécuter en haut de l’écran et choisis Transférer
Les variables sont comme des boîtes dans lesquelles on peut ranger des informations (par exemple un nombre, le temps d’attente en seconde). Elles permettent au programme de mémoriser des données et de s’en servir plus tard. Grâce aux variables, ton programme peut changer de comportement selon la situation (par exemple, attendre plus ou moins longtemps). Elles rendent le code plus facile à comprendre et à modifier, car il suffit de changer la valeur d’une variable pour tout adapter. En résumé, les variables servent à donner de la mémoire et de la souplesse à ton programme.
Etape 09 : Gérer une demande d’un piéton
Pendant la phase d’attente, le piéton pourra demander l’arrêt des véhicules pour traverser en toute sécurité. Le piéton devra appuyer sur le capteur de pression pour obtenir l’autorisation de passer.
La demande du piéton sera traitée pendant sa phase d’attente au feu rouge. Tu utiliseras un chronomètre pour compter le temps d’attente du piéton tout en vérifiant si le capteur de pression est activé. Si le piéton appuie sur le capteur, sa valeur sera égale à zéro. Tu laisseras ensuite un petit temps supplémentaire pour que les voitures puissent encore passer avant que le feu piéton ne devienne vert.
Clique sur le menu Exécuter en haut de l’écran et choisis Transférer
GERTRUDE
Un exemple de service de la gestion de la circulation
Gertrude Saem a été créée en 1981 par la Communauté Urbaine de Bordeaux avec l’objectif de développer un système d’avant-garde pour améliorer ou résoudre les problèmes de circulation, de transport publics, de contrôle et de diminution de la pollution véhiculaire et de sécurité dans la ville. Le principe est de minimiser les temps d’attente en synchronisant les feux sur les grands axes, en fonction du trafic. Des installations comptent les véhicules ou les longueurs des files d’attente (boucles magnétiques implantées dans la chaussée, aux carrefours et sur les axes), et le tout est centralisé à un poste de commande, qui régule informatiquement les feux de la ville ou de l’agglomération et fluidifie ainsi le trafic.
GERTRUDE EN FRANCE Antibes, Bordeaux, Brive, Caen, Dax, Dunkerque, Fort-de-France, Le Mans, Marseille, Metz, Mimizan, Mont de Marsan, Montpellier, Nîmes, Reims, Troyes, Saint-Vincent-de-Tyrosse, SDEC du Calvados.
UN SAVOIR-FAIRE ET DES SOLUTIONS QUI S’EXPORTENT DANS LE MONDE Algérie (Alger), Argentine (Posadas), Chine (Pékin), Egypte (Le Caire), Maroc (Casablanca), Mexique (Monterrey, Morelia), Paraguay (Asuncion), Pologne (Wroclaw), Portugal (Lisbonne, Porto).
Tu as déjà appris les bases de Python et tu veux aller plus loin ? Avec la micro:bit, tu vas coder des jeux, des calculatrices, des capteurs, et bien plus encore. Tu vas manipuler des boucles, des fonctions, des événements, et même des conversions de bases (binaire, hexadécimal, etc.) — des compétences utiles pour le lycée, les études, et même dans le monde professionnel. La micro:bit interagit avec le monde réel grâce à ses boutons, ses capteurs et son écran LED. Tu pourras voir le résultat de ton code en temps réel !
Partie 01 : Découverte des tables en Python
Apprendre à utiliser et manipuler des tables (ou listes) en Python, en affichant une séquence de chiffres ou d’images sur l’écran de la micro:bit.
Une table en Python s’écrit entre crochets : [ ].
Les éléments sont séparés par des virgules.
Pour afficher une image, utilise Image.NOM_DE_L_IMAGE (ex : Image.SMILE).
from microbit import *
while True:
all_images = [str(1), str(2), str(3)]
display.show(all_images, delay=300)
Modifie le programme suivant pour qu’il affiche, dans l’ordre, les chiffres de 1 à 5 sur l’écran de la micro:bit, avec un délai de 300 ms entre chaque chiffre.
Comprendre la table all_images Actuellement, la table all_images contient les chaînes de caractères "1", "2" et "3". Question : Comment faire pour qu’elle contienne les chiffres de 1 à 5 ?
Modifier la table Ajoute les chiffres manquants ("4" et "5") dans la table all_images.
Tester le programme Télécharge ton programme sur la micro:bit et vérifie que les chiffres défilent bien de 1 à 5.
Personnalisation (défis bonus !)
Défi 1 : Fais défiler les chiffres de 5 à 1.
Défi 2 : Crée ta propre table avec des motifs ou des lettres (ex : "A", "B", "C").
Défi 3 : Remplace les chiffres par des images (ex : Image.HAPPY, Image.SAD, Image.HEART).
Partie 02 : Chronomètre avec la micro:bit – booléens et gestion du temps
Découvrir le fonctionnement d’une variable booléenne (True/False) et la gestion du temps en Python, en créant un chronomètre qui se lance et s’arrête quand on touche le logo de la micro:bit
from microbit import *
import time
start = 0
triggered = False
while True:
if pin_logo.is_touched():
triggered = not triggered
while pin_logo.is_touched():
start = time.ticks_ms()
else:
if triggered :
display.scroll(int((time.ticks_ms() - start)/1000))
else:
display.show(Image.HEART)
Comprendre la variable booléenne triggered
triggered vaut False au début : le chronomètre est arrêté.
Quand on touche le logo, triggered devient True (chronomètre lancé), et redevient False si on retouche le logo (chronomètre arrêté).
Question : Que fait l’instruction triggered = not triggered ?
Lancer et arrêter le chronomètre
Si triggered est True, le chronomètre doit compter les secondes.
Si triggered est False, le chronomètre doit s’arrêter.
Afficher le temps écoulé
Utilise time.ticks_ms() pour mesurer le temps en millisecondes.
Convertis ce temps en secondes et affiche-le sur l’écran.
Tester le programme
Télécharge ton programme sur la micro:bit.
Vérifie que le chronomètre se lance et s’arrête bien en touchant le logo.
Chronomètre lancé :
Défis bonus
Défi 1 : Ajoute un bouton pour remettre le chronomètre à zéro.
Défi 2 : Lance une musique toutes les secondes.
Défi 3 : Lance une musique toutes les 10 secondes.
from microbit import *
import time
import music
start = 0
triggered = False
while True:
if pin_logo.is_touched():
triggered = not triggered
while pin_logo.is_touched():
start = time.ticks_ms()
elif button_a.is_pressed():
while button_a.is_pressed() :
start = time.ticks_ms()
else:
if triggered :
duration = int((time.ticks_ms() - start)/1000)
music.pitch(200, 50)
if (duration % 10) == 0:
music.pitch(300, 80)
display.scroll(duration)
else:
display.show(Image.HEART)
Partie 01 : Convertisseur décimal
Consigne : Écrire un programme Python qui demande à l’utilisateur de saisir un nombre entier décimal, puis affiche sa représentation en base dans une base de 2 à 36.
Exemple : Pour une conversion en base 16 (hexadécimal), si l’utilisateur saisit 10, le programme doit afficher E.
Indices pour réussir l’exercice
Comprendre par exemple pour la base 16 : En hexadécimal, on utilise les chiffres de 0 à 9 et les lettres A à F pour représenter les valeurs de 10 à 15.
Méthode de conversion : Pour convertir un nombre décimal en hexadécimal, on divise successivement le nombre par 16 et on garde le reste de chaque division.
Utilisation des restes : Chaque reste correspond à un chiffre hexadécimal, mais il faut les lire à l’envers à la fin.
Gestion des lettres : Si un reste est égal à 10, 11, 12, 13, 14 ou 15, il faut le remplacer par A, B, C, D, E ou F.
Exemple de programme :
from microbit import display, Image, button_a, pin_logo
# base donnée (2 ≤ base ≤ 36)
digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
base = 16
def decimal_to_base_n(decimal_num, base):
"""
Convertit un nombre décimal (int) dans une base donnée (2 ≤ base ≤ 36).
Retourne une chaîne représentant le nombre dans la base souhaitée.
"""
if base < 2 or base > 36:
raise ValueError("La base doit être comprise entre 2 et 36.")
result = []
if decimal_num == 0:
return "0"
decimal_num = abs(decimal_num)
while decimal_num > 0:
# Obtenir le reste de la division entière du nombre par la base
remainder = decimal_num % base
result.append(digits[remainder])
decimal_num = decimal_num // base
return ''.join(reversed(result))
# Addition de deux nombres
i = 0
display.show(Image.PACMAN)
while True:
# Résultat de l'addition
if pin_logo.is_touched():
display.show("=" + decimal_to_base_n(i, base))
i = 0
while pin_logo.is_touched():
pass
# Choix d'un nombre avec le bouton A
elif button_a.is_pressed():
i = i+1
display.show(str(i))
while button_a.is_pressed() :
pass
Choisis avec le bouton A le chiffre 10 :
Convertis le chiffre 10 en décimal en base 16 avec la zone sensitive :
Partie 02 : Calculette de programmeur
Tu vas programmer une micro:bit pour qu’elle fonctionne comme une calculette permettant d’additionner deux nombres dans une base choisie (entre 2 et 36). Par exemple, si la base est 16, tu pourras additionner deux chiffres hexadécimaux (comme A + 5 = F).
Consignes
Reprend la Fonction de conversion de l’exercice précédent decimal_to_base_n(decimal_num, base) qui convertit un nombre décimal en une chaîne de caractères représentant ce nombre dans la base choisie.
Exemple : decimal_to_base_n(15, 16) doit retourner "F".
Choix de la base La variable base est déjà initialisée à 16, mais tu pourras la changer pour tester d’autres bases (entre 2 et 36).
Sélection des nombres
Appuie sur le bouton A pour incrémenter le premier nombre (i) et l’afficher.
Appuie sur le bouton B pour incrémenter le deuxième nombre (j) et l’afficher.
Les nombres doivent rester inférieurs à la base choisie.
Affichage du résultat
Touche le logo de la micro:bit pour afficher le résultat de l’addition i + j dans la base choisie, sous la forme =X (où X est le résultat de l’addition de i + J).
Réinitialisation Après chaque calcul, les nombres i et j doivent être remis à zéro.
from microbit import display, Image, button_a, button_b, pin_logo
# base donnée (2 ≤ base ≤ 36)
digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
base = 16
def decimal_to_base_n(decimal_num, base):
"""
Convertit un nombre décimal (int) dans une base donnée (2 ≤ base ≤ 36).
Retourne une chaîne représentant le nombre dans la base souhaitée.
"""
if base < 2 or base > 36:
raise ValueError("La base doit être comprise entre 2 et 36.")
result = []
if decimal_num == 0:
return "0"
decimal_num = abs(decimal_num)
while decimal_num > 0:
# Obtenir le reste de la division entière du nombre par la base
remainder = decimal_num % base
result.append(digits[remainder])
decimal_num = decimal_num // base
return ''.join(reversed(result))
# Addition de deux nombres
i = 0
j = 0
display.show(Image.PACMAN)
while True:
# Résultat de l'addition
if pin_logo.is_touched():
display.show("=" + decimal_to_base_n(i+j, base))
i, j = 0, 0
while pin_logo.is_touched():
pass
# Choix d'un nombre avec le bouton A
elif button_a.is_pressed():
i = i+1 if i < base-1 else 0
display.show(digits[i])
while button_a.is_pressed() :
pass
# Choix du deuxième nombre par la touche B
elif button_b.is_pressed():
j = j+1 if j < base-1 else 0
display.show(digits[j])
while button_b.is_pressed() :
pass
Choix du premier nombre par la touche A :
Choix du deuxième nombre par la touche B :
Demande le résultat de la somme par la zone sensitive :
