Embedded Python: Construisez un jeu sur BBC micro: bit – Real Python

Avantages de l'utilisation de Python

Le principal avantage que Python apporte lors de la création d'un système embarqué est la vitesse de développement. Python a des bibliothèques disponibles pour la plupart des tâches, et cela reste principalement vrai pour ses implémentations intégrées. Vous pouvez vous concentrer sur la création de votre système, car la plupart des problèmes que vous rencontrez ont déjà été résolus.

Étant donné que Python est de plus haut niveau que les autres langages intégrés courants, le code que vous écrirez sera plus concis. Cela accélère le développement, ce qui signifie que vous écrivez du code plus rapidement, mais cela permet également de garder votre code compréhensible.

Python est géré en mémoire. C ++, un choix courant pour le développement embarqué, ne l'est pas. En C ++, vous êtes responsable de la libération de la mémoire lorsque vous en avez terminé, ce qui est très facile à oublier, ce qui entraîne un manque de mémoire dans votre programme. Python fait cela pour vous.

Inconvénients de l'utilisation de Python

Bien que la gestion de la mémoire de Python soit d'une grande aide, elle entraîne une vitesse et un coût de mémoire mineurs. La documentation MicroPython a une bonne discussion sur les problèmes de mémoire.

Une autre chose à considérer est que le Python interprète lui-même prend de la place. Avec un langage compilé, la taille de votre programme dépend uniquement de votre programme, mais les programmes Python ont besoin de l'interpréteur qui les exécute. L'interpréteur Python utilise également de la RAM. Sur le micro: bit, vous ne pouvez pas écrire de code Bluetooth avec Python car il n'y a pas assez de place pour Python et Bluetooth en même temps.

Puisque Python est interprété, il ne peut jamais être assez aussi rapide qu'un langage compilé. Un langage interprété doit décoder chaque instruction avant de l'exécuter, mais un langage compilé peut simplement s'exécuter. En pratique, cependant, cela importe rarement car les programmes Python s'exécutent encore assez rapidement pour la plupart des cas d'utilisation.

Points à surveiller lors de la découverte du développement intégré

Les ordinateurs modernes ont beaucoup de mémoire pour travailler. Lorsque vous les programmez, vous n’avez pas à vous soucier trop de la taille des listes que vous créez ou du chargement d’un fichier entier à la fois. Les systèmes embarqués ont cependant une mémoire limitée. Vous devez faire attention lors de l'écriture de vos programmes à ne pas avoir trop de choses en mémoire à la fois.

De même, vitesses du processeur sur les systèmes embarqués sont beaucoup plus lents que sur les ordinateurs de bureau. La vitesse du processeur détermine la rapidité avec laquelle votre code est exécuté, donc l'exécution d'un programme sur un ordinateur intégré prendra plus de temps que de l'exécuter sur un ordinateur de bureau. Il est plus important de penser à l’efficacité du code intégré. Vous ne voulez pas qu’il soit trop long pour s’exécuter!

Le plus grand changement lors de la programmation de systèmes embarqués concerne peut-être les besoins en énergie. Les ordinateurs portables, les téléphones et les ordinateurs de bureau se branchent sur le mur ou ont de grandes batteries. Les systèmes embarqués ont souvent des piles minuscules et doivent durer très longtemps, parfois même des années. Chaque ligne de code que vous exécutez coûte un peu d'autonomie, et tout s'additionne.

Voici quelques autres choses dont vous devez être conscient lorsque vous commencez:

• Si vous disposez d'une connexion réseau sur votre appareil, il est probable qu'elle soit lente ou peu fiable.
• Vous avez un choix beaucoup plus restreint de bibliothèques.
• Les systèmes embarqués n'ont généralement pas une grande quantité de stockage persistant.

Le développement intégré est un vaste domaine, avec beaucoup à apprendre pour les nouveaux arrivants. Pour l’instant, rappelez-vous simplement qu’il est plus important d’écrire du code allégé sur les systèmes embarqués. Cela rend les systèmes embarqués parfaits pour apprendre l'efficacité de votre code!

BBC micro: bit

Le BBC micro: bit est un système embarqué conçu pour un usage éducatif. À bord d'un micro: bit, il y a beaucoup de composants, y compris des boutons, un écran LED 5×5, un haut-parleur et un microphone, un accéléromètre et un module Bluetooth. Malheureusement, le module Bluetooth est inutilisable avec Python, mais vous pouvez toujours utiliser la radio directement. Il est programmable en Scratch, JavaScript et, surtout, Python.

