Créer un portique de chronométrage pour mesurer le temps mis par un robot suiveur de ligne pour parcourir un circuit. Le portique détecte le passage du robot grâce à des capteurs infrarouges et affiche le temps sur l’écran du microcontrôleur UNIHIKER.
Le robot passe une première fois sous le portique au départ, puis une deuxième fois à l’arrivée.
Premier passage : démarrage du chronomètre.
Deuxième passage : arrêt du chronomètre.
Les composants du portique
Élément
Rôle
Description
🧠 Microcontrôleur UNIHIKER
Le cerveau du portique
Il gère les capteurs, mesure le temps et affiche les résultats sur son écran.
👀 Deux capteurs photoréflecteurs IR
Détecter le robot
Placés en vis-à-vis de chaque côté du portique, ils détectent quand le robot passe (interruption du faisceau).
💡 LED verte
Indiquer que le portique est prêt
Allumée : le portique attend le départ du robot.
🔴 LED rouge
Indiquer la mesure en cours
Allumée : le portique mesure le temps du parcours.
📺 Écran intégré à l’UNIHIKER
Affichage du résultat
Montre le message “Prêt”, “Course en cours…” et le temps mesuré.
Le portique attend le robot (LED verte). Le robot passe une première fois → démarrage du chrono. Le robot passe une deuxième fois → arrêt du chrono et affichage.
Programmation de l’interface
Détail des instructions pour l’affichage du temps :
Lance pour vérifier l’affichage
Programmation de la détection des passages
⚙️ Principe de détection du robot par le portique
🔦 1. Comment le portique détecte le passage du robot
Le portique utilise un photoréflecteur infrarouge. C’est un petit capteur qui envoie de la lumière invisible (infrarouge) et mesure la lumière qu’il reçoit en retour.
Quand rien ne passe, la lumière rebondit normalement : 👉 le capteur reçoit beaucoup de lumière.
Quand le robot passe devant, il bloque ou réfléchit moins la lumière : 👉 le capteur reçoit moins de lumière.
C’est ce changement de niveau de lumière que le portique utilise pour savoir qu’un robot vient de passer.
🧠 2. La variable mesure_en_cours
Pour que le portique sache s’il doit démarrer ou arrêter le chronomètre, on utilise une variable mémoire qu’on appelle ici :
Cette variable peut prendre deux valeurs :
Valeur
Signification
État du portique
0
Attente du robot au départ
Portique prêt, LED verte allumée
1
Chronométrage en cours
LED rouge allumée, le portique mesure le temps
⏱️ 3. Les deux passages du robot
🟢 Premier passage : le départ
Le portique attend (mesure_en_cours = 0).
Le robot passe → le capteur détecte un changement de lumière.
Le portique :
allume la LED rouge,
met mesure_en_cours = 1,
attente que le véhicule passe.
🔴 Deuxième passage : l’arrivée
Le robot repasse sous le portique.
Le capteur détecte à nouveau un changement de lumière.
Le portique :
rallume la LED verte,
remet mesure_en_cours = 0 (prêt pour une nouvelle mesure),
attente que le véhicule passe.
Le programme avec la détection et le comptage des passages :
Lance pour vérifier
Programmation du chronomètre
🟢 Premier passage : le départ
démarre le chronomètre,
⏱️ Affichage du temps
affiche le temps sur l’écran,
Lance pour vérifier
Programmation en python
Bibliothèques conseillées
import time import math from unihiker import GUI from pinpong.board import Board,Pin from pinpong.extension.unihiker import *
Objets à instancier # Interfaces u_gui=GUI() # Micro contrôleur Board().begin()
# Photo réflecteur IR sur le port P1 p_p1_analog=Pin(Pin.P1, Pin.ANALOG)
# LED rouge p_p14_out=Pin(Pin.P14, Pin.OUT)
# LED verte p_p15_out=Pin(Pin.P15, Pin.OUT)
# Lecture du photo réflecteur IR lumiere = p_p1_analog.read_analog()
# Gestion des LEDs p_p14_out.write_digital(0) p_p15_out.write_digital(1)
# Affichage du chronomètre mm = 0 ss = 0 chrono=u_gui.draw_clock( h=mm,m=0,s=ss, x=120,y=200,r=50, color= »#0000FF ») text_chrono = u_gui.draw_text( text= »Temps= »+ str(mm).zfill(2)+ »: »+str(ss).zfill(2), x=20,y=260, font_size=20, color= »#0000FF »)
# Affichage d’un texte u_gui.draw_text( text= »texte à afficher », x=40,y=25, font_size=20, color= »#0000FF »)
# Dessin d’une surface rectangle u_gui.fill_rect(x=5,y=5,w=230,h=90,color= »#CCFFFF »)
# Dessin d’un pourtour d’un rectangle u_gui.draw_rect(x=0,y=0,w=240,h=100,width=10,color= »#FF0000″)
# Gestion du temps (pour le chrono) # Récupération du temps start = time.time() # Calcul d’une durée en minutes et secondes duree = int(time.time() – start) mm = int(duree / 60) ss = int(duree – (mm * 60))
# Exemple pour l’affichage du temps chrono.config(h=mm,m=0,s=ss) text_chrono.config(text= »Temps= »+str(mm).zfill(2)+ »: »+str(ss).zfill(2))
Comment utiliser LinearVelocity, VectorForce et AssemblyLinearVelocity pour lancer ou faire bouger des objets. Comment utiliser HingeConstraint pour faire ouvrir une barrière. Comment construire une voiture et la piloter
LinearVelocity, VectorForce et AssemblyLinearVelocity — servent tous à faire bouger des objets dans Roblox, mais ils ne fonctionnent pas du tout de la même manière.
LinearVelocity
Ce que ça fait : ➡️ Fait bouger un objet à une vitesse constante dans une direction. ➡️ Roblox s’occupe automatiquement de calculer la force nécessaire pour maintenir cette vitesse.
C’est parfait pour :
Faire voler ou propulser un objet
Tirer des projectiles
Donner un mouvement stable et constant
VectorForce
Ce que ça fait : ➡️ Applique une force brute (comme une poussée de moteur ou la gravité). ➡️ La vitesse dépend de la masse de l’objet et des forces qui s’opposent.
L’objet est poussé mais ralentit ou accélère selon sa masse, sa friction, etc.
C’est parfait pour :
Simuler une propulsion physique réaliste
Faire un jetpack, un vent, une poussée de moteur
Ajouter une force continue (comme la gravité personnalisée)
AssemblyLinearVelocity
Ce que ça fait : ➡️ Change directement la vitesse actuelle du corps rigide complet. ➡️ C’est comme “modifier” la vitesse sans appliquer de vraie force.
L’objet prend instantanément cette vitesse. Pas de physique calculée, pas de force — juste une vitesse imposée.
📍 C’est parfait pour :
Faire bouger instantanément un objet
Lancer un objet d’un coup
Remettre à zéro sa vitesse facilement
Crée une balle à lancer
Crée une balle à partir de l’onglet Modèle puis Pièce et Sphère :
Renomme le part en « Balle » :
Change les propriétés suivantes du part Balle :
Déplace le part Balle sous ServerStorage :
ServerStorage permet de stocker des objets secrets ou internes au serveur (comme des scripts, modèles ou outils que les joueurs ne doivent pas voir directement). Donc la conséquence immédiate du déplacement de la balle : celle-ci n’est plus visible dans ton jeu, ni dans ton workspace.
Programme un lancer avec linearVelocity :
VectorVelocity fait bouger ta balle à une vitesse constante dans la direction du regard du joueur.
La balle rouge bouge sans la contrainte de la physique du jeu, notamment de la gravité.
Crée un script sous ServerScriptService et lance les balles devant le joueur :
-- je récupère la balle dans le ServerStorage
local ss = game:GetService("ServerStorage")
local balle= ss:WaitForChild("Balle")
-- je récupère la liste des jueurs
local players = game:GetService("Players")
-- je lance la blle avec linearVelocity
local function linearVelocityBall(player)
-- je récupère le corps du joueur
local char = player.Character or
player.CharacterAdded:Wait()
local hrp = char:WaitForChild("HumanoidRootPart")
-- Je génère une copie de la balle dans le workspace
local ball = balle:Clone()
ball.BrickColor = BrickColor.Red()
ball.Parent = workspace
ball.CFrame = hrp.CFrame * CFrame.new(0, 2, -2)
-- J'applique à la balle une force constante
local lv = Instance.new("LinearVelocity")
lv.MaxForce = math.huge
lv.VelocityConstraintMode =
Enum.VelocityConstraintMode.Vector
lv.VectorVelocity = hrp.CFrame.LookVector * 5
lv.Parent = ball
-- J'attache cette force à la balle
local attchment = Instance.new("Attachment")
attchment.Parent = ball
lv.Attachment0 = attchment
-- Je détruis la balle au bout de 5 secondes
game.Debris:AddItem(ball, 5)
end
-- Le joueur se connecte
players.PlayerAdded:Connect(function(player)
player.CharacterAdded:Connect(function()
for i = 1, 5 do
task.wait(1)
linearVelocityBall(player)
end
end)
end)
VectorVelocity fait bouger ta balle à une vitesse constante dans la direction du regard du joueur.
L’objet bouge sans que tu aies besoin de gérer la physique.
Ton script instancie un Attachment. Un Attachment est un point de repère invisible dans une pièce (Part, MeshPart, etc.) C’est comme une punaise virtuelle que tu peux placer n’importe où dans la pièce.
🔹 Il sert à :
indiquer un point précis où appliquer une force, un effet, ou une jointure,
ou relier deux objets ensemble (LinearVelocity, VectorForce).
L’objet bouge sans que tu aies besoin de gérer la physique.
Programme un lancer avec vectorForce:
Applique une force brute (comme une poussée de moteur ). La vitesse dépend de la masse de l’objet et des forces qui s’opposent. La belle bleue est poussée mais ralentit ou accélère selon sa masse, sa friction et subit la gravité.
Modifie ton script pour le lancer avec une balle bleue :
local function vectorForceBall(player)
-- je récupère le corps du joueur
local char = player.Character or player.CharacterAdded:Wait()
local hrp = char:WaitForChild("HumanoidRootPart")
-- Je génère une copie de la balle dans le workspace
local ball = balle:Clone()
ball.BrickColor = BrickColor.Blue()
ball.Parent = workspace
ball.CFrame = hrp.CFrame * CFrame.new(0, 2, -2)
-- J'applique à la balle un VectorForce
local vf = Instance.new("VectorForce")
vf.RelativeTo = Enum.ActuatorRelativeTo.World
vf.ApplyAtCenterOfMass = true
vf.Force = hrp.CFrame.LookVector * ball:GetMass() * 5
vf.Parent = ball
-- J'attache cette force à la balle
local attchment = Instance.new("Attachment")
attchment.Parent = ball
vf.Attachment0 = attchment
-- Je détruis la balle au bout de 5 secondes
game.Debris:AddItem(ball, 5)
end
players.PlayerAdded:Connect(function(player)
player.CharacterAdded:Connect(function()
for i = 1, 5 do
task.wait(1)
linearVelocityBall(player)
task.wait(1)
vectorForceBall(player)
end
end)
end)
Programme un lancer avec AssemblyLinearVelocity
La balle verte prend instantanément la vitesse appliquée. Pas de physique calculée, pas de force — juste une vitesse imposée
Modifie ton script :
local function assemblyLinearVelocityBall(player)
-- je récupère le corps du joueur
local char = player.Character or player.CharacterAdded:Wait()
local hrp = char:WaitForChild("HumanoidRootPart")
-- Je génère une copie de la balle dans le workspace
local ball = balle:Clone()
ball.BrickColor = BrickColor.Green()
ball.Parent = workspace
ball.CFrame = hrp.CFrame * CFrame.new(0, 2, -2)
-- J'applique une vitesse à l'objet
ball.AssemblyLinearVelocity = hrp.CFrame.LookVector *
ball:GetMass() * 5
-- Je détruis la balle au bout de 5 secondes
game.Debris:AddItem(ball, 5)
end
players.PlayerAdded:Connect(function(player)
player.CharacterAdded:Connect(function()
task.wait(5)
for i = 1, 5 do
task.wait(1)
linearVelocityBall(player)
task.wait(1)
vectorForceBall(player)
task.wait(1)
assemblyLinearVelocityBall(player)
end
end)
end)
PARTIE 02 : Une barrière
Avant de commencer à construire ta barrière, choisis ces options pour ton projet :
Construction d’une barrière
Puis commence à construire ta barrière en créant un bloc :
Renomme le part en Socle :
Modifie les propriétés suivantes :
Puis un deuxième part pour la barrière :
Renomme le part en Barriere :
Avec les propriétés suivantes :
Sous ton workspace crée un Model que tu renommes en Barriere puis range les deux parts précédent sous ce Model :
Installe une charnière pour le mécanisme d’ouverture de la porte :
Avec un premier point d’appui sur la barrière et un deuxième sur le socle :
Tu dois obtenir ce résultat dans explorer :
deux points d’attachement un sur le socle et un autre sur la barrière,
une charnière HingeConstraint sur la barrière.
Tu peux régler plus précisément le point d’attachement, en sélectionnant celui-ci dans explorer et en utilisant l’outil déplacer :
Modifie les propriétés du HingeConstraint :
Si tu lances ton jeu, tu obtiens ce résultat :
Si tu changes la propriété TargetAngle :
En lançant ton jeu, tu obtiens le résultat suivant :
Automatisation d’ouverture de la barrière
Rajoute une boîte de collision transparente autour de la barrière afin d’automatiser son ouverture :
N’oublie pas d’enlever le CanCollide de la boîte de collision.
Puis crée un script dans ton Model Barriere :
Puis saisie ce script pour ouvrir et fermer automatiquement ta barrière :
-- Récupération de la barrière
local barriere = script.Parent.Barriere
-- Récupération de la boîte de collision
local boiteCollision = script.Parent.BoiteCollision
-- Quand la boîte de collision touche un un personnage
boiteCollision.Touched:Connect(function(hit)
-- On récupère le modèle parent de la pièce touchée
local character = hit.Parent
-- On vérifie si ce modèle a un "Humanoid" (seuls les personnages en ont un)
local humanoid = character:FindFirstChild("Humanoid")
if humanoid then
-- Ouverture de la barrière
barriere.HingeConstraint.TargetAngle = 90
end
end)
-- Quand la boîte de collision ne touche plus de personnage
boiteCollision.TouchEnded:Connect(function(hit)
-- On récupère le modèle parent de la pièce touchée
local character = hit.Parent
-- On vérifie si ce modèle a un "Humanoid" (seuls les personnages en ont un)
local humanoid = character:FindFirstChild("Humanoid")
if humanoid then
-- Fermeture de la barrière
barriere.HingeConstraint.TargetAngle = 0
end
end)
-- Fermeture de la barrière au début
barriere.HingeConstraint.TargetAngle = 0
Lance ton jeu pour tester ta barrière automatique :
PARTIE 03 : ROULER EN VOITURE
Choisis ces paramètres pour la construction de ton véhicule :
Joindre les surfaces
1 pour l’incrémentation pour dimensionner les objets
Choix d’un Bloc pour le châssis de la voiture
Redimensionne le châssis de ta voiture et renomme le part en « Chassis« :
Crée un nouveau bloc pour créer les moyeux des roues de la voiture :
Choisis sa demension :
Duplique en quatre blocs :
Colle les blocs sur le châssis :
Sur les quatre côtés du châssis :
Duplique deux nouveaux blocs pour la direction, modifie la couleur :
Décoche la propriété CanCollide pour ces blocs :
Sous worksapace crée cette structure et range tous les parts de ta voiture :
Par le clic droit de la souris, demande le menu suivant :
Insére l’objet VehicleSeat :
Installe cet objet sur le châssis, cet objet représente le siège du conducteur :
Déplace cet objet sous l’arborescence de ta voiture :
Lance le jeu pour venir t’assoir sur le siège de ton véhicule :
Insère des contraintes entre les pièces de ton véhicule pour transmettre la direction :
Vision de la transmission de direction à droite
Vision de la transmission de direction à gauche
Tu dois obtenir ce résultat dans ton explorer :
Sélectionne les HingeConstraint de tes deux roues de l’avant pour modifier les propriétés suivantes :
Rappel : c’est quoi un HingeConstraint ?
Un HingeConstraint = une charnière virtuelle. Il permet à un objet de tourner autour d’un axe (comme une porte, une roue, ou un bras robotique).
Mais quand on ajoute un moteur dessus, il peut :
tourner jusqu’à un certain angle → Servo
Quand ActuatorType = Servo
Le Servo agit comme un moteur intelligent : il regarde la position actuelle de la pièce, puis la fait tourner jusqu’à atteindre l’angle qu’on lui demande.
👉 On lui donne une cible (TargetAngle), et il s’arrête tout seul quand il y arrive.
🔩 3️⃣ Les propriétés importantes
Propriété
Rôle
TargetAngle
l’angle à atteindre (en degrés)
ServoMaxTorque
la force que le moteur peut exercer pour y arriver
AngularSpeed
vitesse à laquelle il tourne pour atteindre l’angle
ActuatorType
doit être mis sur Enum.ActuatorType.Servo
Tu dois obtenir la visualisation du mécanisme de la direction de tes deux roues :
Renomme les parts des roues avant droite et gauche ayant un HingeConstraint en « Direction » :
Rend invisible les deux parts des deux roues avant :
Rajoute un script sous le modèle de ta voiture :
local seat = script.Parent.VehicleSeat
local roueAvantGauche = script.Parent.RoueAvantGauche
local roueAvantDroite = script.Parent.RoueAvantDroite
local steerAngle = 30
seat:GetPropertyChangedSignal("Steer"):Connect(function()
print("Steer =", seat.Steer)
roueAvantGauche.Direction.HingeConstraint.TargetAngle =
steerAngle * seat.Steer
roueAvantDroite.Direction.HingeConstraint.TargetAngle =
steerAngle * seat.Steer
end)
Ce script fait tourner les roues avant d’une voiture quand le joueur tourne à gauche ou à droite avec le clavier (A / D ou Q / D selon ton clavier).
📘 Le code
local seat = script.Parent.VehicleSeat
➡️ On récupère le siège de conduite de la voiture (VehicleSeat). C’est lui qui détecte quand le joueur tourne à gauche ou à droite.
local roueAvantGauche = script.Parent.RoueAvantGauche
local roueAvantDroite = script.Parent.RoueAvantDroite
➡️ On récupère les deux roues avant du véhicule, pour pouvoir les faire pivoter.
RoueAvantGauche = la roue de gauche
RoueAvantDroite = la roue de droite
Ces roues ont chacune une charnière (HingeConstraint) qui permet de les faire tourner.
local steerAngle = 30
➡️ C’est l’angle maximum de rotation des roues (en degrés). Ici : les roues peuvent tourner jusqu’à 30° vers la gauche ou la droite.
➡️ Le script change l’angle cible (TargetAngle) de la charnière des roues avant. 👉 Résultat : quand le joueur tourne, les roues s’inclinent à gauche ou à droite comme une vraie voiture 🚘
🧠 En résumé
Élément
Rôle
VehicleSeat
détecte les touches du joueur
Steer
indique la direction du volant (-1, 0, 1)
HingeConstraint
permet de faire tourner les roues
TargetAngle
angle que doit atteindre la roue
steerAngle
limite maximale de rotation (ici 30°)
🎯 Ce que fait le script
➡️ À chaque fois que le joueur tourne :
Le siège envoie une valeur (Steer)
Le script multiplie cette valeur par 30
Les roues avant tournent de cet angle
💬 En bref :
Quand tu tournes le volant, les roues tournent dans la même direction, comme une vraie voiture
Lance ton jeu pour vérifier le bon fonctionnement de ta direction :
Maintenant nous allons installer les roues.
Crée une roue centrée sur la direction de ta voiture, surélève ton châssis de voiture :
Renomme le part en « roue » :
Duplique en 4 roues :
Place tes 4 roues bien centrées :
Range tes roues dans l’arborescence de ta voiture :
Pour chaque roue positionne une charnière à partir du centre de la roue sur le centre de la direction :
Sélectionne les quatre HingeConstraint des quatre roues et applique ces propriétés :
Qu’est-ce qu’un HingeConstraint ?
Un HingeConstraint (en français : contrainte de charnière) relie deux objets pour qu’ils puissent tourner autour d’un axe, comme une porte sur ses gonds ou une roue sur son axe.
Sans moteur, il laisse juste la pièce tourner librement. Avec un Motor, il fait tourner activement la pièce tout seul.
Quand ActuatorType = Motor
Alors le HingeConstraint se comporte comme un moteur qui fait tourner la pièce en continu 🌀
Les propriétés les plus importantes sont :
Propriété
Rôle
AngularVelocity
vitesse de rotation de la pièce (en radians/s)
MotorMaxTorque
force maximum du moteur (plus elle est grande, plus il peut pousser)
AngularResponsiveness
vitesse à laquelle le moteur s’adapte aux changements (réactivité)
Vérifie le sens de rotation :
Tu remarques que le sens gauche est inverse de celui du sens droit.
Vérifie le bon fonctionnement de la direction :
Modifie ton script :
local seat = script.Parent.VehicleSeat
local roueAvantGauche = script.Parent.RoueAvantGauche
local roueAvantDroite = script.Parent.RoueAvantDroite
local roueArriereGauche = script.Parent.RoueArriereGauche
local roueArriereDroite = script.Parent.RoueArriereDroite
local steerAngle = 30
local speed = 60
seat:GetPropertyChangedSignal("Steer"):Connect(function()
print("Steer =", seat.Steer)
roueAvantGauche.Direction.HingeConstraint.TargetAngle =
steerAngle * seat.Steer
roueAvantDroite.Direction.HingeConstraint.TargetAngle =
steerAngle * seat.Steer
end)
seat:GetPropertyChangedSignal("Throttle"):Connect(function()
print("Throttle =", seat.Throttle)
roueAvantGauche.Roue.HingeConstraint.AngularVelocity = speed * seat.Throttle
roueAvantDroite.Roue.HingeConstraint.AngularVelocity = speed * -seat.Throttle
roueArriereGauche.Roue.HingeConstraint.AngularVelocity = speed * seat.Throttle
roueArriereDroite.Roue.HingeConstraint.AngularVelocity = speed * -seat.Throttle
end)
Ce script permet de faire tourner les roues d’une voiture quand le joueur accélère ou recule avec le clavier (les touches Z / S ou flèche haut / flèche bas).
🧩 Étape 1 : on récupère les objets importants
local seat = script.Parent.VehicleSeat
➡️ On récupère le siège de conduite de la voiture. C’est lui qui détecte quand le joueur appuie pour avancer ou reculer.
local roueAvantGauche = script.Parent.RoueAvantGauche
local roueAvantDroite = script.Parent.RoueAvantDroite
local roueArriereGauche = script.Parent.RoueArriereGauche
local roueArriereDroite = script.Parent.RoueArriereDroite
➡️ On récupère les 4 roues du véhicule :
2 à l’avant
2 à l’arrière
Chaque roue contient un objet appelé HingeConstraint, une charnière qui permet à la roue de tourner sur elle-même.
🧩 Étape 2 : les réglages de base
local steerAngle = 30
local speed = 60
steerAngle : angle pour tourner (pas utilisé ici, mais utile si on veut tourner les roues plus tard).
speed : vitesse de rotation des roues (plus la valeur est grande, plus la voiture va vite 🚀).
🧩 Étape 3 : détecter quand le joueur accélère ou recule
Chaque roue tourne grâce à sa vitesse angulaire (AngularVelocity), c’est-à-dire la vitesse à laquelle elle tourne autour de son axe.
Mais pourquoi une roue est multipliée par -seat.Throttle ❓ 👉 Parce que les roues droite et gauche sont dans des sens opposés (comme une vraie voiture). Si elles tournaient dans le même sens, la voiture glisserait sur place au lieu d’avancer 😅.
Donc :
les roues de gauche tournent dans un sens,
celles de droite tournent dans le sens inverse, ➡️ ce qui fait avancer la voiture dans la bonne direction 🚗💨
Tu vas construire et programmer une barrière automatique qui s’ouvre dès qu’un passage est détecté grâce à un photoréflecteur. Ce projet te permettra de découvrir le fonctionnement d’un servomoteur, d’un capteur de lumière et de programmer un système automatique simple.
🧩 Ce que tu vas apprendre
Comment fonctionne un servomoteur pour faire bouger une barrière.
Comment utiliser un photoréflecteur pour détecter un passage.
À programmer des fonctions pour organiser ton code et le rendre plus lisible.
À tester et améliorer un système automatique.
🕹️ Comprendre les composants
1️⃣ Le servomoteur
Un servomoteur est un moteur spécial qui peut se déplacer à un angle précis.
Il se positionne à un angle défini entre 0° et 180°.
Cela permet de lever ou baisser la barrière exactement comme tu veux.
2️⃣ Le photoréflecteur
Un photoréflecteur détecte la présence d’un objet en utilisant la lumière réfléchie.
Quand rien ne passe devant, le capteur renvoie une valeur élevée
Quand un objet (voiture, main, robot) passe devant, la lumière est réfléchie et le capteur change sa valeur.
Cela permet de savoir qu’un passage est détecté.
🛠️ Matériel nécessaire
1 microcontrôleur (Arduino, micro:bit, ou équivalent)
1 servomoteur
1 photoréflecteur
Fils de connexion
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 coche D9 pour indiquer l’installation du servomoteur :
Vérifie que l’instruction sur le servomoteur est couleur bleue :
Active le test pour contrôler le servomoteur :
Utilise deux instructions servomoteur pour connaitre la position de la barrière ouverte et celle de la barrière fermée :
En cliquant sur les instructions, tu commande le servomoteur, attention il doit être sous tension.
Si tu veux contrôler la vitesse d’ouverture de la barrière :
Donne un nom à aux deux actions en créant deux fonctions :
Installe un bouton poussoir pour piloter l’ouverture de ta barrière :
Installe le connecteur du bouton poussoir sur A0 et modifie les paramètres des ports :
Vérifie que l’instruction sur le capteur de pression est bien de la couleur bleue :
Programme pour ouvrir la barrière sur l’appui du capteur de pression, puis attendre un certain avant de refermer automatiquement la barrière :
Transfert ton programme et test le bon fonctionnement :
Rajoute une LED rouge pour prévenir que la barrière est fermée :
Installe la LED sur A1 :
Programme pour allumer la LED rouge quand la barrière est fermée.
Introduis la possibilité de deux modes de fonctionnement :
un mode avec une ouverture puis une fermeture automatique
un mode avec juste une ouverture
Pour distinguer les deux modes, un appui rapide sur le bouton poussoir permet une ouverture puis une fermeture, un appui long permet une ouverture simple :
Transfert ton programme et test le bon fonctionnement :
from unihiker import GUI
import time
gui = GUI()
# Dessin d'un cercle pour le visage
circle = gui.draw_circle(x = 120,y = 140,r = 50,width = 3,color = "#FF6666")
# Création de l'emoji
emj = gui.draw_emoji(emoji = "Wink", origin = "center", x=120, y=120, duration = 0.2, w=50)
# Affichage du prénom en bas de l'écran
Text = gui.draw_text(text='Hello , Patrick !',x=15,y=260,font_size=20)
Text.config(color='#0000FF')
width = 50
radius = 30
delta_radius = 2.5
delta_width = 5
while True:
# Animation de l'emoji
time.sleep(0.3)
width += delta_width
radius += delta_radius
circle.config(r=radius)
emj.config(w = width)
if not (50 <= width <= 240):
delta_width = -delta_width
delta_radius = -delta_radius
Si tu veux une progression plus douce (effet oscillation) Tu peux remplacer l’incrémentation linéaire par une fonction sinus :
from unihiker import GUI
import time, math
gui = GUI()
# Dessin d'un cercle pour le visage
circle = gui.draw_circle(x = 120,y = 140,r = 50,width = 3,color = "#FF6666")
# Création de l'emoji
emj = gui.draw_emoji(emoji = "Wink", origin = "center", x=120, y=120, duration = 0.2, w=50)
# Affichage du prénom en bas de l'écran
Text = gui.draw_text(text='Hello , Patrick !',x=15,y=260,font_size=20)
Text.config(color='#0000FF')
width = 50
radius = 30
delta_radius = 2.5
delta_width = 5
t = 0
while True:
time.sleep(0.03)
radius = 80 + 40 * math.sin(t)
width = 120 + 60 * math.sin(t)
circle.config(r=int(radius))
emj.config(w=int(width))
t += 0.1
Les différentes possibilité des emoji.
Angry,
Nerve,
Peace,
Shock,
Sleep,
Smile,
Sweat,
Think,
Wink
Changement des EMOJI avec les boutons A ou B
from unihiker import GUI
from pinpong.extension.unihiker import *
import time, math
gui = GUI()
# Dessin d'un cercle pour le visage
circle = gui.draw_circle(x = 120,y = 140,r = 50,width = 3,color = "#FF6666")
emoji_table = ["Angry", "Nerve", "Peace", "Shock", "Sleep", "Smile", "Sweat", "Think", "Wink"]index = 0
# Création de l'emoji
emj = gui.draw_emoji(emoji = emoji_table[index], origin = "center", x=120, y=120, duration = 0.2, w=50)
# Affichage du prénom en bas de l'écran
Text = gui.draw_text(text='Hello , Patrick !',x=15,y=260,font_size=20)
Text.config(color='#0000FF')
width = 50
radius = 30
delta_radius = 2.5
delta_width = 5
import time, math
t = 0
while True:
time.sleep(0.03)
radius = 80 + 40 * math.sin(t)
width = 120 + 60 * math.sin(t)
circle.config(r=int(radius))
emj.config(w=int(width))
t += 0.1
# Changement de l'emoji avec le bouton A ou B
if (button_a.is_pressed()==True):
index = index + 1 if index < 8 else 0
emj.config(emoji = emoji_table[index])
if (button_b.is_pressed()==True):
index = index - 1 if index > 0 else 8
emj.config(emoji = emoji_table[index])
Bouton A ou B lumineux
Les boutons A et B de l’UNIHIKER sont accessibles à l’utilisateur, ce qui permet de créer un projet impliquant une LED contrôlée par des boutons. Ce projet vérifie d’abord si les boutons A et B de l’UNIHIKER ont été enfoncés, puis contrôle l’allumage et l’extinction de la LED bleue située à l’arrière de l’UNIHIKER. La bibliothèque PinPong propose deux façons d’utiliser les boutons : la première consiste à lire directement la requête, la seconde à utiliser les rappels d’événements d’interruption. Voici un exemple de contrôle de l’allumage et de l’extinction de la LED à l’aide des boutons A et B.
Utilise ces librairies :
from pinpong.extension.unihiker import *
from pinpong.board import Board,Pin
from unihiker import GUI
from pinpong.extension.unihiker import *
from pinpong.board import Board,Pin
from unihiker import GUI
# Initialisation de l'interface et de la carte
gui=GUI()
Board().begin()
# Initialisation de la LED
ledUI = gui.fill_circle(x=120,y=100,r=50,color="#FFFF00")
led = Pin(Pin.P25, Pin.OUT)
while True:
# Bouton A appuyé
if (button_a.is_pressed()==True):
led.write_digital(1)
ledUI.config(color="#0000FF")
# Bouton B appuyé
if (button_b.is_pressed()==True):
led.write_digital(0)
ledUI.config(color="#FF0000")
Fonctions d’interception de l’événement de l’appui sur le bouton A ou B
from pinpong.extension.unihiker import *
from pinpong.board import Board,Pin
from unihiker import GUI
# Controle de l'appui du bouton A
def on_buttona_click_callback():
led.write_digital(1)
ledUI.config(color="#0000FF")
# Controle de l'appui du bouton B
def on_buttonb_click_callback():
led.write_digital(0)
ledUI.config(color="#FF0000")
# Initialisation de l'interface et de la carte
gui=GUI()
Board().begin()
ledUI = gui.fill_circle(x=120,y=100,r=50,color="#FFFF00")
# Eteindre la LED
led = Pin(Pin.P25, Pin.OUT)
# Intercpetion des boutons A et B
gui.on_a_click(on_buttona_click_callback)
gui.on_b_click(on_buttonb_click_callback)
while True:
pass
LED externe sur le port 22
led = Pin(Pin.P22, Pin.OUT)
Détecteur de luminosité
UNIHIKER est équipé d’un capteur de lumière placé au-dessus de l’écran frontal, permettant de détecter l’intensité lumineuse ambiante. Grâce à cette fonctionnalité, un détecteur de luminosité peut être développé. Ce projet consiste à afficher la valeur lumineuse détectée par le capteur sur l’écran.
from unihiker import GUI
import time
from pinpong.board import Board
from pinpong.extension.unihiker import *
# # initialization
Board().begin()
# Instantiate a GUI object
gui = GUI()
img = gui.fill_circle(x=120,y=100,r=50,color="#FFFF00")
value = gui.draw_text(x=145, y=28, text='0', font_size=18)
while True :
# Update the displayed light value
Light = light.read()
value.config(text = Light)
# Light value level
if Light < 600:
img.config(color="#FF6600")
elif 600 <= Light < 1024:
img.config(color="#FF9900")
elif 1024 <= Light < 2048:
img.config(color="#FFCC33")
elif 2048 <= Light < 3072:
img.config(color="#FFFF99")
else:
img.config(color="#FFFF00")
time.sleep(1)
Dans cet exemple, UNIHIKER est initialisé avec Board().begin(). Ensuite, un objet GUI est instancié et un objet image et un objet texte sont créés à l’aide des méthodes draw_image() et draw_text(), respectivement. Dans la boucle principale, l’intensité lumineuse ambiante est obtenue grâce à la méthode light.read() de la bibliothèque PinPong, et la valeur lumineuse est affichée à l’écran grâce à la méthode draw_text() de la bibliothèque GUI.
L’intensité lumineuse ambiante est divisée en cinq niveaux en moyenne, et différents niveaux de luminosité sont représentés par des cercles de couleurs différentes, selon les conditions d’éclairage.
Piano musical
L’UNIHIKER est équipé d’un buzzer capable d’émettre différentes tonalités en réglant différentes fréquences. Cette fonctionnalité permet de créer un piano électronique. Ce projet propose une interface utilisateur simple permettant aux utilisateurs de jouer différentes notes en appuyant sur des boutons à l’écran. Voici un exemple de piano électronique :
from pinpong.extension.unihiker import *
from pinpong.board import Board,Pin
from unihiker import GUI
import time
# Gestion des touches du piano
def button_click1():
buzzer.pitch(262,1)
text.config(text="C4")
def button_click2():
buzzer.pitch(294,1)
text.config(text="D4")
def button_click3():
buzzer.pitch(330,1)
text.config(text="E4")
def button_click4():
buzzer.pitch(349,1)
text.config(text="F4")
def button_click5():
buzzer.pitch(392,1)
text.config(text="G4")
def button_click6():
buzzer.pitch(440,1)
text.config(text="A4")
def button_click7():
buzzer.pitch(494,1)
text.config(text="B4")
def button_click8():
buzzer.pitch(277,1)
text.config(text="C#4")
def button_click9():
buzzer.pitch(311,1)
text.config(text="D#4")
def button_click10():
buzzer.pitch(370,1)
text.config(text="F#4")
def button_click11():
buzzer.pitch(415,1)
text.config(text="G#4")
def button_click12():
buzzer.pitch(466,1)
text.config(text="A#4")
# Initialisation de l'interface et de la carte
u_gui=GUI()
Board().begin()
# Affichage du titre
bg=u_gui.fill_rect(x=0,y=0,w=240,h=320,color="#CCCCFF")
text = u_gui.draw_text(x=185,y=160,text="Clavier musical",origin="center",font_size=28,angle=270)
# Zones sensibles du clavier musical (touches blanches)
do=u_gui.fill_rect(x=0,y=3,w=130,h=43,color="#FFFFFF",onclick=button_click1)
re=u_gui.fill_rect(x=0,y=48,w=130,h=43,color="#FFFFFF",onclick=button_click2)
mi=u_gui.fill_rect(x=0,y=93,w=130,h=43,color="#FFFFFF",onclick=button_click3)
fa=u_gui.fill_rect(x=0,y=138,w=130,h=43,color="#FFFFFF",onclick=button_click4)
so=u_gui.fill_rect(x=0,y=183,w=130,h=43,color="#FFFFFF",onclick=button_click5)
la=u_gui.fill_rect(x=0,y=228,w=130,h=43,color="#FFFFFF",onclick=button_click6)
xi=u_gui.fill_rect(x=0,y=273,w=130,h=43,color="#FFFFFF",onclick=button_click7)
# Zones sensibles du clavier musical (touches noires)
bian1=u_gui.fill_rect(x=50,y=32,w=80,h=30,color="#000000",onclick=button_click8)
bian2=u_gui.fill_rect(x=50,y=77,w=80,h=30,color="#000000",onclick=button_click9)
bian3=u_gui.fill_rect(x=50,y=167,w=80,h=30,color="#000000",onclick=button_click10)
bian4=u_gui.fill_rect(x=50,y=212,w=80,h=30,color="#000000",onclick=button_click11)
bian5=u_gui.fill_rect(x=50,y=257,w=80,h=30,color="#000000",onclick=button_click12)
while True:
time.sleep(0.1)
Dans cet exemple, UNIHIKER est initialisé avec Board().begin().
Ensuite, un objet GUI est instancié, sur un fond bleu plusieurs rectangles noirs et blancs (représentant différentes touches de piano) sont créés à l’aide de la fonction fill_rect().
Ensuite, une série de fonctions d’événements sur le click de chaque touche sont définies, chacune correspondant à une note de musique.
Dans les fonctions appelées par un click sur la touche, le buzzer est contrôlé pour émettre un son d’une fréquence et d’une durée spécifiques à l’aide de la fonction buzzer.pitch (frequency, duration).
Chaque note de musique est liée à une touche de piano, et lorsque la touche est enfoncée, la fonction de rappel correspondante est exécutée et le buzzer joue la note correspondante.
De plus, une zone de texte affiche le nom de la note jouée, permettant ainsi à l’utilisateur d’identifier la note jouée.
Sonde sonore
L’UNIHIKER est également équipé d’un microphone capable de capter l’intensité du bruit ambiant. Cette fonctionnalité permet de créer un dispositif de surveillance du bruit, affichant l’intensité du bruit ambiant à l’écran. De plus, un seuil de bruit peut être défini ; lorsqu’il est dépassé, un signal sonore retentit pour vous avertir. Voici un exemple de dispositif de surveillance du bruit :
from pinpong.extension.unihiker import *
from pinpong.board import Board,Pin
from unihiker import Audio
from unihiker import GUI
Board().begin()
# Instantiation des objets audio et interface
audio = Audio()
gui = GUI()
# Titre du dispositif
gui.draw_text(text="Sonde sonore",x=120,y=50,font_size=20, color="#0000FF", origin="center")
# Affichage du niveau sonore
sound_text = gui.draw_text(text="",x=120,y=170,font_size=55, color="#0000FF", origin="center")
while True:
# Récupération du niveau sonore et son affichage
sound_value = audio.sound_level()
sound_text.config(text=sound_value, color="#0000FF")
# Déctection du niveau sonore
if (sound_value > 50):
# Alerte visuelle et sonore
sound_text.config(color="#FF0000")
buzzer.pitch(392)
time.sleep(0.1)
buzzer.stop()
# On laisse le niveau sonore retomber avant de le mesurer à nouveau
time.sleep(1)
Dans cet exemple, l’UNIHIKER est initialisé avec la fonction Board().begin().
Ensuite, un objet Audio et un objet GUI sont instanciés, et deux objets texte sont créés avec la fonction draw_text(). Ces objets texte affichent respectivement la surveillance du bruit et les valeurs de bruit correspondantes.
Dans la boucle principale, la méthode sound_level() de l’objet Audio permet d’obtenir l’intensité sonore ambiante, puis la méthode config() de l’objet texte permet de mettre à jour la valeur de luminosité à l’écran. Parallèlement, l’intensité sonore est vérifiée pour vérifier si elle dépasse le seuil défini. Si tel est le cas, la fonction buzzer.pitch(frequency) émet une alarme sonore, puis la fonction buzzer.stop() désactive le buzzer.
Compteur de sauts
L’UNIHIKER est également équipé d’un accéléromètre et d’un gyroscope 6 axes, capables de lire les valeurs x, y et z de l’accéléromètre et du gyroscope individuellement. Cette fonctionnalité permet de créer un compteur de saut : les valeurs de l’accéléromètre et du gyroscope s’affichent à l’écran, et le nombre de saut est calculé et affiché en fonction de l’intensité de l’accélération.
from pinpong.extension.unihiker import *
from pinpong.board import Board,Pin
from unihiker import GUI
import time
# Chronomètre du temps du jeu
chrono = 0
# Compteur de sauts
value = 0
# Réinitialisation des compteurs avec le bouton A
def on_buttona_click_callback():
global chrono
global value
chrono = 0
value = 0
# Initialisation de la carte et de l'interface
Board().begin()
gui = GUI()
# Affichage des données
gui.draw_text(text="Accéléromètre",x=10,y=5,font_size=16, color="#0000FF")
gui.draw_text(text="Gyroscope",x=10,y=105,font_size=16, color="#0000FF")
gui.draw_text(text="Compteur de sauts",x=10,y=210,font_size=16, color="#0000FF")
accelerometer_x = gui.draw_text(text="X：",x=30,y=35,font_size=12, color="#000000")
accelerometer_y = gui.draw_text(text="Y：",x=30,y=60,font_size=12, color="#000000")
accelerometer_z = gui.draw_text(text="Z：",x=30,y=85,font_size=12, color="#000000")
gyroscope_x = gui.draw_text(text="X：",x=30,y=135,font_size=12, color="#000000")
gyroscope_y = gui.draw_text(text="Y：",x=30,y=160,font_size=12, color="#000000")
gyroscope_z = gui.draw_text(text="Z：",x=30,y=185,font_size=12, color="#000000")
pedometer=gui.draw_text(text=value,x=30,y=230,font_size=45, color="#000000")
# Attente appui bouton A pour commmencer
gui.wait_a_click()
# Initialisation pour interception l'appui sur le bouton A
gui.on_a_click(on_buttona_click_callback)
while True:
# Récupération des mouvements par l'accéléromètre et le gyroscope
accelerometer_x.config(text=(str("X：") + str(accelerometer.get_x())))
accelerometer_y.config(text=(str("Y：") + str(accelerometer.get_y())))
accelerometer_z.config(text=(str("Z：") + str(accelerometer.get_z())))
gyroscope_x.config(text=(str("X：") + str(gyroscope.get_x())))
gyroscope_y.config(text=(str("Y：") + str(gyroscope.get_y())))
gyroscope_z.config(text=(str("Z：") + str(gyroscope.get_z())))
# Comptage de sauts
if (accelerometer.get_strength() > 1.5):
value = (value + 1)
# Affichage des sauts et du chronomètre
pedometer.config(text=str(value) + "/" + str(int(chrono)))
time.sleep(0.1)
chrono +=0.1
Dans cet exemple, l’UNIHIKER est initialisé avec la fonction Board().begin() et un objet GUI est instancié. Ensuite, grâce à la méthode draw_text(), plusieurs objets texte sont créés pour afficher les valeurs d’accélération, de gyroscope et de nombre de pas, ainsi que leurs valeurs correspondantes.
Le programme principal utilise accelerometer.get_x(), accelerometer.get_y() et accelerometer.get_z() pour obtenir les valeurs x, y et z de l’accélération, et gyroscope.get_x(), gyroscope.get_y() et gyroscope.get_z() pour les valeurs x, y et z du gyroscope. Ces valeurs sont ensuite affichées à l’écran grâce à la méthode config() de l’objet texte.
De plus, le nombre de saut est calculé à l’aide de la fonction accelerometer.get_strength() et incrémenté de 1 lorsque l’intensité d’accélération dépasse 1,5.
Le nombre de sauts est affiché à l’écran avec le chronomètre via la méthode config() de l’objet texte.
Votre objectif ? Couler les navires adverses et être le dernier joueur encore en lice ! Chaque micro:bit représente un champ de bataille : à vous de viser juste.
Comment ça marche ?
Un navire caché : Dès que vous allumez votre micro:bit, un navire apparaît aléatoirement sur la grille de LEDs (reconnaissable à sa lumière plus faible).
Un missile à guider : La LED la plus brillante, c’est votre missile ! Inclinez votre micro:bit (avant/arrière, gauche/droite) pour le déplacer et viser l’ennemi.
Prêt à tirer ?
Bouton A : Figez la position de votre missile pour ajuster votre tir.
Bouton B : FEU ! Envoyez votre missile vers les adversaires.
Touché ! Si votre missile atteint un navire, la micro:bit de la victime joue une musique de défaite… mais attention, elle reviendra en jeu après un délai ! À vous de la neutraliser à nouveau.
💻 À vous de coder ! Pour créer ce jeu, voici les fonctionnalités clés à programmer :
Communication radio : Envoyez et recevez les coordonnées (ligne/colonne) des tirs entre toutes les micro:bits du jeu.
Contrôle du missile : Utilisez l’accéléromètre pour déplacer le missile en inclinant la carte.
Gestion des tirs :
Bouton A : Verrouillez la position du missile.
Bouton B : Lancez le tir et transmettez les coordonnées aux autres joueurs.
Position aléatoire du navire : À chaque début de partie, le navire apparaît à un endroit aléatoire.
Détection de collision : Si un missile touche un navire, affichez une croix et déclenchez une musique de défaite.
Temps de réapparition : Un navire touché réapparaît après quelques secondes : soyez prêt à recommencer !
💡 Pourquoi c’est génial ?
Un jeu multijoueur : Affrontez vos amis en temps réel !
De la stratégie : Mémorisez les tirs et neutralisez vos adversaires.
Un projet complet : Codez la logique, l’affichage des LEDs, les sons et la communication entre cartes.
🛠️ Prêt à relever le défi ? Avec la micro:bit, vous allez apprendre à : ✔ Utiliser des capteurs (accéléromètre, boutons). ✔ Programmer l’affichage des LEDs et des sons. ✔ Faire communiquer plusieurs cartes entre elles.
À vos micro:bits ! Qui sera le dernier survivant ? 🎮💥
Le champ de bataille :
Ton navire : LED reconnaissable à sa lumière plus faible.
📦 Tu vas construire une boîte Leitner pour tes apprentissages. La boîte Leitner est un outil malin qui t’aide à mémoriser sur le long terme.
👉 Son principe est simple :
tu écris tes apprentissages sur des fiches recto-verso,
tu les ranges dans la boîte, qui contient 7 cases,
chaque case correspond à un rythme de révision différent (par exemple : le lendemain, quelques jours plus tard, une semaine plus tard, etc.),
avec un calendrier perpétuel de 64 jours, tu peux planifier tes révisions sans jamais perdre le fil.
Résultat : tu apprends moins dans la durée, mais tu retiens beaucoup plus longtemps !
Pour construire et imprimer ta boîte, tu vas utiliser le logiciel FreeCAD. FreeCAD est un logiciel de modélisation 3D libre et gratuit, utilisé dans le monde professionnel pour concevoir des objets, des machines. Il fonctionne un peu comme une feuille de dessin en 3D, où tu peux créer des formes simples (cubes, cylindres, sphères) et les assembler. Avec FreeCAD, tu peux mesurer, découper et modifier tes modèles avec une grande précision, comme un vrai ingénieur. Il est souvent utilisé en industrie pour le design mécanique, mais aussi en architecture et en impression 3D. Pour les collégiens, FreeCAD est un super outil car il permet de mettre en pratique les maths et la géométrie de façon concrète. Tu peux par exemple créer une boîte Leitner. Le logiciel garde une trace des étapes de ta construction, ce qui te permet de revenir en arrière et de comprendre comment ton modèle est construit. Comme il est open source, il est gratuit et améliorable par une grande communauté d’utilisateurs dans le monde. Il existe de nombreux tutoriels adaptés aux débutants, ce qui facilite la prise en main. En résumé, FreeCAD est à la fois un outil professionnel puissant et un jeu d’exploration pédagogique pour apprendre en s’amusant.
Choisir :
Puis Créer une esquisse :
Extérieur de la boîte (85mm x 110mm)
Protrusion pour la hauteur de la boîte (100mm)
Intérieur de la boîte (73mm x 98mm)
Cavité pour l’intérieur de la boîte (hauteur 97 mm)
Séparateur (3mm x 85mm à 36mm)
Protrusion (95mm)
Encoche du premier jour de l’agenda (3mm x 3mm à 38mm et 46mm)
Cavité de 60mm
Répétition des jours du calendrier sur le bord gauche (24 sur 99,50 mm)
Encoche du 41eme jour de l’agenda (3mm x 3mm à 38mm et 46mm)
Répétition des jours du calendrier sur le bord droit (24 sur 99,50 mm)
Encoche du 25eme jour de l’agenda (3mm x 3mm à 35mm et 50,50mm)
Répétition des jours du calendrier sur le bord du fond (16 sur 73 mm)
Trou pour les fréquences tous les jours (3mm à 52mm et 96mm)
Répétition des fréquences tous les jours (24 sur 99,50mm)
Trou pour les fréquences tous les 2 jours (3mm à 47,67mm et 91mm)
Répétition des fréquences tous les 2 jours (12 sur 95,25mm)
Trou pour les fréquences tous les 3 jours (3mm à 43,17mm et 86 mm)
Répétition des fréquences tous les 3 jours (6 sur 86,50mm)
Trou pour les fréquences tous les 4 jours (3mm à 34,67mm et 81 mm)
Répétition des fréquences tous les 4 jours (4 sur 78mm)
Trou pour la fréquence 5 (3mm à 34,67mm et 81 mm)
Trou pour la fréquence 6 (3mm à 34,67mm et 71 mm)
Reprendre les mêmes opérations mais pour la face droite du boitier :
Trou pour la fréquence 7 sur la face droite du boitier (3mm à 36,67mm et 66 mm)
Répétition des fréquences tous les 2 jours (12 sur 95,25mm)
Tu vas bientôt fabriquer ta propre boîte Leitner : une boîte spéciale qui t’aidera à mieux mémoriser tes leçons. Elle pourra t’accompagner tout au long de tes apprentissages, au collège, au lycée et même plus tard dans tes études supérieures.
Dans cet atelier, tu vas :
comprendre comment ton cerveau apprend grâce aux découvertes des sciences,
t’initier à la modélisation 3D pour imaginer et concevoir ta boîte,
utiliser une imprimante 3D pour lui donner vie,
et créer un parcours pédagogique personnalisé avec l’aide d’une IA qui t’accompagnera comme un coach.
🌍 Le monde évolue très vite. Mon souhait, c’est que ces ateliers t’apportent non seulement des méthodes efficaces, mais aussi le goût d’apprendre et la curiosité d’aller toujours plus loin
⚠️ Rappel important : Les techniques et outils présentés (boîte de Leitner, répétition espacée, auto-tests ou encore l’aide d’une IA) rendent l’apprentissage plus efficace et facilitent la mémorisation à long terme. Mais ils ne remplacent pas l’effort personnel : il faut toujours prendre le temps de réfléchir, comprendre et mémoriser par soi-même. C’est un peu comme le vélo : tu peux avoir les meilleures roues et le meilleur guidon, mais c’est toi qui dois pédaler pour avancer. Et si tu veux aller loin, tu dois t’entraîner à pédaler régulièrement. La différence, c’est qu’avec ces techniques, tu disposes des meilleurs outils grâce aux découvertes scientifiques, comme les cyclistes professionnels du Tour de France.🚴♂️.
Mets ton téléphone en mode avion avant de lire cet article.
🧠 Comment notre cerveau apprend et retient
Pourquoi apprendre ?
Apprendre, ce n’est pas seulement « savoir par cœur ». C’est aussi : mémoriser, comprendre, résoudre des problèmes et être créatif (inventer à partir de ce qu’on connaît déjà).
1) Ton cerveau : deux grandes mémoires
📌 Mémoire de travail = une petite table
C’est la mémoire « de l’instant présent ».
La table où tu poses les infos que tu utilises maintenant. (Elle reçoit des informations de tes sens : sons, images, sensations).
Capacité limitée (≈ 4 éléments en moyenne).
Si tu empiles trop, ça tombe : d’où l’importance de fractionner et organiser.
📚 Mémoire à long terme = une immense bibliothèque
Stocke des faits (dates, définitions) et des idées reliées (schémas mentaux).
Plus il y a de chemins (exemples, images, liens), plus il est facile de retrouver l’info.
Quasi-illimitée et organisée en réseau.
2) De la table à la bibliothèque : encodage, récupération, oubli
Encodage → ranger un nouveau « livre » dans la bibliothèque. (quand tu apprends une nouvelle information et que ton cerveau la stocke.)
Récupération → retrouver le livre quand on en a besoin. (quand tu arrives à te souvenir de cette information pour t’en servir.)
💡 Oubli = souvent, le livre est là… mais on a perdu le chemin. Multiplier les amorces (indices) aide à le retrouver.
Problème : parfois, l’information est bien stockée, mais tu ne retrouves pas la bonne « amorce » pour y accéder. C’est comme si ton cerveau avait la clé… mais tu avais perdu l’étiquette !
L’oubli n’est pas toujours une perte définitive : c’est souvent la perte d’indices de récupération.
Plus il y a d’amorces autour d’une information (ex : images, exemples, liens avec d’autres notions), plus elle sera facile à retrouver.
C’est pourquoi comprendre vaut mieux que répéter mécaniquement.
3) Quatre techniques validées par la recherche
🔁 Répétition espacée
Revoir l’information plusieurs fois en espacant les séances. Comme arroser une plante : ni trop, ni trop peu.
❓ Auto‑test (retrieval practice)
Se tester sans ses notes (quiz, QCM, cartes). Cela renforce les chemins de récupération, mieux que la simple relecture.
🔀 Diversification (interleaving)
Alterner matières ou types d’exercices. Comme un sportif qui varie les parcours : on apprend à choisir la bonne méthode au bon moment.
🛠️ Apprentissage actif / génératif
Reformuler avec ses mots, créer un schéma, expliquer à un camarade : on construit des liens qui rendent la mémoire plus solide.
📦 Tu vas construire une boîte Leitner pour tes apprentissages. La boîte Leitner est un outil malin qui t’aide à mémoriser sur le long terme.
👉 Son principe est simple :
tu écris tes apprentissages sur des fiches recto-verso,
tu les ranges dans la boîte, qui contient 7 cases,
chaque case correspond à un rythme de révision différent (par exemple : le lendemain, quelques jours plus tard, une semaine plus tard, etc.),
avec un calendrier perpétuel de 64 jours, tu peux planifier tes révisions sans jamais perdre le fil.
Résultat : tu apprends moins dans la durée, mais tu retiens beaucoup plus longtemps !
Ta boîte Leitner à ton nom
Avec son agenda intégré
📅 Le calendrier des révisions avec la boîte de Leitner
La boîte de Leitner fonctionne avec un planning de révisions. C’est ce qui rend la méthode très efficace : on ne revoit pas toutes les cartes tous les jours, mais on suit un rythme régulier.
🕐 Dans une journée
Chaque jour, prends 5 à 15 minutes pour réviser ta boîte.
Commence toujours par le premier compartiment (les cartes que tu connais le moins).
Révise ensuite les cartes des compartiments supérieurs si c’est leur « jour de passage » (voir plus bas).
📅 Dans une semaine
Les cartes du compartiment 1 reviennent tous les jours.
Les cartes du compartiment 2 reviennent tous les 2 jours.
Les cartes du compartiment 3 reviennent environ 1 fois par semaine.
🗓️ Dans un mois
Les cartes des compartiments avancés (4, 5, 6…) reviennent tous les 15 jours ou une fois par mois.
Cela veut dire qu’une carte bien apprise ne sera revue qu’après plusieurs semaines.
Si tu te trompes, pas grave : la carte redescend au niveau 1
👉 Grâce à ce calendrier, tu passes plus de temps sur ce que tu ne connais pas encore bien, et moins de temps sur ce que tu maîtrises déjà. C’est ça la force de la méthode Leitner !
📝 Comment bien rédiger ses fiches pour la boîte de Leitner
Chaque fiche a 2 faces : le recto (devant) et le verso (derrière).
📌 Le recto (la question)
Écris une question simple et claire.
Ça peut être :
un mot à traduire (« cat → ? »),
une définition (« Capital de la France ? »),
un calcul (« 7 × 8 = ? »),
ou une phrase à compléter (« Le fer est un … »).
Astuce : Mets une seule idée par fiche, jamais deux !
📖 Le verso (la réponse)
Écris la réponse exacte et complète.
Tu peux ajouter :
un exemple (« Paris → Tour Eiffel »),
une image ou un dessin rapide (utile pour les sciences, la géo, les langues),
une astuce mémoire (exemple : « 7×9=63 → pense à (7×10=70) – 7 = 63 »).
✅ Exemple complet
Recto : Capital de l’Espagne ?
Verso : Madrid 🏙️ Astuce : pense au « Real Madrid », l’équipe de foot.
👉 Quand tu révises, regarde toujours le recto d’abord (la question). Ne retourne la fiche qu’après avoir essayé de répondre dans ta tête.
🤖 Apprendre avec l’aide d’une IA (agent conversationnel)
Un agent conversationnel d’IA (comme le Chat de MISTRAL) peut être un outil d’apprentissage très utile. Mais attention :
L’IA peut parfois se tromper (on appelle ça « halluciner »).
Il faut toujours garder son esprit critique.
Vérifie tes cours, ton manuel ou demande à ton professeur pour être sûr.
👉 Important : demande toujours à l’IA de donner ses sources.
Tu peux t’aider d’un agent conversationnel pour t’aider à rédiger tes fiches de ta boîte Leitner.
Demande à tes parents l’autorisation d’utiliser un agent conversationnel.
📋 Exemples de prompts (questions à poser à l’IA)
Remplace le texte entre crochets pour l’adapter à ton apprentissage
1️⃣ Une aide pour rédiger ces fiches de la boîte Leitner
Exemple d’un prompt pour faire un QCM
Prompt : « Pour rédiger une flashcard (RECT/VERSO) fais-moi 1 QCM [facile, difficile, expert] de 5 questions avec 4 choix de réponses sur [ma leçon] et donne-moi la correction à la fin. Cite tes sources. »
Exemple d’un prompt pour faire une association mentale
Prompt : « Pour rédiger une flashcard (RECT/VERSO) peux-tu me proposer une association mentale sur les [syllabes, la sonorité, sur l’humour, sur le contexte ..] du [mot] pour créer une image immersive et mémorable en utilisant sur les sens [Visuel, Sons, Olfactif, Saveurs, Tactile, ou un Symbole] sur 5 lignes. et donne-moi la correction à la fin. Cite tes sources. »
Exemple d’un prompt pourfaire une phrase à trou
Prompt : « Pour rédiger une flashcard (RECT/VERSO) peux-tu me proposer trois phrases à trou pour trouver le [mot] sous forme de [devinette indice culturel…]. »
Exemple d’un prompt pourmémoriser un théorème
Prompt : « Pour rédiger une flashcard (RECT/VERSO) peux-tu me proposer une question sur le [théorème] avec [un visuel, un cas concret d’utilisation] en utilisant des mots clés et donne-moi la définition avec un exemple concret à la fin. Cite tes sources.. »
Exemple d’un prompt pourmémoriser une date
Prompt : « Pour rédiger une flashcard (RECT/VERSO) peux-tu me proposer une question sur une [date] avec [un visuel, une anecdote, un personnage, un lieu] en utilisant des mots clés et donne-moi la réponse avec une astuce pour mémoriser la date. Cite tes sources.. »
2️⃣ Avoir un professeur virtuel
Prompt : « Explique-moi [le concept] en 10 lignes comme si j’étais un collégien de 12 ans. Donne-moi aussi un exemple concret sur 5 lignes et tes sources. »
3️⃣ Simplifier un texte difficile
Prompt : « Simplifie ce texte compliqué pour que je le comprenne facilement (niveau collège). Garde les infos importantes et cite tes sources. »
4️⃣ Inventer une histoire mnémotechnique
Prompt : « Invente une petite histoire amusante pour m’aider à retenir [la règle / la formule / le mot] en utilisant [ton sport, ton activité préférée …] sur 10 lignes. »
5️⃣ Simuler un débat entre deux spécialistes
Prompt : « Simule un débat entre un scientifique qui défend [idée A] et un autre qui défend [idée B], pour que je comprenne les 5 arguments des deux côtés. Donne aussi les sources. »
6️⃣ Poser des questions en mode “enseignement inversé”
Prompt : « Je vais t’expliquer [mon cours] avec mes mots. Corrige-moi si je me trompe et complète mes explications. »
7️⃣ Demander des études de cas ou des problèmes pratiques
Prompt : « Donne-moi un petit problème pratique ou une étude de cas pour appliquer [ma leçon]. Corrige ma réponse ensuite et explique-moi mes erreurs. Cite tes sources. »
⚠️ Rappel important
👉 L’IA est un assistant, pas un professeur parfait. Vérifie toujours avec ton cahier, ton manuel ou ton enseignant.
⚠️ Un mot important sur l’IA et l’environnement Les outils d’intelligence artificielle sont très utiles pour apprendre, mais ils consomment aussi beaucoup d’énergie et de ressources. C’est pourquoi il est important de les utiliser à bon escient : seulement quand ils apportent une vraie valeur à ton apprentissage, et pas pour tout remplacer. L’IA doit être un allié robotique, mais l’essentiel de l’apprentissage vient toujours de ton effort, de ta curiosité et de ton envie de progresser.
Mistral est une entreprise française, ce qui signifie que ses outils sont pensés pour les élèves français, avec une meilleure compréhension des programmes scolaires, des références culturelles locales (ex : les classiques de la littérature française, l’histoire de France, etc.).
Moins de biais, plus de neutralité
Pourquoi ça compte ? Mistral est très attentif à la neutralité et à la diversité des points de vue, surtout sur des sujets sensibles (histoire, sciences, société). C’est important pour développer ton esprit critique sans être influencé par des idées toutes faites.
Comparaison : Certains outils peuvent avoir des biais culturels ou linguistiques (par exemple, privilégier des exemples anglo-saxons). Mistral évite ça pour coller à ton environnement.
Un outil qui respecte ta vie privée
Pourquoi c’est rassurant ? Mistral est soumis aux règles européennes strictes (RGPD) sur la protection des données. Tes conversations ne sont pas utilisées pour de la pub ou revendues, contrairement à certains outils américains.
et 2Mo de Flash programme, ce qui veut dire un espace de stockage à minima intégré.
d’un microcontrôleur ARM M0 double coeur cadencé à 130 MHz,
de plus de 200 Ko de RAM
La carte propose l’écosystème C/C++ mais également celui du Micropython.
Pi Pico bénéficie des avantages de micro-python et on peut citer notamment :
le mode interpréteur qui permet d’interagir avec la carte « à la volée » ce qui est très pratique pour apprendre, faire des essais, etc.
une programmation « puissante », synthétique et facile à apprendre à la fois,
la programmation par fichiers (et non plus code compilé) ce qui rend la maintenance d’un projet très facile : sur la carte on dispose du code !
Sur une carte à microcontrôleur, on dispose :
Processeur ARM Cortex M0 à double cœur
Horloge 133 Mhz.
2 Mo de mémoire Flash.
264 ko de RAM.
2 interfaces UART.
2 interfaces SPI.
2 contrôleurs I2C.
16 canaux PWM.
3 ADC 12 bits.
Un module Wifi.
https://www.youtube.com/watch?v=o-tRJPCv0GA&t=29s
Le pico pi est vendu « vide », autrement dit, il ne dispose pas du Micropython et il faut le programmer sur la carte avant toute chose.
Vous pouvez voir Micropython comme une sorte de firmware, un micrologiciel, que l’on flashe dans la carte et qui va ajouter l’interpréteur Python à la carte
Appuyez sur le bouton BOOTSEL de votre pico et maintenez le enfoncé.
Connectez votre Pico au port USB de votre PC tout en maintenant le bouton enfoncé.
Attendez quelques secondes et relâchez le bouton BOOTSEL.
Le Pico doit apparaître comme un lecteur amovible baptisé RP2350 :
Copier le fichier sur le Pico. Lorsque la copie du Firmware, le pico se relance.
Lancer l’IDE Thonny :
Cliquer sur «Options » dans le menu « Outils».
Choisir l’interpréteur « MicroPython (Raspberry Pi Pico) »
et indiquer le port COM utilisé par la carte Raspberry PICO puis cliquer sur « OK ».
Ma présence du MicroPython du Pico apparaît dans la console.
Saisir ce code dans la console pour allumer la LED du Pico :
>>> from machine import Pin
>>> led=Pin("LED",Pin.OUT)
>>> led.on()
>>>
Saisie ce programme et demande son exécution sur la Pico :
from machine import Pin
import time
pin_led = Pin('LED', mode = Pin.OUT) # La broche de la LED built-in est placée en sortie
while True:
pin_led.value(True)
time.sleep(1)
pin_led.value(False)
time.sleep(1)
Si sous Thonny, vous rencontrez ce problème : Unable to connect to COM24: port not found
Avec cet exercice, tu vas découvrir comment fonctionnent les briques de ton kit robotique. Chaque brique a des trous et des ergots. Pour les assembler, il faut mettre un ergot dans un trou.
Observe les images : Regarde bien où se trouvent les trous et les ergots sur chaque brique.
Assemble les briques : Place un ergot d’une brique dans un trou d’une autre brique.
Vérifie ton travail : Si tu ne peux pas assembler deux briques, c’est qu’il y a une erreur. Recommence en regardant bien les images.
Pour illustrer, imagine que tu as deux briques : la brique A et la brique B. La brique A a un ergot sur le côté droit et la brique B a un trou sur le côté gauche. Pour les assembler, tu dois aligner l’ergot de la brique A avec le trou de la brique B.
Terminé !
Apprendre à programmer ton robot
Tu vas apprendre à créer un programme pour contrôler ton robot. Pour cela, tu vas utiliser une interface de programmation en blocs appelée Scratch. Scratch a été inventé par des pédagogues du MIT (Massachusetts Institute of Technology) pour aider les enfants à apprendre à programmer. Aujourd’hui, Scratch est utilisé dans les écoles du monde entier.
Comment ça marche ?
Découvre les instructions : À gauche de ton écran, tu trouveras différentes instructions que le microcontrôleur de ton robot peut comprendre. Par exemple, il y a des instructions pour faire avancer le robot.
Assemble les blocs : Tu vas glisser et déposer ces instructions pour créer un programme. C’est comme assembler des cubes de ton kit robotique !
Transfère ton programme : Une fois que tu es satisfait de ton programme, tu peux le transférer sur le microcontrôleur de ton robot. C’est le cerveau de ton robot qui va lire et exécuter les instructions que tu as programmées.
Exemple :
Imagine que tu veux que ton robot allume une LED. Tu devrais chercher les blocs LED, puis les assembler pour les mettre sous « Démarrer le programme ».
Choix de la langue
Sauvegarde de ton programme
Paramètres des ports
Transfert de ton programme vers le microcontrôleur du robot
Aide
Taille des caractères à l’écran
Liste des instructions disponibles
Ton programme
Contrôle en mode test de ton programme
Placer des blocs
Pour placer un bloc, fais un clic-gauche dessus et fais-le gliser vers le centre de l’écran avant de le lâcher.
Maintiens le clic gauche de ta souris pour amener une instruction sur la partie centrale de ton écran.
Présente l’instruction par en dessous jusqu’à l’affichage d’une barre blanche, lâche le bouton de la souris pour coller l’instruction.
Par un clic-gauche, tu peux faire bouger « Démarrer le programme » pour vérifier que l’instruction est bien collée.
Clic-gauche sur 90 pour changer le chiffre grâce au clavier numérique. clic sur la partie grise de l’écran pour valider.
Choix des blocs
Tu as le choix entre différents types de blocs ou instructions. Il te suffit de cliquer sur chacun des 5 boutons en haut à gauche.
Pour chaque thème représenté par une couleur différente, découvre les différents sortes de blocs que tu vas apprendre à utiliser.
Pour en savoir plus sur SCRATCH
Scratch a été inventé par Mitchel Resnick, un professeur au MIT Media Lab. Il a été développé par le Lifelong Kindergarten Group au MIT. Le but de Scratch est de rendre la programmation accessible et amusante pour les enfants et les débutants, en utilisant une interface de programmation visuelle basée sur des blocs. Scratch est utilisé dans le monde entier et est traduit en plus de 70 langues. En septembre 2023, le site web de Scratch comptait plus de 115 millions d’utilisateurs enregistrés et près de 138 millions de projets partagés. Scratch est également utilisé dans de nombreuses écoles et collèges pour enseigner les concepts de base de la programmation et de l’algorithmique. Wikipedia Scratch
Scratch est particulièrement populaire en Amérique, avec des millions d’utilisateurs aux États-Unis, au Canada et au Brésil. En France, il y a près de 2 millions de comptes inscrits sur Scratch. Le logiciel est utilisé dans de nombreux collèges et écoles primaires à travers le monde, et il est intégré dans les programmes scolaires de plusieurs pays, y compris la France, où il est utilisé dans le cadre de la réforme des collèges de 2015 pour enseigner le codage et la programmation
Faire clignoter une LED
Instructions pour brancher la LED
Branchement du câble de la LED :
Insère le câble de la LED dans le connecteur A0 de ton microcontrôleur.
Assure-toi que le câble gris est positionné comme indiqué sur l’illustration. Cela garantit que le signal de contrôle est envoyé correctement.
Connexion du microcontrôleur :
Utilise un câble USB pour connecter ton microcontrôleur à ton ordinateur. Cela permet de transférer le programme et d’alimenter le microcontrôleur.
Une fois tout bien branché, tu peux programmer ton microcontrôleur pour envoyer des signaux à la LED et la faire clignoter.
Branche le câble de la LED sur le connecteur A0 de ton microcontrôleur. Attention au sens du câble gris.
Connecte ton microcontrôleur à ton ordinateur par le câble USB
Pour en savoir plus sur une LED
Une LED (Light Emitting Diode) est un composant électronique qui émet de la lumière lorsqu’un courant électrique la traverse. Les LEDs sont utilisées dans une multitude d’applications, des indicateurs lumineux aux écrans de télévision. Dans ton cas, tu utilises une LED rouge qui s’allume ou s’éteint en fonction des signaux qu’elle reçoit. Le câble de connexion de ta LED a trois fils : deux noirs pour l’alimentation électrique et un gris pour le signal de contrôle qui dit à la LED quand s’allumer ou s’éteindre.
Pour en savoir plus sur un microcontrôleur
Un microcontrôleur est un petit ordinateur sur une seule puce. Il contient un processeur, de la mémoire et des entrées/sorties programmables. Les microcontrôleurs sont utilisés pour contrôler des dispositifs électroniques. Dans ton projet, le microcontrôleur envoie des signaux à la LED pour la faire clignoter.
Configurer les ports
Clic sur le menu Edition en haut de l’écran et choisis Paramètres des ports
Dans la fenêtre qui apparaît, annule la sélection en cliquant sur le bouton Tout décocher. ensuite, clique sur la case A0 et choisis LED.
Clique sur A0 et choisis LED
Clic sur OK pour valider
Remarque la différence dans les blocs proposés :
Allume la LED :
Fais glisser le bloc LED A0 on sous Démarrer le programme :
Puis clic sur le menu Exécuter en haut de l’écran et choisis Transférer :
Tant que ce message est affiché ne touche pas au microcontrôleur ni au câble USB.
Il disparaîtra, une fois le transfert terminé.
Ta LED s’allume !!!
Allume ta LED avec ton doigt
Utilise le photoréflecteur mis à ta disposition :
Instructions pour brancher le photoréflecteur
Branchement du câble du photoréflecteur :
Insère le câble du photoréflecteur dans le connecteur A1 de ton microcontrôleur.
Assure-toi que le câble gris est positionné comme indiqué sur l’illustration pour garantir que le signal est correctement transmis.
Place le photoréflecteur en face du bloc noir :
Configuration des ports
Clic sur le menu Edition en haut de l’écran et choisis Paramètres des ports
Dans la fenêtre qui apparaît, clique sur la case A1 puis choisis Photoréflecteur IR.
Valide par le bouton OK
Par le dispositif Activer le test sous Exécuter du menu de l’écran, tu vas visionner le fonctionnement du photoréflecteur :
Tant que ce message est affiché ne touche pas au microcontrôleur ni au câble USB.
Il disparaîtra, une fois le dispositif de test lancé.
Ce tableau apparaît et tu peux visualiser les valeurs remontées par le photoréflecteur :
Glisse ton doigt entre le photoréflecteur et le cube noir :
Regarde la valeur retournée par le photoréflecteur :
En savoir plus sur le photoréflecteur
Un photoréflecteur est un capteur qui détecte la présence d’un objet en utilisant la lumière. Il émet une lumière (généralement infrarouge que tu ne vois pas) et mesure la quantité de lumière réfléchie. Lorsque tu places ton doigt devant le photoréflecteur, la lumière est réfléchie différemment, ce qui permet au capteur de détecter la présence de ton doigt.
Programme le photoréflecteur
Programme ton photoréflecteur pour allumer la LED sur la présence de ton doigt.
Désactive le dispositif de test :
Ton objectif : allumer la LED quand le photoréflecteur retourne une valeur détectant la présence du doigt sinon éteindre la LED
Utilise les instruction de contrôle pour tester la valeur de retour du photoréflecteur :
Installe l’instruction répéter indéfiniment
Puis l’instruction de condition SI SINON
Maintenant pour comparer la valeur retournée par le photoréflecteur utilise l’opérateur mathématique > :
Puis récupère les valeurs retourbées par le photoréflecteur :
Décide d’allumer la LED quand les valeurs retournées par le photoréflecteur dépassent la valeur de 20 :
Pense à éteindre la LED quand ton doigt n’est plus présent :
Puis clic sur le menu Exécuter en haut de l’écran et choisis Transférer :
Tant que ce message est affiché ne touche pas au microcontrôleur ni au câble USB.
Il disparaîtra, une fois le transfert terminé.
Test d’un moteur
Instructions pour brancher le moteur CC
Branchement du moteur :
Insère le connecteur du moteur dans le port M1 de ton microcontrôleur.
Assure-toi de ne pas forcer lors du branchement. Le connecteur a un détrompeur, donc s’il ne s’insère pas facilement, c’est qu’il est mal orienté.
Alimentation :
Assure-toi que la batterie est bien en position ON. Le moteur nécessite plus d’énergie que celle fournie par la liaison USB, donc une source d’alimentation externe est nécessaire.
Configuration des ports
Configure le port M1 :
Dans le configurateur des paramètres des ports, coche M1 pour activer le port du moteur.
Clic sur le menu Edition en haut de l’écran et choisis Paramètres des ports
Dans la fenêtre qui apparaît, clique sur la case M1 puis OK
Programme le moteur
Pour programmer le moteur, tu disposes de trois instructions principales :
Déclaration de la puissance du moteur :
Tu peux définir la puissance du moteur, sous la forme d’un pourcentage de la puissance maximale 0 à 100%.
Sens de la marche :
CW (Clockwise) pour le sens des aiguilles d’une montre.
CCW (Counter-Clockwise) pour le sens inverse des aiguilles d’une montre.
Par exemple, MOTEUR M1 tourne Sens aiguilles CW pour faire tourner le moteur dans le sens des aiguilles d’une montre.
Arrêter le moteur :
Utilise une instruction pour arrêter le moteur, par exemple, Moteur M1 off Frein.
Teste le bon fonctionnement du moteur
Puis clic sur le menu Exécuter en haut de l’écran et choisis Transférer :
Tant que ce message est affiché ne touche pas au microcontrôleur ni au câble USB.
Il disparaîtra, une fois le transfert terminé.
En savoir plus sur le moteur à courant continu CC
Un moteur à courant continu (CC) est un dispositif qui convertit l’énergie électrique en énergie mécanique. Il est alimenté par un courant continu et est utilisé dans une variété d’applications, des jouets aux robots. Le sens de rotation du moteur peut être inversé en changeant la polarité de l’alimentation.
Test d’un servomoteur
Instructions pour brancher le servomoteur
Branchement du servomoteur :
Insère le connecteur du servomoteur dans le port D9 de ton microcontrôleur.
Assure-toi que le câble gris est correctement orienté selon l’illustration pour garantir que le signal est correctement transmis.
Alimentation :
Assure-toi que la batterie est bien en position ON. Le servomoteur nécessite plus d’énergie que celle fournie par la liaison USB, donc une source d’alimentation externe est nécessaire.
Configuration des ports
Configurer le port D9 :
Dans le configurateur des paramètres des ports, coche D9 pour activer le port du servomoteur.
Clic sur le menu Edition en haut de l’écran et choisis Paramètres des ports
Dans la fenêtre qui apparaît, clique sur la case D9 puis OK
Programmation du servomoteur
Pour programmer le servomoteur, tu disposes d’une instruction principale pour définir l’angle de rotation :
Tu peux définir l’angle de rotation du servomoteur, généralement entre 0° et 180°. Par exemple, Régler le servomoteur D9 à 90 pour positionner le servomoteur à 90°.
Définir l’angle de rotation :
Atelier 01
Atelier de Codage d’un robot de livraison :
L’objectif de cet atelier est de coder en mode bloc un robot de livraison qui doit détecter un bloc de cubes blancs afin de l’attraper pour le livrer.
Matériel Nécessaire
Pour cet atelier, vous aurez besoin des composants suivants :
Composant
Description
Arduino Uno
Un microcontrôleur pour exécuter le code.
Photoreflecteur
Un capteur pour détecter le bloc de cubes blancs
Un capteur de pression
Pour démarrer la phase de livraison du robot.
LED rouge
Une LED qui s’allumera lorsque le robot démarra sa phase de livraison.
Cubes blancs
Objets à détecter par le photoréflecteur.
Le robot livreur avance pince ouverte :
Le robot détecte le bloc de cubes, referme sa pince :
Le robot livreur :
1 Servomoteur pour attraper le boc (attention ne pas le manipuler sous tension, dispositif fragile)
Photo réflecteur pour détecter le bloc blanc
LED rouge pour indiquer que le robot bouge
Capteur de pression pour faire démarrer le robot
Construction du robot
Installe le servomoteur :
Installe le photoréflecteur pour détecter le bloc :
Installe le microcontrôleur
Installe la LED rouge :
Installe le capteur de pression :
Cable tous les dispositifs :
A0 : Photoréflecteur A1 : LED A2 : Capteur de pression D9 : Servomoteur M1 : Moteur CC
Tableau d’assignation des broches
Test du bouton de pression pour allumer la LED rouge
Teste ton robot
Puis clic sur le menu Exécuter en haut de l’écran et choisis Transférer :
Tant que ce message est affiché ne touche pas au microcontrôleur ni au câble USB.
Il disparaîtra, une fois le transfert terminé.
Fais avancer ton robot jusqu’au cube :
Teste ton robot
Puis clic sur le menu Exécuter en haut de l’écran et choisis Transférer :
Attrape le cube
Le robot avance pince ouverte, détecte le cube blanc puis pince le cube :
Le robot détecte, attrape puis recule pour relâcher le cube :
Atelier 02
Atelier de Codage pour la reconnaissance de blocs blancs ou noirs :
L’objectif de cet atelier est de vous initier au codage en utilisant des blocs de programmation pour reconnaître des couleurs (noir et blanc) à l’aide d’un photo réflecteur. En fonction de la couleur détectée, une LED blanche ou rouge s’allumera.
Matériel Nécessaire
Pour cet atelier, vous aurez besoin des composants suivants :
Composant
Description
Arduino Uno
Un microcontrôleur pour exécuter le code.
Photoreflecteur
Un capteur pour détecter les couleurs.
LED blanche
Une LED qui s’allumera lorsque le capteur détectera du blanc.
LED rouge
Une LED qui s’allumera lorsque le capteur détectera du noir.
Cubes noir et blanc
Objets à détecter par le photoréflecteur.
Configuration Matérielle
Connexion du Photoreflecteur :
photoréflecteur sur le port A0
Connexion des LEDs :
LED blanche A1
LED rouge A2
Plateforme matérielle
LED Blanche
LED Rouge
Photoréflecteur
Présentation du bloc blanc la LED blanche s’allume, la rouge reste éteinte :
Présentation du bloc noir la LED rouge s’allume, la blanche reste éteinte :
Connexions du dispositif
A0 : Photoréflecteur A1 : LED blanche A2 : LED rouge
Vérifie si l’assignation des dispositifs est correcte :
Active les test pour comprendre le fonctionnement du Photoréflecteur :
Présente le bloc blanc :
Présente le bloc noir :
Ecris ce code :
Transfère ton code sur le microcontrôleur et teste avec les cubes blanc et noir :
Atelier 03
Atelier IA : Reconnaissance de couleurs avec une Micro:bit et un outil d’Intelligence Artificielle
Objectif de l’Atelier
L’objectif de cet atelier est d’initier les participants à la reconnaissance de couleurs en utilisant un capteur de couleurs et une plateforme de microcontrôleur appelée Micro:bit. Contrairement au premier atelier, nous allons utiliser un outil d’intelligence artificielle pour apprendre à reconnaître trois couleurs : blanc, noir et vert. Les participants apprendront à collecter des échantillons de mesures, à entraîner un modèle d’IA, et à utiliser ce modèle pour reconnaître les couleurs.
Matériel Nécessaire
Pour cet atelier, vous aurez besoin des composants suivants :
Composant
Description
Micro:bit
Un microcontrôleur facile à utiliser pour les débutants.
Vittascience est une plateforme éducative pensée pour l’apprentissage du codage, qui propose des outils innovants pour l’enseignement.
Description du microcontrôleur micro:bit :
Configuration Matérielle
Connexion du Capteur :
Branchez le capteur sur la carte d’extension Micro:bit en utilisant la broche P0
Allumez la carte d’extension
Préparation 3 blocs de Couleurs blanc, vert et noir :
Préparez des échantillons de couleurs blanches, noires et vertes que le capteur pourra détecter.
Bouton pour allumer la carte d’extension
Connexion du capteur sur P0 sur la carte d’extension
Capteur analogique
Sur le site vittascience IA choisir connecter une carte :
Connecte le capteur analogique en choisissant p0 :
Ajoute les trois catégories noir, vert, blanc :
Présente le capteur au dessus des blocs et enregistrement pour chaque couleur une dizaine d’échantillons :
Puis demande à entrainer le modèle :
Demande à ton modèle de reconnaître les blocs :
Atelier 04
IA reconnaissance de forme : Objectif de l’Atelier
L’objectif de cet atelier est d’initier les participants à la reconnaissance de forme par l’IA en utilisant les dalles d’un parcours de compétition Rescue Line.
Matériel Nécessaire
Pour cet atelier, vous aurez besoin des composants suivants :
Composant
Description
Caméra
Utilisation d’une caméra sur le port USB.
Dalles
Dalles composées d’une ligne noire sous différentes formes
Vittascience est une plateforme éducative pensée pour l’apprentissage du codage, qui propose des outils innovants pour l’enseignement.
La MAQUEEN suivi ligne noire :
Caractéristiques : 5 capteurs de suivi de ligne (sorties analogiques et digitales), calibration automatique via bouton-poussoir 2 LEDs frontales rouges 4 LEDS RGB Néopixels Capteur de distance ultrason HC-SR0 4Buzzer pour effets sonores 2 motoréducteurs N20 :vitesse de rotation nominale : 266 tr/minmodulation PWM rapport de réduction: 1:75 Capteur infrarouge permettant au robot d’être télécommandé Port d’extension GPIO : 8 ports : P0 P1 P2 P8 P12 P13 P14 P15 avec 3,3V 3 ports pour servomoteur : P0 P1 P2 avec Vbat 2 Ports I2C 3.3V1 Port I2C 5V Alimentation par batterie Li-Ion 18650 3.7V 3500 mAh avec circuit de chargement Tension de charge : 5 V, temps de charge : 4 heures, indicateur du niveau de charge : 4 LED Dimensions du produit : 14 x 101 x 70 mm
Le robot dispose à l’avant de 5 capteurs optiques infrarouge.
Fonctionnement d’un capteur optique infrarouge
Le capteur optique infrarouge est constitué : d’une LED infrarouge d’un photo-transistor Le capteur envoie un signal haut lorsqu’il détecte le noir et un signal bas quand il détecte le blanc.
Puis fais défiler ton écran pour choisir le robot Maqueen Plus
Choisis le mode Bloc et agrandis ton écran en baissant la console du bas :
Pour gérer le tableau de LED de la carte microbit utilise l’instruction « afficher l’image » sous Affichage :
Par exemple allume les LEDs de la manière suivante dans « Au démarrage » :
Tu peux tester en demandant à Téléverser sur la carte :
Demande la connexion avec la carte puis valide le transfert.
Tu utilises les instructions suivantes pour le suivi de la ligne noire.
Pour faire avancer ton robot :
Pour détecter la ligne noire :
Comment suivre la ligne noire
Programme ton robot pour qu’il tente de rester sur la ligne noire :
Le capteur de gauche et celui de droite ne captent pas la ligne noire, alors les deux capteurs sont de chaque coté de la ligne noire, le robot peut avancer tout droit. Le capteur de gauche est sur la ligne noire, ramène ton robot vers la gauche. Le capteur de droite est sur la ligne noire, alors ramène ton robot vers la droite.
Passe ton robot sur la ligne noire et vérifie que le robot détecte bien la ligne noire, ainsi que les flèches indiquent la bonne direction pour que le robot puisse suivre la ligne noire :
Premier essai pour suivre la ligne noire
Programme les deux moteurs pour aller tout droit, à gauche et à droite.
Pour ton premier essai réduit la vitesse à 50, le Maqueen est très véloce :
Atelier 06
L’objectif de cet atelier est de programmer le robot MBOT pour qu’il puisse détecter des obstacles.
Matériel Nécessaire
Pour cet atelier, vous aurez besoin des composants suivants :
Composant
Description
Robot MBOT V2
Le robot mBot 2 est un robot éducatif de nouvelle génération, conçu pour l’enseignement secondaire, mais qui peut s’adapter à un niveau d’enseignement plus élevé.
mBlock est un logiciel de programmation par blocs d’instructions permettant de piloter des cartes programmables, robots et de créer des programmes sans avoir de connaissances en langage de programmation. C’est un outil idéal pour découvrir et maîtriser les bases de l’algorithmique.
Description du MBOT :
Programme un MBOT pour qu’il détecte un obstacle :
A bouton A
B bouton B
1 Connecteur USB pour téléverser
2 Bouton on/off
Programme pour que ton robot avance, détecte un obstacle et tourne à gauche à 90°. Le bouton A lance le robot Le bouton B arrête le robot
Utilise le capteur ultrasons pour détecter un obstacle à moins de 15 cm.
Utilise les couleurs pour retrouver les instructions :
Pour essayer, connecte le robot par la câble USB puis téléverse le programme :
Pose le robot sur le sol et essaye !!!!
Atelier 07
L’objectif de cet atelier est de dessiner des formes en utilisant l’accéléromètre et des boutons poussoir.
Matériel Nécessaire
Pour cet atelier, vous aurez besoin des composants suivants :
Composant
Description
micro-controleur UNIHIKER
UNIHIKER est un ordinateur monocarte complet et compact, riche en fonctionnalités et convivial. Il est doté d’un écran tactile de 2,8 pouces, du Wi-Fi, du Bluetooth et équipé de plusieurs capteurs.
Mind+
Mind+ est un logiciel de programmation graphique destiné aux adolescents qui s’intègre à toutes sortes de cartes mères grand public.
Description du MBOT
Programme le boitier UNIHIKER :
Connecte le terminal :
Ton objectif dessine des cercles de différentes couleurs, grosseurs sur l’écran et utilise l’accéléromètre pour positionner les cercles.
Initialisation
Changement du diamètre du cercle
Changement des couleurs
Utilise les objets graphiques de UNIHIKER pour dessiner des cercles :
Ecris ce programme et lance l’exécution :
Utilise l’accéléromètre pour positionner les cercles :
L’écran de l’UNIHIKER fait 240×360 pixel, affiche les cercles en utilisant l’accéléromètre :
Utilise le port 21 pour récupérer les données des cinq boutons, pour modifier le diamètre du cercle et sa couleur :
Affiche les cercles en fonction des calculs sur la position en x et y, la valeur du diamètre du cercle radius et de sa couleur color :
Une proposition de programme complet :
Lance le programme sur UNIHIKER :
Atelier 08
Atelier de Codage d’un lanceur d’avion :
L’objectif de cet atelier est de coder en mode bloc un robot de livraison qui doit détecter un bloc de cubes blancs afin de l’attraper pour le livrer.
Matériel Nécessaire
Pour cet atelier, vous aurez besoin des composants suivants :
Composant
Description
Arduino Uno
Un microcontrôleur pour exécuter le code.
Un servomoteur
Afin de diriger la rampe de lancement suivant un certain angle
Un moteur CC
Pour détendre l’élastique afin de propulser l’avion
Joystick
Un joystick pour piloter l’angle de lancement et le tir
Un avion
Un avion en papier
Paramètres des ports :
Programme le lancement du tir en actionnant le moteur CC pendant 0.5 seconde :
Teste en transférant ton programme, n’oublie d’allumer la batterie du robot :
Oriente la rampe de lancement à 60° en utilisant une variable angle afin de piloter le servomoteur :
Utilise le joystick pour orienter la rampe de lancement :
Atelier 09
Atelier de Création d’un jeu vidéo en PYTHON:
Pour pouvoir coder notre jeu il va falloir importer une « bibliothèque » qui se nomme pygame:
Import de la bibliothèque pygame
import pygame
Cela va nous permettre d’accéder à des systèmes déjà créés afin de nous faciliter la tâche.
Après l’importation de la bibliothèque il faut maintenant l’initialiser.
Initialisation de pygame
pygame.init()
Si l’on veut voir notre jeu il faut créer une fenêtre de windows. Il faut donc définir ses caractéristiques comme sa taille, son titre et sa couleur.
Définis la longueur et la largeur de la fenêtre de jeu
WIDTH = 800 HEIGHT = 400
Il faut donc l’afficher avec ces caractéristiques:
crée la fenêtre windows en fonction de la longueur et la largeur défini précedemment et défini le nom de la fenêtre
screen = pygame.display.set_mode((WIDTH, HEIGHT)) pygame.display.set_caption(« Mon premier jeu »)
Ensuite on va définir le nombre d’images par seconde(fps, soit frame per second) qu’aura notre fenêtre.
Définis le nombre d’images par seconde
fps = 60
Si l’on veut pouvoir fermer la fenêtre de notre jeu, il va falloir savoir si le jeu est en cours ou non. Pour cela on va créer une variable contenant un booléen, c’est à dire une boîte contenant soit la valeur vraie (True) ou la valeur fausse (False) que l’on va pouvoir modifier en fonction de l’état de notre jeu (en cours ou non).
Définis si le jeu est en cours ou non
run = True
Ma première fenêtre windows en Python Pygame :
Ecris ce programme, vérifie que tu n’as pas d’erreur et que tu as bien respecté l’indentation :
Vérifie la syntaxe de ton programme :
Lance ton programme pour tester ta première fenêtre windows en Python avec Pygame :
Tu dois constater ce résultat :
Tu peux t’amuser à modifier ces variables et voir le résultat de la fenêtre windows générée :
Peint ta fenêtre :
On va donc appeler une fonction display dans le programme principal qui va permettre de changer la couleur du fond et appliquer ces changements à l’écran afin qu’ils soient visibles.
Tu peux t’amuser à changer la couleur de ta fenêtre (des valeurs comprises entre 0 à 255) :
par exemple : screen.fill((200, 0, 0))
Dessine ton personnage
Maintenant, dessinons notre personnage, comme pour la fenêtre il faut créer des constantes , autrement dit une boîte que l’on ne modifiera pas, comme ses dimensions par exemple.
Définis la largeur est la hauteur du personnage
WIDTH_RECT = 60 HEIGHT_RECT = 60
Il faut donc la dessiner, pour cela il faut créer une fonction afin de simplifier le code. Une fonction est un groupe d’instructions que l’on peut réutiliser plusieurs fois dans le programme sans le réécrire, il faut seulement appeler le nom de la fonction.
Fonction permettant de dessiner le personnage avec une taille précise sur l’écran en rouge à une position x et y
On va donc appeler cette fonction dans une autre fonction qui va aussi nous permettre de changer la couleur du fond et appliquer ces changements à l’écran afin qu’ils soient visibles.
Avant d’appeler cette fonction on va d’abord définir quelques variables comme la position sur l’axe x et y du personnage :
Vérifie bien les modifications :
Tu obtiens ce résultat :
Essaye de changer la couleur de ton personnage ? un indice recherche (255, 0, 0) et change ces valeurs.
Fais bouger ton joueur avec les touches du clavier :
