Micro:bit - Codeur morse

Micro:bit - Codeur morse

1. Introduction

Salut l’ami !

Si tu te retrouves ici, c’est que tu as en ta possession une carte micro:bit ! Félicitations ! Tu as l’âme d’un ingénieur doublé de la curiosité d’un aventurier ! Partons ensemble à la découverte des sciences !

Dans ce tutoriel, tu vas apprendre à programmer ta carte micro:bit pour en faire un véritable Codeur/Décodeur Morse à l’aide du logiciel MakeCode. Ta mission sera longue et complexe, mais nous serons en permanence à tes côtés pour te guider pas à pas.

Munis toi de ta carte et suis nous dans cette grande aventure !

C’est parti !

 

2. Présentation de la Carte

Si tu as déjà appris à utiliser ta carte micro:bit, tu peux passer directement à l’étape suivante.

La carte électronique micro:bit que tu as entre les mains est un vrai nano ordinateur créé pour programmer toutes sortes de choses, avec ou sans extensions. Elle est très simple d'utilisation, mais tu peux également t’en servir dans des situations bien plus complexes ; la seule limite est ton imagination.

La carte micro:bit est équipée d'un processeur ARM, de deux boutons, d'une matrice 5x5 LEDs, de 22 broches, d'un accéléromètre, d'un magnétomètre et d'une antenne Bluetooth, ce qui en fait un accessoire parfait pour les objets connectés.

Cela fait beaucoup de mots compliqués, tu ne trouves pas ?

Faisons un petit point rapide.

  • Le Processeur ARM est en quelque sorte le cerveau de ta carte, ce qui va lui permettre de fonctionner.
  • Les deux boutons vont te permettre d’actionner ta carte, pour réaliser diverses actions, en les utilisant ensemble ou indépendamment.
  • La Matrice 5x5 LEDs est constituée de 25 petits points lumineux, que tu pourras utiliser pour écrire des messages ou réaliser des dessins simples.
  • Les 22 broches (dont 3 analogiques) sont métalliques et vont te permettre d’associer de nouveaux accessoires à ta carte et d’effectuer certaines actions spécifiques en les activant ou non.
  • L’Accéléromètre mesure les vibrations ou l’accélération du mouvement de ta carte, ainsi que son inclinaison.
  • Le Magnétomètre est un module servant à mesurer la direction du champ magnétique terrestre et permet donc de se servir de la carte comme d’une boussole.
  • Le Thermomètre mesure, évidemment la température ambiante.
  • Les Capteurs de luminosité et de son permettent d’évaluer le niveau de luminosité ou le volume sonore alentour.
  • Le Buzzer est capable d’émettre quelques sons à la fréquence désirée.
  • L’antenne Bluetooth et l’Émetteur/Récepteur Radio te servirons à envoyer ou recevoir des données sans fil.

Tout ceci ne te sera pas utile pour le programme que nous allons concevoir ensemble, mais tu as dorénavant une bonne idée de tout ce que tu peux envisager de faire avec ta carte.

Passons au codage.

 

4. Le Code Morse

Petit point historique.

Le code Morse est basé sur diverses combinaisons de deux signes seulement (un court, un long). Chaque lettre de l’alphabet correspond à une combinaison. Le signal en code Morse peut être transmis notamment via un son envoyé par radio ou à l’aide d’une lumière que l’on fait clignoter.

En l’occurrence, concernant le télégraphe, il s’agit d’un signal sonore dont on fait varier la durée entre longue et courte. Cela permet de faire un codage binaire.

Telegraphiste

Au départ, il servait à transmettre des télégrammes (messages écrits) via le réseau télégraphique ; le tout premier date de 1844 ! C’était bien avant les SMS ou Internet.

Cela a permis une évolution fulgurante des moyens de communications à travers le monde entier et, a fortiori, des progrès scientifiques et technologiques.

Imagine toi, la première ligne reliant notre continent aux Amériques (des câbles sous-marins traversant l’Atlantique) fût posée en 1858. Il permettait de communiquer quasiment instantanément au-delà de l’océan, alors que le voyage en paquebot prenait une quinzaine de jours.

Voici l’alphabet Morse dans le détail. Par exemple, la lettre S correspond à trois signaux courts d’affilée.

Il nous servira plus tard, tu verras.

En avant pour les premiers programmes !

 

5. Premiers Programmes (1)

Il est temps de se mettre au travail.

Dans un premier temps, tu vas coder ta carte micro:bit pour qu’elle imite le son d’un émetteur Morse.

