29 917
modifications
Modifications
Sauter à la navigation
Sauter à la recherche
Ligne 1 :
Ligne 1 : − + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FEATHER-CHARGER-FICHIER-MICROPYTHON-RUNCODE (voir la source)
Version du 13 novembre 2016 à 11:43
, 13 novembre 2016 à 11:43aucun résumé de modification
{{FEATHER-CHARGER-FICHIER-MICROPYTHON-NAV}}
{{FEATHER-CHARGER-FICHIER-MICROPYTHON-NAV}}
{{traduction}}
== Introduction ==
{{ambox|text=Avant d'utiliser ampy avec un ESP8266, vous devez avoir désactivé la sortie de débogage (si nécessaire). Voyez la page [[FEATHER-CHARGER-FICHIER-MICROPYTHON-DEBUG|Désactiver la sortie
DEBUG de l'ESP8266]]}}
En utilisant {{fname|ampy}}, vous pouvez prendre du code python écrit sur votre odrinateur et l'exécuter sur sur un carte MicroPython connectée en USB-Série. Cela permet d'explorer MicroPython en utilisant un flux de traitement assez simple. Vous pouvez écrire vitre code sur votre ordinateur, dans votre éditeur de texte favoris, puis utiliser ampy pour l'exécuter sur la carte!
== Exécuter (run) ==
Utilisez la commande '''{{fname|run}}''' (exécuter) et spécifiez simplement le chemin du fichier Python présent sur votre ordinateur, attendez la fin de son exécution, voyez les sorties (''instruction print')'') affichés par le programme.
Créez le fichier d'exemple '''test.py''' sur votre ordinateur et copiez/collez y le code Pyhton suivant:
<syntaxhighlight lang="python">
print('Hello world! I can count to 10:')
for i in range(1,11):
print(i)
</syntaxhighlight>
Ouvrez un terminal et placez vous dans le même répertoire que votre fichier test.py. Exécutez ensuite la commande ampy suivante pour exécuter le script sur votre carte MicroPython connectée en USB-Séerie:
<nowiki>ampy --port /port/serie run test.py</nowiki>
Où '''/port/serie''' est le chemin (ou nom) du port série correspondant à votre carte MicroPython connectée sur le port USB de votre ordinateur. Sur une machine Lunix (ex: Linux Mint, dérivé d'Ubuntu) cela se présente sous la forme /dev/ttyUSB0
{{ambox|text=Si vous ne voulez pas préciser continuellement l'option --port dans la ligne de commande alors vous pouvez initialiser la variable d'envrionnement AMPY_PORT dans votre session terminal. Ampy utilisera automatiquement la valeur de la variable d'environnement si aucun port n'est précisé.}}
Après exécution de la commande, vous devriez voir les sortie du scripts sur votre moniteur:
{{ADFImage|FEATHER-CHARGER-FICHIER-MICROPYTHON-RUNCODE-00.png}}
'''Si vous recevez une erreur stipulant que ampy n'a pas reçu la réponse attendue (''failed to receive the expected response'') c'est probablement parce que la sortie des message de débogage n'a pas été désactivé sur carte. Voyez le lien mentionné en haut de page!''' Vérifiez également que votre carte est bien connéectée sur votre ordinateur et que vous avez spécifié correctement le port série de la carte. Finalement, assurez vous également que le fichier test.py se trouve bien dans le répertoire où vous vous trouvez (celui où vous allez exécuter ampy).
'''Attention: la commande {{fname|run}} n'est pas un shell ou un outil qui permet d'envoyer des entrées (données) depuis l'ordinateur vers la carte!''' Si vous avez besoin d'envoyer des entrées/données vers la carte alors vous aurez besoin de connecter la carte et [[FEATHER-CHARGER-MICROPYTHON-SERIAL-REPL|d'utiliser le REPL Série]].
Par défaut la commande {{fname|run}} attendra la fin d'exécution du script sur la carte avant d'afficher la sortie. Parfois, il arrive que vous n'ayez pas besoin de cette fonctionnalité --par exemple, lorsque votre script principal est une boucle infinie qui ne se termine jamais, auquel cas ampy attend indéfiniment la fin du script! Dans ce cas, ajoutez l'option '''--no-output''' à la commande {{fname|run}}. Ce flag/drapeau informe ampy qu'il ne doit pas attendre de sortie de la part du script et n'attend donc pas la fin d'exécution de celui-ci. Ampy exécute le script et rend la main immédiatement au terminal.
Par exemple: modifiez le script '''test.py''' de façon à ce qu'il fasse un comptage à l'intérieur d'une boucle infinie:
<syntaxhighlight lang="python">
import time
print('Hello world! I can count:')
i = 1
while True:
print(i)
i += 1
time.sleep(1.0) # attendre une seconde.
</syntaxhighlight>
Exécutez ensuite le script sur votre carte avec l'option '''--no-output'''. Comme vous pourrez le constater, ampy rend immédiatement la main au système d'exploitation:
<nowiki>ampy --port /serial/port run --no-output test.py</nowiki>
Vous pouvez néanmoins ouvrir une session REPL Série et voir le compte augmenter chaque seconde!
{{ADFImage|FEATHER-CHARGER-FICHIER-MICROPYTHON-RUNCODE-01.png}}
Gardez à l'esprit que le programme est toujours en cours d'exécution, ampy n'attend simplement pas qu'il se termine!
== Comparaison avec Arduino ==
L'option '''--no-output''' est particulièrement approprié lorsque vous exécutez des scripts qui ressemblent au fonctionnement des croquis/sketch Arduino. Dans le monde Arduino, vous avez les fonctions '''setup''' et '''loop''' explicites qu'il faut remplir avec du code qui est exécuté une fois pour (dans '''setup''') et duc code exécuté en boucle (dans '''loop''').
MicroPython ne dispose pas de ce concept mais vous pouvez facilement le re-créer dans vos propres scripts Python!
Si vous jetez un coup d'oeil au script '''test.py''' ci-dessus, vous noterez que:
* tout le code '''situé avant''' l'instruction {{fname|while True}} fonctionne comme la fonction {{fname|setup()}} d'Arduino (exécuté une seule fois au démarrage du programme/script).
* tout le code '''situé à l'intérieur''' de l'instruction {{fname|while True}} fonctionne comme la fonction {{fname|loop()}} d'Arduino (le contenu est exécuté encore et encore et encore... à l'infini)
Pour rendre cela un peu plus clair, voici le fichier '''test.py''' avec des commentaire qui indique où se trouve la code correspondant à {{fname|setup()}} et le code correspondant à {{fname|loop()}}:
<syntaxhighlight lang="python">
###########################################################################
# Code setup() début ci-dessous, il est appelé au démarrage du programme #
###########################################################################
import time
print('Hello world! I can count:')
i = 1
while True:
###################################################################
# Code loop() inclus dans la boucle infinie. #
# Cette section de code est appelé répétitivement #
###################################################################
print(i)
i += 1
time.sleep(1.0) # Delay for 1 second.
</syntaxhighlight>
Si vous découvrez MicroPython alors que vous possédez déjà un savoir faire Arduino alors vous trouverez cette approche pratique pour garder la même façon de travailler qu'avec vos Arduino.
Placez votre code d'initialisation (setup) en premier puis écrivez votre code répétitif dans une boucle infinie {{fname|while True}}.
Ajoutez simplement l'option '''--no-output''' à l'instruction ampy pour que ampy n'attende pas la fin de l'exécution de votre script!
{{FEATHER-CHARGER-FICHIER-MICROPYTHON-TRAILER}}
{{FEATHER-CHARGER-FICHIER-MICROPYTHON-TRAILER}}