Outil utilisé: Gemini (option Canvas)
Date: 9 octobre 2025
Objectif: Voir comment une capture d'écran d'une séquence de code (Makecode/micro:bit) sous forme de blocs est interprétée.
Cet exemple de code a été créé afin de démontrer qu'il est possible d'optimiser la programmation en mobilisant des concepts mathématiques (fonction linéaire, fonction en escalier, addition de fonctions, etc.) [version optimisée]. Le projet initial ne fait pas appel à l'IA. Ce code permet de modifier la position de la lumière en appuyant sur le bouton A.
Simulation du code micro:bit
Image de la séquence de programmation
Afin de voir comment Gemini Canva pourrait m'être utile dans la programmation d'un micro:bit, j'ai exporter le code en image (voir image ci-dessus)...
À noter que je n'ai donné aucune autre information à part l'image et la requête.
Cette image est un code sous forme de bloc pour programmer un micro:bit via makecode. Peux-tu me donner une version java de ce code?
Absolument ! Voici une traduction en Java du code en blocs pour le micro:bit que vous avez partagé.
Le code Java est structuré pour refléter la logique de vos blocs, en supposant un environnement de programmation Java pour micro:bit. J'ai inclus des commentaires pour faire le lien entre chaque partie du code et les blocs d'origine.
Ce fichier Java vous donne une traduction directe de la logique de vos blocs.
J'ai aussi inclus une méthode calculerCoordonneesOptimise() qui montre une manière plus courte et efficace d'obtenir le même résultat en utilisant les opérateurs mathématiques modulo (%) et de division (/), qui sont très courants en programmation. C'est généralement la méthode que l'on privilégierait
/**
* Ce code est une traduction Java du programme en blocs MakeCode pour le micro:bit.
* Il allume une LED à la fois sur l'écran 5x5.
* Le bouton A permet de passer à la LED suivante.
*
* Le programme utilise trois variables principales :
* - 'position': un compteur de 0 à 24 pour suivre la LED actuelle.
* - 'x': la coordonnée horizontale (colonne) de la LED.
* - 'y': la coordonnée verticale (ligne) de la LED.
*/
public class MicroBitCode {
// --- Variables globales ---
// Correspond aux variables 'position', 'x', et 'y' de MakeCode.
private static int position = 0;
private static int x = 0;
private static int y = 0;
/**
* Bloc "au démarrage"
* Cette méthode est appelée une seule fois au lancement du programme.
* Elle initialise la position à 0.
*/
public static void auDemarrage() {
position = 0;
}
/**
* Bloc "lorsque le bouton A est pressé"
* Cette méthode est appelée chaque fois que le bouton A est pressé.
*/
public static void lorsqueLeBoutonAEstPresse() {
// Éteint la LED à la position actuelle (avant de la changer)
// Note: l'API réelle peut varier, ex: microbit.display.unplot(x, y);
eteindreLED(x, y);
// Modifie la position de 1
position++;
// Pour éviter de dépasser 24 (l'écran a 25 LEDs, de 0 à 24)
if (position > 24) {
position = 0;
}
}
/**
* Fonction "valeurx"
* Calcule la coordonnée x en fonction de la position.
* Ceci est une façon détaillée d'écrire l'opération "modulo 5".
*/
private static void calculerValeurX() {
if (position < 5) {
x = position;
} else if (position < 10) {
x = position - 5;
} else if (position < 15) {
x = position - 10;
} else if (position < 20) {
x = position - 15;
} else {
// Pour les positions de 20 à 24
x = position - 20;
}
}
/**
* Fonction "valeury"
* Calcule la coordonnée y en fonction de la position.
* Ceci est une façon détaillée d'écrire l'opération "division entière par 5".
*/
private static void calculerValeurY() {
if (position < 5) {
y = 0;
} else if (position < 10) {
y = 1;
} else if (position < 15) {
y = 2;
} else if (position < 20) {
y = 3;
} else {
// Pour les positions de 20 à 24
y = 4;
}
}
/**
* Version optimisée des fonctions de calcul de x et y.
* Cette méthode est plus concise et efficace.
*/
private static void calculerCoordonneesOptimise() {
// L'opérateur modulo (%) donne le reste d'une division.
// position % 5 donnera toujours un résultat entre 0 et 4.
x = position % 5;
// En Java, la division de deux entiers donne un entier (le reste est ignoré).
// position / 5 donnera 0 pour 0-4, 1 pour 5-9, etc.
y = position / 5;
}
/**
* Bloc "toujours"
* C'est la boucle principale du programme qui s'exécute continuellement.
*/
public static void toujours() {
// Appelle les fonctions pour mettre à jour les coordonnées x et y
calculerValeurX();
calculerValeurY();
// Alternative optimisée :
// calculerCoordonneesOptimise();
// Allume la LED aux nouvelles coordonnées
// Note: l'API réelle peut varier, ex: microbit.display.plot(x, y);
allumerLED(x, y);
}
// --- Méthodes de simulation pour l'affichage LED ---
// Remplacez-les par les vraies méthodes de la bibliothèque micro:bit que vous utilisez.
private static void allumerLED(int x, int y) {
System.out.println("Allumer LED à (" + x + ", " + y + ")");
}
private static void eteindreLED(int x, int y) {
System.out.println("Éteindre LED à (" + x + ", " + y + ")");
}
/**
* Point d'entrée principal pour simuler l'exécution.
*/
public static void main(String[] args) {
auDemarrage();
// Simule une boucle infinie avec quelques pressions de bouton
for (int i = 0; i < 30; i++) {
toujours();
// Simule une pression sur le bouton A tous les 5 cycles
if (i % 5 == 0 && i > 0) {
System.out.println("--- Bouton A pressé ---");
lorsqueLeBoutonAEstPresse();
}
try {
// Petite pause pour ralentir la simulation
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
L'interprétation du code est exacte.
Les notes ajoutées décrivent réellement ce que le code doit faire.
L'IA a reconnu que l'intention du programmeur était d'attribuer une position à chacune des Del du Micro:bit. Reconnaissant qu'il y a seulement 25 DEL sur un micro:bit, elle a déterminer que la valeur de position maximale serait 24 (variant de 0 à 24) et propose un retour à 0 après 24. Ceci n'était pas dans le code, mais faisait partie des améliorations possibles.
Sans l'avoir demandé, l'IA a analysé les concepts mathématiques et a suggéré une équivalence:
Variable y
«Ceci est une façon détaillée d'écrire l'opération "division entière par 5".»
Dans la version optimisée du projet, la série de conditions a été remplacée par une fonction en escalier (partie entière). y=[position/5]
Dans ce cas-ci, l'interprétation est la même.
Variable x
«Ceci est une façon détaillée d'écrire l'opération "modulo 5".»
Dans la version optimisée du projet, la série de conditions a été remplacé par une addition de fonction. x = position -5*[position/5] ou x = position-5y (dans ce cas-ci, la valeur de y doit avoir été calculée avant).
L'utilisation de modulo (reste d'un division) et donne effectivement le même résultat avec moins d'opérations à faire. La proposition de l'IA est donc meilleure que la solution d'optimisation proposée.
Code Java fonctionnel?
Le code Java proposé ne fonctionne pas directement dans Makecode. J'ai également demandé des propositions en JavaScript et Python pour voir si cela fonctionnerait mieux. Les résultats ont également donné des résultats incompatibles. Je n'ai pas poussé l'expérimentation plus loin pour le moment.
Suggestions d'expérimentation pour aller plus loin:
Utiliser le moteur IA proposé dans Makecode pour corriger le code.
Au lieu de prendre une image du code, prendre le code disponnible en JavScript et demander de l'améliorer.