Auteur/autrice : Patrick Gelinaud

ROBOCUP 2026

Auteur de l’article Par Patrick Gelinaud
Date de l’article 7 janvier 2026

Finale régionale	14 mars 2026	INP
Finale nationale	30 et 31 mai 2026	Bordeaux (France)
Finale européenne	du 1er au 5 juin 2026	Vienne (Autriche)

Règlement général ROBOCUP JUNIOR

Règlement RESCUE LINE

Règlements des différentes ligues ACAdémie de paris

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 :

la formule du PID est la suivante :

correction = (Kp × erreur) + (Kd × variation de l’erreur)

vitesse_gauche = vitesse_mini + (correction * vitesse_mini)
vitesse_droit = vitesse_mini – (correction * vitesse_mini)

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.

Modélisation 3D

PREMIERS PAS ONSHAPE

Auteur de l’article Par Patrick Gelinaud
Date de l’article 6 janvier 2026

Visualisation de la vidéo pour la construction d’une roue en 3D :

https://youtu.be/TgZ3qs0dCtU

Lancement de ONSHAPE

Jeu vidéo ROBLOX

Découverte mon premier jeu ROBLOX

Auteur de l’article Par Patrick Gelinaud
Date de l’article 19 décembre 2025

Se téléporter d’un point a à b

grandir sauter courir plus

menu pour le joueur

une arme fatale

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)

MBOT Robotique

Programmer un robot suiveur de couloir et explorateur de labyrinthe

Auteur de l’article Par Patrick Gelinaud
Date de l’article 5 décembre 2025

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

Le code sous mBlock :

Pour aller tout droit dans le couloir :

Pour choisir sa direction :

Jeu vidéo ROBLOX

Comment activer le mode collaboration sur un projet Roblox

Auteur de l’article Par Patrick Gelinaud
Date de l’article 30 novembre 2025

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 :

➤1. Ouvre le site Roblox Hub

Dans un navigateur Hub Création Roblox :
https://create.roblox.com/

Vérifie que tu es connecté avec

Le login doit être 123codageXX (ton numéro de PC).

Ouvre les créations

Clique sur Créations dans le menu à gauche.

Va dans “Partagé avec moi”

Tu devrais voir le projet créé par le membre de ton équipe.

Ouvre le projet dans Studio

Cliquer sur le jeu
Choisir Modifier dans Studio

Vérifie que la collaboration est active

Lorsque Roblox Studio s’ouvre :
Dans “Création en équipe”, tu dois voir tous les membres connectés.

Vous pouvez maintenant collaborer en temps réel !

Vous êtes prêts à travailler comme de vrais développeurs Roblox !

En respectant une bonne organisation et en communiquant régulièrement, vous pourrez créer ensemble un jeu original, complet et cohérent.

Rouler de A vers B

Auteur de l’article Par Patrick Gelinaud
Date de l’article 20 novembre 2025

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 ?

ALGORA Niveau 01 Robotique

Arbre de Noël

Auteur de l’article Par Patrick Gelinaud
Date de l’article 1 novembre 2025

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

ALGORA Niveau 01 Robotique

ALLGORA : trafic routier

Auteur de l’article Par Patrick Gelinaud
Date de l’article 1 novembre 2025

Tu dois inventer une nouvelle signalisation

🎯 Objectif du projet

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).

Voir la vidéo de présentation

MICRO PYTHON MICRO:BIT

Python avancé avec la micro:bit

Auteur de l’article Par Patrick Gelinaud
Date de l’article 31 octobre 2025

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).

Crée une animation graphique :

from microbit import *

while True:
    image1 = Image("99999:"
                  "90009:"
                  "90009:"
                  "90009:"
                  "99999")
    image2 = Image("00000:"
                   "09990:"
                   "09090:"
                   "09990:"
                   "00000")
    image3 = Image("00000:"
                   "00000:"
                   "00900:"
                   "00000:"
                   "00000")
    image4 = Image("00000:"
                   "00000:"
                   "00000:"
                   "00000:"
                   "00000")
    image5 = Image("99999:"
                  "99999:"
                  "99999:"
                  "99999:"
                  "99999")
    all_images = [image1, image2, image3, image4, image5]
    display.show(all_images,delay=300)

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 :