Pour cela, on va utiliser le bouton A pour le signal court et le B pour le signal long. Dans la réalité, une seule commande est utilisée par les télégraphistes, mais nous reviendrons sur ce point plus tard.

Parmi les « Entrées » disponibles dans MakeCode, trouve le bloc qui déclenche une action lorsqu’un bouton est appuyé (le A tout d’abord).

À l’intérieur de ce bloc, insère une instruction pour que la carte émette un son court (1/4 de temps). Fie-toi au code couleur.

Procède de la même manière pour le bouton B avec un son long (1 temps).

Télécharge ton programme et vérifie qu’il fonctionne comme il faut !

 

6. Premiers Programmes (2)

Pour la suite, nous allons essayer de faire apparaître à l’écran le « symbole » correspondant au bouton : un point pour un signal court et un tiret pour un signal long.

Parmi les instructions de la « Base », trouve celle qui permet d’afficher un texte. Fais en sorte qu’un point apparaisse lorsque tu appuies sur A et un tiret lorsque tu appuies sur B.

Astuce : ajoute une instruction « Effacer l’écran » après chaque affichage, afin d’éteindre la matrice LEDs.

Teste ton programme !

Dans un deuxième temps, tu vas essayer d’associer les symboles entre eux (pour coder un S, par exemple, il faut trois points). On parle de concaténation lorsqu’on place des caractères les uns à la suite des autres.

Une fois que les caractères seront concaténés, ils formeront un « mot » (qui n’aura pas vraiment de sens, puisqu’il ne s’agirait que d’une suite de tirets et de points). Pour que ce mot soit « enregistré » par la carte, tu vas devoir créer une variable.

Une variable est une valeur sauvegardée numériquement et qui peut être modifiée lorsque, par exemple, une condition est vérifiée (exemple : ajouter 1 à chaque seconde, etc.). Cela permet à ton programme de « compter », en quelque sorte.

Également, cela peut s’avérer fort utile lorsqu’une valeur utilisée plusieurs fois dans un même programme doit être modifiée d’un seul coup partout (exemple : tous les voyants lumineux ne s’allument plus en position 2, mais en 3, etc.).

Crée une variable que tu vas appeler, par exemple « Lettre », puisqu’il s’agit de coder une lettre en Morse.

Dans le bloc A (Bouton A), ajoute une instruction pour que la variable Lettre soit définie d'une nouvelle manière : à savoir la concaténation de sa précédente valeur et du nouveau caractère (ici « . »).

Procède de la même manière pour le bloc B, avec le caractère « - ».

Enfin, ajoute un bloc " A+B », qui sera actif si tu appuies en même temps sur A et B. Ce bloc devra afficher le contenu de la variable « Lettre » en intégralité, avant de la redéfinir à zéro (pour la « mise à zéro » utilise l'instruction présentée ci-dessous ; celle qui semblent ne contenir que deux guillemets).

De même, programme le bloc de démarrage pour que la variable Lettre soit vide d'emblée.

Tu le vois, à force, nous te donnons de moins en moins d’indications pour réussir le programme. Plus tu avanceras dans ce tutoriel, plus tu seras indépendant.

Toutefois, clique ici pour découvrir une proposition de correction de ce qui t’es demandé. Il y en aura à découvrir tout au long de ton parcours.

 

7. Décodeur Morse (1)

Cette partie va être divisée en deux étapes très différentes : la première sera assez facile, mais longue à réaliser. Au contraire, la seconde sera brève mais te demandera de la subtilité.

L’intérêt d’un décodeur Morse est qu’il te traduise un signal reçu en la lettre (ou le chiffre) correspondant. Pour cela, il va te falloir lister toutes les possibilités de signal ; à savoir 26 lettres et 10 chiffres. Et cela deux fois puisque il va le falloir pour l’alphabet latin et le Morse.

Dans le bloc de démarrage, sous la création de variable Lettre, définie une nouvelle variable « Alphabet ». Cette variable sera un peu différente de la précédente car elle ne contiendra pas une « valeur » mais 36. Pour cela, dans la partie « Tableaux » trouve l’instruction qui permet de définir une liste de textes (que tu renommeras « Alphabet »). Il ne te reste plus qu’à compléter ce tableau avec les lettres de A à Z et les chiffres de 0 à 9.

Et ce n’est que la première moitié du travail...

À présent, crée une nouvelle variable « Morse » et procède la même façon pour les signaux correspondants. Fais bien attention de les noter dans le même ordre que l’alphabet latin, afin que les symboles associés soient situés au même endroit d’un tableau à l’autre ; c’est primordial pour la suite.