En voici une photo de l’arrière montrant quelques-uns des composants intéressants disponibles:

Le micro: bit propose de nombreuses ressources en ligne pour vous aider à démarrer et à proposer des idées de projets.

Tarte aux framboises

La plupart des Raspberry Pis sont techniquement des ordinateurs à carte unique au lieu de systèmes embarqués, mais ils permettent tous d'accéder au matériel externe via leurs broches GPIO. Une exception à la règle est le Raspberry Pi Pico, qui est une carte de développement de microcontrôleur. D'autres Raspberry Pis exécutent Linux, ce qui signifie que vous pouvez les utiliser comme un ordinateur complet, et tous les Pis prennent en charge Python dès la sortie de la boîte.

Il existe quelques modèles différents de Raspberry Pi disponibles, mais tous sont capables d'exécuter Python et de travailler avec l'électronique. Le modèle que vous devez choisir dépend des besoins de votre projet. Voici l’un des derniers modèles:

Vous pouvez en savoir plus sur les différents modèles du Raspberry Pi sur le site officiel. Pour un exemple de projet que vous pouvez réaliser avec un Raspberry Pi et Python, consultez Créer des projets physiques avec Python sur le Raspberry Pi.

pyboard

Le pyboard est une carte de développement électronique conçue pour exécuter MicroPython. Il est beaucoup plus puissant qu’un micro: bit, mais il est livré sans avantages supplémentaires comme l’écran de bord et les capteurs du micro: bit. Voici le pyboard 1.0:

Vous remarquerez peut-être beaucoup de cercles dorés sur le tableau. Ceux-ci sont appelés épingles et sont utilisés pour connecter le pyboard à d'autres composants électroniques. Par exemple, si vous construisez une voiture télécommandée, vous pouvez y connecter des moteurs.

Autres

Il existe de nombreuses cartes et kits compatibles Python, bien trop nombreux pour être listés ici. Cependant, il y en a quelques-uns intéressants à signaler:

• Le LoPy de Pycom se connecte aux réseaux spécialisés de l'Internet des objets tels que LoRa et Sigfox.
• Les cartes basées sur ESP8266 exécutent toutes MicroPython. L'ESP8266 est un microcontrôleur compatible Wi-Fi bon marché. Ses successeurs, la famille de puces ESP32, exécutent également tous MicroPython.
• Python fonctionne également sur la Nintendo DS. La configuration semble un peu compliquée pour les débutants, mais ce projet est trop amusant pour ne pas être mentionné.

Il y a beaucoup plus de cartes compatibles MicroPython pour lesquelles ce didacticiel a de l'espace. Vous devriez faire des recherches pour trouver celui qui convient à vos projets. Un bon point de départ pourrait être le magasin MicroPython d'Adafruit.

MicroPython

MicroPython est l'implémentation Python intégrée standard de facto. Il s'agit d'une implémentation Python 3.x conçue pour fonctionner sur des microcontrôleurs. Ce n'est pas 100% compatible CPython, mais c'est très proche. Cela signifie que si vous avez écrit du code à exécuter sur des versions jusqu'à Python 3.4, il y a de fortes chances que vous puissiez l'exécuter en MicroPython.

CircuitPython

CircuitPython est un fork de MicroPython qui prend en charge une liste légèrement différente de cartes et a quelques modifications pour le rendre plus convivial pour les débutants. Pour la plupart, votre expérience sera très similaire lors de l'utilisation de CircuitPython et lors de l'utilisation de MicroPython. Vous pouvez choisir d'utiliser CircuitPython si votre carte ne le prend en charge et pas d'autres implémentations.

Configuration de votre environnement

Que vous ayez ou non un micro: bit physique, le chemin le plus rapide pour commencer à coder est d'utiliser les éditeurs en ligne disponibles. Pour ce didacticiel, vous utiliserez l'éditeur create.withcode. Lorsque vous ouvrez l'éditeur, vous verrez l'écran suivant:

La majeure partie de l'écran est occupée par le tampon de texte où vous pouvez entrer votre code. En bas à droite, vous verrez un bouton de lecture. Cela vous permettra d'exécuter votre code une fois que vous l'avez écrit.

Affichage des instructions à l'écran