Et veille aussi à ne pas te tromper en recopiant 😊 !

Clique ici pour télécharger ces deux tableaux déjà complétés.

 

8. Décodeur Morse (2)

Les tableaux réalisés, tu dois demander à ton programme de reconnaître les signaux.

En somme, il faut que ta variable Lettre soit retrouvée dans le tableau Morse, puis que l’algorithme repère dans le tableau Alphabet le caractère situé à la même place.

Exemple : si le code de Lettre est « … », il s’agit de la 18ème* case de Morse, ce qui correspond au « S » dans Alphabet.

Tu dois absolument comprendre ce concept avant de passer à la suite.

Comment réaliser cela dans ton programme ?

Sous ton instruction « Afficher Lettre » (dans le bloc A+B), ajoute une autre consigne « Afficher… ».

Dans le même menu où tu as trouvé l’instruction « Tableau », tu trouveras « reçoit la valeur de », que tu insèreras dans le précédent bloc. Le variable Alphabet reçoit une valeur qui lui indique quelle case du tableau elle doit choisir.

Et pour savoir quelle case choisir, elle a besoin d’un index : dans la variable Morse, le programme doit trouver tout seul la variable Lettre.

Détache bien chacune des consignes ici pour réussir ce programme tout seul.

Teste ton programme et compare le avec celui proposé ici.

*il s'agit de la 19ème lettre de l'alphabet, mais elle occupe la case n°18. Nous reviendront sur ce point plus tard.

 

9. Télégraphe

Pour la suite, nous aurons besoin des blocs A et B pour ajouter un codeur Morse à ton décodeur. Tu vas les libérer en transformant ta carte micro:bit en véritable appareil de télégraphie.

Tu l’as lu tout à l’heure, lorsqu’un télégramme était envoyé en Morse, l’opérateur utilisait un appareil capable d’émettre un son plus ou moins long suivant la durée de la pression sur le manipulateur Morse.

Ici, de la façon dont tu as codé ta carte, le fonctionnement est différent et manque, de fait, de vraisemblance.

S’il n’est pas possible de programmer ta carte pour différencier un appui bref d’un long sur les boutons A ou B, il est possible de le faire avec le logo.

Tu es un véritable champion de la programmation si tu es arrivé jusqu’ici ; alors à toi de trouver comment transformer ton programme pour qu’il associe un point à un appui bref sur le logo et un tiret à un appui long.

Enfin, pour que le décodeur « comprenne » que tu as fini d’entrer le signal, ajoute un bloc qui remplacera celui s’activant lorsque A et B sont appuyés en même temps ; par exemple, lorsque la carte est basculé vers l’avant.

Tu trouveras ici une proposition de correction.

Remarque : pour la partie « fin de signal » de ce programme (à la place de la basucle de la carte), tu peux aussi utiliser un chronomètre qui devine que le message est terminé au bout de trois secondes d’inactivité. Tu trouveras ici comment programmer un chronomètre.

 

10. Codeur Morse

On en a fini avec le décodeur.

Ici, tu vas programmer ta carte micro:bit pour qu’elle code en Morse, en plus de tout ce que tu as fait avant.

Maintenant que tu as libéré les blocs A et B, tu vas les utiliser pour faire défiler l’alphabet.

Pour cela, dans le bloc démarrage, crée une variable « Caractère », initiée à 0. Cette variable doit s’incrémenter lorsque tu enclenches un bouton : elle augmente de 1 en appuyant sur B et de -1 (ce qui équivaut à une diminution de 1 – on dira décrémenter) en appuyant sur A.

Attention, si ton tableau contient 36 cases, elles sont « numérotées » de 0 à 35. La lettre A est dans la case n°0. De même, la 19ème lettre S est dans la case n°18...

Puis, dans chacun des blocs, affiche la lettre du tableau Alphabet qui correspond à la case identifiée par la variable ; ainsi, au départ la lettre A apparaît, puis B, puis C, etc. si tu appuies sur le bouton B. On revient en arrière en appuyant sur le bouton A.

Ne confonds pas "Bouton A" et "Lettre A" !

Petite subtilité : que se passe-t-il lorsque ta variable passe sous la barre des 0 ? ou au-dessus de 30 ?

Tu pourrais borner ta variable entre ces deux valeurs pour simplifier les choses, mais ce n’est pas très efficace : en effet, étant donné que ta variable démarre toujours à 0 (numéro de la case contenant A), il faut appuyer plus de vingt fois sur B pour atteindre les chiffres.