La première chose que votre jeu doit faire est de trouver une direction et de la dire au joueur. Pour les besoins de ce jeu, vous pouvez utiliser trois directions: la gauche, droite, et reste tranquille. Votre code devra choisir l'une de ces directions et l'afficher au joueur. Ce sera enveloppé dans un infini tandis que loop afin qu'il puisse s'exécuter plusieurs fois.

Voici à quoi pourrait ressembler votre code:

de microbit importer *
de Aléatoire importer Randrange

# Définissez à gauche, restez immobile et à droite
directions = [[[["L", "O", "R"]

# Pendant que le micro: bit est allumé
tandis que Vrai:
    # Choisissez une direction aléatoire
    direction = directions[[[[Randrange(3)]
    affichage.spectacle(direction)
    # Dormez pendant une seconde (1000ms)
    dormir(1000)

Ce code affichera une direction aléatoire différente chaque seconde. Les deux premières lignes importent les fonctions nécessaires:

1. le microbit Le module contient tout le code nécessaire pour s'interfacer avec le micro: bit. Par exemple, le affichage et accéléromètre les modules sont ici. le microbit Le module est pré-chargé avec MicroPython sur le micro: bit, vous pouvez donc rencontrer une erreur si vous essayez de l'importer lors de l'exécution de code sur votre ordinateur.
2. le Aléatoire module vous permet de choisir un nombre aléatoire.

Après les importations, le code définit le directions liste. Celui-ci contient trois caractères qui représentent les directions disponibles. L'avantage de définir cette liste avec des caractères est qu'ils peuvent être affichés directement car l'écran micro: bit n'a de place que pour un caractère à la fois.

le tandis que Vrai: loop dit au micro: bit d'exécuter le code à l'intérieur pour toujours. En réalité, cela signifie qu'il fonctionnera pendant que le micro: bit est alimenté. À l'intérieur, le code choisit d'abord une direction aléatoire avec randrange () et le montre. Ensuite, il dort une seconde. Cela oblige le micro: bit à ne rien faire pendant une seconde, ce qui garantit que le joueur a le temps de voir les instructions.

Exécution de votre code

Maintenant que vous avez du code, vous pouvez l'exécuter! Heureusement, vous n'avez pas besoin d'un micro: bit pour exécuter votre code car votre éditeur est livré avec un simulateur intégré. Vous pouvez y accéder et exécuter votre code en cliquant sur le bouton de lecture dans le coin inférieur droit.

Lorsque vous cliquez sur le bouton de lecture, la fenêtre contextuelle de superposition suivante s'affiche dans votre éditeur:

Dans celui-ci, vous verrez un micro: bit, et l'écran devrait afficher des caractères aléatoires de la liste des itinéraires. Sinon, essayez de copier le code ci-dessus dans l'éditeur et cliquez à nouveau sur le bouton de lecture.

Il s’agit du flux de développement général que vous suivrez pour le reste du didacticiel.

Facultatif: exécutez votre code sur un micro: bit physique

Si vous avez un micro: bit physique, il y a quelques étapes supplémentaires pour exécuter votre code. Vous devrez télécharger un .hex puis copiez-le sur votre micro: bit.

Pour télécharger le .hex fichier, recherchez le bouton suivant dans votre éditeur:

Cela vous demandera d'enregistrer le fichier sur votre ordinateur. Enregistrez-le, puis récupérez votre micro: bit. Connectez votre micro: bit à votre ordinateur à l'aide d'un câble USB. Vous devriez le voir apparaître de la même manière que les clés USB.

Pour programmer le micro: bit, faites glisser le fichier téléchargé .hex fichier sur votre micro: bit. Une LED rouge à l'arrière de votre micro: bit devrait clignoter. Une fois qu'il s'arrête, votre programme est chargé sur l'appareil et commencera à s'exécuter immédiatement!

Maintenant que vous avez configuré votre micro: bit pour le développement, vous êtes prêt à passer au codage.

Obtenir l'entrée du joueur

Maintenant que le micro: bit peut dire au joueur quoi faire, il est temps d’obtenir les commentaires du joueur. Pour ce faire, vous utiliserez le accéléromètre. Un accéléromètre est un appareil qui mesure le mouvement. Il peut dire si le micro: bit se déplace dans une direction spécifique, et surtout pour le jeu, si le micro: bit s'incline dans une direction spécifique. Jetez un œil au diagramme suivant:

Dans le diagramme, vous verrez trois axes: X, Y et Z. Ce sont exactement comme les axes que vous auriez pu voir dans les graphiques à l'école. L'axe X représente le mouvement d'un côté à l'autre, l'axe Y représente le mouvement de haut en bas et l'axe Z représente le mouvement vers ou loin de vous.

L'accéléromètre sur le micro: bit renvoie les valeurs de ces trois axes. Étant donné que votre jeu ne se soucie que de l'inclinaison vers la gauche et la droite, tout ce dont vous aurez besoin est l'axe X pour le moment. accelerometer.get_x () renvoie les valeurs de la plage (-2000, 2000), où -2000 est incliné complètement vers la gauche et 2000 est incliné complètement vers la droite.

Votre code pour obtenir l'entrée du joueur devra suivre trois étapes:

1. Lisez la valeur X de l’accéléromètre.
2. Décidez si cette valeur X représente un mouvement à gauche, à droite ou immobile.
3. Décidez si c'était la bonne direction pour vous déplacer.

Voici le code pour accomplir ces étapes:

# Code précédent ...

tandis que Vrai:
    # Code précédent ...

    # Obtenez l'inclinaison de l'axe X (gauche-droite)
    acc_x = accéléromètre.get_x()
    # Déterminer la direction
    si acc_x < -200:
        player_in = "L"
    elif abdos(acc_x) < 200:
        player_in = "O"
    elif acc_x > 200:
        player_in = "R"

    # Vérifier la condition de victoire
    si player_in == direction:
        # Entrée du joueur correctement
        affichage.spectacle(Image.HEUREUX)
    autre:
        affichage.spectacle(Image.TRISTE)
    dormir(1000)

Ce code est un peu plus long car vous devez vérifier un grand nombre de conditions différentes. La première chose que vous faites est d'obtenir la valeur de l'axe X de l'accéléromètre avec accelerometer.get_x (). Rappelez-vous, ce sera dans la plage (-2000, 2000).

Après avoir obtenu la valeur X, vous exécutez une série de vérifications pour déterminer le mouvement qu'elle représente. Tout ce qui est supérieur à 200 dans les deux sens est considéré comme une inclinaison, et rien de moins que 200 est considéré comme restant immobile.

abdos() permet de raccourcir le code en supprimant le signe négatif de la valeur de l'accéléromètre. Cela signifie que les nombres de la plage (-200, 200) sera considéré comme restant immobile. Vous voudrez peut-être jouer avec ce seuil pour rendre le jeu plus ou moins difficile.

Après avoir obtenu l'entrée directionnelle du lecteur, vous vérifiez si elle était correcte ou non. Si c'était la bonne direction, le code affiche un visage heureux. Sinon, il affiche un visage triste. Le code se met alors en veille pendant une seconde pour permettre au joueur de voir le résultat sans qu'il disparaisse très rapidement.

Test du code d'accéléromètre dans le simulateur

Étant donné que l'accéléromètre est un capteur qui détecte les mouvements physiques, vous vous demandez peut-être comment interagir avec lui dans le simulateur. Heureusement, le simulateur fournit un accéléromètre virtuel que vous pouvez contrôler avec votre souris.

Exécutez votre code de la même manière que vous l'avez fait auparavant, en cliquant sur le bouton de lecture dans le coin inférieur droit. Vous verrez apparaître la superposition micro: bit. La superposition a quelques onglets en haut qui contrôlent les différents composants du micro: bit. Cliquez sur l'onglet étiqueté Accéléromètre.

Dans cet onglet, vous verrez trois curseurs, un pour chaque axe. Vous utiliserez le curseur de l'axe X pour tester votre jeu.

Lorsque vous déplacez le curseur vers la droite, la valeur X de l'accéléromètre augmente. De même, lorsque vous déplacez le curseur vers la gauche, la valeur X diminue. Cela équivaut à incliner le micro: bit à gauche et à droite et vous permet de jouer à votre jeu dans le navigateur.

Points et perdre

Maintenant que le jeu de base est en place, il est temps de penser à ajouter des points et à perdre pour terminer le jeu. Rappelez-vous que le comportement décrit dans la spécification était que lorsque le joueur perdait, le micro: bit afficherait le total de points que le joueur avait obtenu jusqu'à ce point. Si le joueur réussit, le micro: bit ne doit rien afficher:

# Code précédent ...
points = 0

tandis que Vrai:
    # Code précédent ...

    si player_in == direction:
        # La saisie du joueur est correcte
        points + = 1
    autre:
        affichage.faire défiler(points)
        affichage.spectacle(Image.TRISTE)
        points = 0
        dormir(1000)

Heureusement, il s'agit d'un changement plus petit que l'étape précédente. En dehors de la tandis que boucle, vous définissez une variable points qui suivra les points du joueur.

Plus bas, vous avez modifié la vérification pour savoir si l’entrée du joueur était dans la bonne direction. Si le joueur a bougé dans la bonne direction, vous augmentez son total de points de 1. Sinon, vous faites défiler le total des points sur l'écran avec display.scroll (), montrez un visage triste et réinitialisez le total de points.

Tu bouges aussi dormir() dans le code de perte car aucune image n'est affichée pour la corriger. Cela rend le jeu un peu plus difficile!

Pour vous aider à vérifier votre code et à consolider ce que vous avez appris, voici le code complet du jeu:

de microbit importer affichage, Image, accéléromètre, dormir
de Aléatoire importer Randrange

# Définissez à gauche, restez immobile et à droite
directions = [[[["L", "O", "R"]
points = 0

# Pendant que le micro: bit est allumé
tandis que Vrai:
    # Choisissez une direction aléatoire
    direction = directions[[[[Randrange(3)]
    affichage.spectacle(direction)
    # Dormez pendant une seconde (1000ms)
    dormir(1000)

    # Obtenez l'inclinaison de l'axe X (gauche-droite)
    acc_x = accéléromètre.get_x()
    # Déterminer la direction
    si acc_x < -200:
        player_in = "L"
    elif abdos(acc_x) < 200:
        player_in = "O"
    elif acc_x > 200:
        player_in = "R"

    # Vérifier la condition de victoire
    si player_in == direction:
        # La saisie du joueur est correcte
        points + = 1
    autre:
        affichage.faire défiler(points)
        affichage.spectacle(Image.TRISTE)
        points = 0
        dormir(1000)

Félicitations pour la création de votre propre jeu! Vous remarquerez que ce code occupe un peu plus de trente lignes, commentaires compris, ce qui est beaucoup plus court qu'un programme équivalent dans un langage intégré traditionnel.

Allez plus loin

Voilà, vous avez construit un jeu complet sur un système embarqué! Si vous voulez des défis supplémentaires, voici quelques idées:

• Incorporez les autres axes de l'accéléromètre et transformez-le en une version micro: bit de Bop It!
• Réduisez le temps dont dispose le joueur pour déplacer le micro: bit s'il obtient un certain nombre correct. Quel est le temps le plus court que vous puissiez faire? Pourquoi pensez-vous que c'est?
• Incluez les gestes de l'accéléromètre. Hors de la boîte, le micro: bit peut détecter les tremblements, le fait d'être face vers le bas ou face vers le haut, et même d'entrer en chute libre.
• Ajoutez des fonctionnalités multijoueurs pour pouvoir jouer avec des amis. Le micro: bit a un module radio qui permet la communication entre micro: bits.

Cette liste n'est pas définitive mais devrait plutôt vous faire réfléchir. Si vous trouvez un moyen sympa d'étendre le jeu, partagez-le dans les commentaires!

Ressources micro: bit

L'une des meilleures choses à propos du micro: bit est l'énorme collection de ressources éducatives disponibles:

La Fondation pour l'éducation Micro: bit a récemment publié une deuxième version du micro: bit qui, espérons-le, encouragera une toute nouvelle vague de ressources.

Autres cartes qui exécutent Python

Le micro: bit n’est pas la seule carte sur le marché. Il vaut vraiment la peine d’explorer pour trouver celui qui convient à votre projet:

• Tutoriels sur la carte MicroPython: MicroPython propose des didacticiels officiels pour certaines des cartes qu'il prend en charge. Par exemple, voici celui de l'ESP8266.
• Projets Hackaday étiquetés MicroPython: Ce site présente des résumés de projets que les gens ont construits et qui pourraient vous inspirer!
• Tutoriels Pycom: Pycom fabrique des cartes compatibles MicroPython qui ont la capacité de se connecter à divers réseaux. Ces didacticiels sont un bon moyen de se faire une idée de ce qui est possible.

Il existe de nombreux autres appareils intéressants qui exécutent Python. Vous serez sûr de trouver celui qui correspond à votre projet.