Ce qu’il faudrait, c’est pouvoir continuer à défiler en arrière avec le bouton A en passant de « A » à « 9 », puis « 8 », etc. De même en appuyant sur B après « 9 » qui revient à « A », etc.

Afin de réaliser cela, tu vas créer un test logique. Là aussi, il s’agit d’une notion primordiale en programmation. Il permet à un bloc d'instructions de se réaliser uniquement lorsqu'une condition requise est respectée. Exemple : si le niveau luminueux est faible, allumer toutes les LEDs.

Ce test, à incorporer dans le bloc B juste avant d’afficher la variable Lettre, indique que si la variable est à 36, alors elle se redéfinie à 0.

De même, dans le bloc A, si la variable est à -1, elle revient à 35.

Complète ensuite le bloc A+B pour que cela valide la lettre sélectionnée et la convertit en Morse (avant de la remettre à 0).

Pour cela, pas besoin d’utiliser la méthode de l’index vu précédemment : grâce à ta variable Caractère, tu as déjà identifié l’index du tableau. Affiche simplement la case correspondante du tableau Morse avec la bonne instruction.

En programmation, il arrive souvent que l’on prenne beaucoup de temps au départ pour bien installer son code, ses variables, afin qu’à force d’avance dans la complexification, cela soit de plus en plus facile ; tu en as un bon exemple ici.

 

11. Codeur Morse Sonore

L'aventure se poursuit !

Fais en sorte que ton codeur Morse émettent les bips sonores correspondant à la lettre que tu as sélectionnée en même temps que les signaux s’affichent.

Pour cela, il va te falloir créer un bloc qui « lit » la Lettre reçue en détachant les signaux un par un.

Tu dois programmer une boucle itérative, ce qui est également une notion extrêmement importante en informatique. Retiens-la !

Il s’agit d’une instruction que se répète un certain nombre de fois dans un programme, tant qu’une condition de fin n’est pas survenu.

Trouve seul où sont cachées les boucles dans MakeCode.

La boucle que tu dois créer va avoir un index qui va aller de 0 (premier caractère contenu dans la variable Lettre) jusqu’à… la longueur de la variable Lettre ! S’il y a trois symboles, il faut effectuer l’itération trois fois.

À l’intérieur de la boucle, il faut deux tests logiques :

- Si le symbole lu est un « . », il faut jouer la note qui dure ¼ de temps ;

- Si le symbole lu est un « - », il faut jouer la note qui dure 1 temps.

De plus, pour éviter que les notes s’enchaînent sans distinction, ajoute un repos d’un quart de temps après les tests logiques (à l’intérieur de la boucle itérative).

Teste ton programme jusqu'à ce qu'il fonctionne !

 

12. Émetteur Radio

Pour finir, nous te proposons cette dernière étape. Il te faut une deuxième carte Micro:Bit pour la réaliser ; vous allez pouvoir vous transmettre des messages codés entre amis !

Ta carte dispose d’un émetteur radio.

Pour l’utiliser, tu dois d’abord définir un groupe de radio commun. Dans notre exemple, nous avons choisi le numéro 4.

Lorsque tu appuies sur A+B, ta carte doit émettre par radio la valeur de Caractère que tu as sélectionnée.

En réaction, la carte qui recevra ce message devra émettre les bips sonores correspondant au code, afin qu’il n’y ait plus qu’à le traduire.

Tu n'as pas besoin d'ajouter beaucoup d'instructions par rapport au programme précédent : tu dois simplement réussir à les réorganiser pour accomplir la mission qui t'est proposé ici.

Clique ici pour voir notre proposition de rédaction.

 

13. Conclusion

Voici qui conclut cette aventure « télégraphique » ! Nous espérons que tu as réussi à faire un maximum d’exercice tout seul et que tu es fier de ton programme !

D’autres tutoriels t’attendent ici si tu veux continuer à explorer toutes les possibilités de ta carte micro:bit.

Et si tu veux aller encore plus loin avec des accessoires dédiés, consulte les programmes des Coffrets SmarteoWorlds SmartCity, SpaceMission et FairyTales: tu y trouveras sans doute ton bonheur !


À bientôt pour de nouvelles aventures !

Laissez un commentaire

* Champs obligatoires

Veuillez noter que les commentaires doivent être vérifiés et approuvés avant d'être publiés.

Réservé aux abonnés

 

Ce contenu est uniquement réservé aux abonnés. Si vous avez souscrit à l'un de nos abonnements, veuillez vous connecter pour accéder au contenu. Si vous n'êtes pas encore abonné, vous pouvez accéder au détail de nos abonnements ICI.