FEATHER-CHARGER-FICHIER-MICROPYTHON-RUNCODE - Historique des versions

Admin le 13 novembre 2016 à 11:43

2016-11-13T11:43:50Z

Admin le 13 novembre 2016 à 11:00

2016-11-13T11:00:28Z

Admin le 13 novembre 2016 à 10:22

2016-11-13T10:22:02Z

Admin le 13 novembre 2016 à 09:52

2016-11-13T09:52:41Z

Admin le 13 novembre 2016 à 09:52

2016-11-13T09:52:06Z

Admin le 8 novembre 2016 à 22:35

2016-11-08T22:35:37Z

Admin le 8 novembre 2016 à 22:35

2016-11-08T22:35:20Z

Admin : Page créée avec « {{FEATHER-CHARGER-FICHIER-MICROPYTHON-NAV}} {{traduction}} {{FEATHER-CHARGER-FICHIER-MICROPYTHON-TRAILER}} »

2016-11-08T21:16:44Z

Page créée avec « {{FEATHER-CHARGER-FICHIER-MICROPYTHON-NAV}} {{traduction}} {{FEATHER-CHARGER-FICHIER-MICROPYTHON-TRAILER}} »

Nouvelle page

@@ Ligne 1 : / Ligne 1 : @@
 {{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!}}
+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!
 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.
@@ Ligne 58 : / Ligne 58 : @@
 Gardez à l'esprit que le programme est toujours en cours d'exécution, ampy n'attend simplement pas qu'il se termine!
-L'option '''--no-output''' est particulièrement approprié lorsque vous exécutez des scripts qui ressemblent au fonctionnement des croquis/sketch Arduino. {{traduction}} In Arduino you have an explicit '''setup''' and '''loop''' function which you fill in with code that runs once (in '''setup''') and code that runs forever (in '''loop''').  MicroPython doesn't have exactly the same concept, but you can create it yourself in your own Python scripts!
+== Comparaison avec Arduino ==
-In fact look at the '''test.py''' above and notice all the code before the '''while True''' loop is like the '''setup''' function from an Arduino sketch, it's executed just once at the start of the program.  Then the code inside the '''while True''' loop is like the '''loop''' function from Arduino, this code runs repeatedly as fast as possible.  To make it a little more clear here's the '''test.py''' with comments that show where the setup code goes and where the loop code goes:
+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">
 ###########################################################################
-# Setup code goes below, this is called once at the start of the program: #
+# Code setup() début ci-dessous, il est appelé au démarrage du programme  #
 ###########################################################################
 import time
@@ Ligne 72 : / Ligne 80 : @@
 while True:
      ###################################################################
-     # Loop code goes inside the loop here, this is called repeatedly: #
+     # Code loop() inclus dans la boucle infinie.                      #
      ###################################################################
      print(i)
@@ Ligne 79 : / Ligne 88 : @@
   </syntaxhighlight>
-If you're coming to MicroPython with a background in Arduino, consider writing your MicroPython scripts in a similar style as the above.  Put your setup code first and then a main loop that runs forever.  Just be sure you add the '''--no-output''' option when running with ampy so it knows not to wait for the script to finish!
+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.
 {{FEATHER-CHARGER-FICHIER-MICROPYTHON-TRAILER}}

@@ Ligne 34 : / Ligne 34 : @@
 '''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]].
-{{traduction}}
+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.
-By default the run command will wait for the script to finish running on the board before printing its output.  In some cases you don't want this behavior--for example if your script has a main or infinite loop that never returns you don't want ampy to sit around waiting forever for it to finish.  In this case add the '''--no-output''' option to the run command.  This flag tells ampy not to wait for any output and instead just start running the script and return.
+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">
@@ Ligne 47 : / Ligne 45 : @@
      print(i)
      i += 1
-     time.sleep(1.0)  # Delay for 1 second.
+     time.sleep(1.0)  # attendre une seconde.
   </syntaxhighlight>
-Then run it with the '''--no-output''' option and notice it immediately returns:
+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>
-However open the board's serial REPL and watch it count numbers every second!
+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}}
-Remember the program is still running, ampy just didn't wait for it to stop!
+Gardez à l'esprit que le programme est toujours en cours d'exécution, ampy n'attend simplement pas qu'il se termine!
-The '''--no-output''' option is great for writing scripts that are like an Arduino sketch.  In Arduino you have an explicit '''setup''' and '''loop''' function which you fill in with code that runs once (in '''setup''') and code that runs forever (in '''loop''').  MicroPython doesn't have exactly the same concept, but you can create it yourself in your own Python scripts!
+L'option '''--no-output''' est particulièrement approprié lorsque vous exécutez des scripts qui ressemblent au fonctionnement des croquis/sketch Arduino. {{traduction}} In Arduino you have an explicit '''setup''' and '''loop''' function which you fill in with code that runs once (in '''setup''') and code that runs forever (in '''loop''').  MicroPython doesn't have exactly the same concept, but you can create it yourself in your own Python scripts!
 In fact look at the '''test.py''' above and notice all the code before the '''while True''' loop is like the '''setup''' function from an Arduino sketch, it's executed just once at the start of the program.  Then the code inside the '''while True''' loop is like the '''loop''' function from Arduino, this code runs repeatedly as fast as possible.  To make it a little more clear here's the '''test.py''' with comments that show where the setup code goes and where the loop code goes:

@@ Ligne 3 : / Ligne 3 : @@
 {{traduction}}
-{{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ésact]]}}
+{{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
-Using {{fname|ampy}} you can take Python code written on your computer and run it on a connected MicroPython board.  This gives you a simple workflow for exploring MicroPython.  Write code on your computer in your favorite text editor, then use ampy's '''run''' command to run it on a board!
+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!}}
-To use the '''run''' command just specify a path to a Python file on your computer.  Ampy will send the file to the board, wait for it to finish running, and print any output from the program.
+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.
-For example create a file '''test.py''' on your computer and save inside it the following Python code:
+Créez le fichier d'exemple '''test.py''' sur votre ordinateur et copiez/collez y le code Pyhton suivant:
   <syntaxhighlight lang="python">
@@ Ligne 17 : / Ligne 18 : @@
   </syntaxhighlight>
-In a terminal in the same directory as test.py run the following ampy command to execute the script on a connected MicroPython board:
+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 /serial/port run test.py</nowiki>
+  <nowiki>ampy --port /port/serie run test.py</nowiki>
-Where '''/serial/port''' is the path or name of the serial port connected to the MicroPython board.
+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=If you don't want to constantly specify the --port option you can set the AMPY_PORT environment variable in your terminal session and ampy will use it as the board's serial port.}}
+   {{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é.}}
-You should see the output of the code after it was run on the board:
+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}}
-'''If you receive an error that ampy failed to receive the expected response be sure you disabled debug output as mentioned at the top of the page!'''  Also double check the board is connected to your computer and you are specifying the correct serial port for the board.  Be sure the file test.py is in the same directory as you're running the ampy command too.
+'''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).
-'''Be aware the run command is not a shell or tool that allows you to send input from your computer to the board!''' If you need to send input you'll want to connect to the board and [[FEATHER-CHARGER-MICROPYTHON-SERIAL-REPL|use its serial REPL]].
+'''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]].
 By default the run command will wait for the script to finish running on the board before printing its output.  In some cases you don't want this behavior--for example if your script has a main or infinite loop that never returns you don't want ampy to sit around waiting forever for it to finish.  In this case add the '''--no-output''' option to the run command.  This flag tells ampy not to wait for any output and instead just start running the script and return.

@@ Ligne 3 : / Ligne 3 : @@
 {{traduction}}
-{{ambox|text=Avant d'utiliser ampy avec un ESP8266, vous devez avoir désactivé la sortie de débogage (si nécessaire). Voyez notre page [[x|x]]}}
+{{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ésact]]}}
 Using {{fname|ampy}} you can take Python code written on your computer and run it on a connected MicroPython board.  This gives you a simple workflow for exploring MicroPython.  Write code on your computer in your favorite text editor, then use ampy's '''run''' command to run it on a board!

@@ Ligne 3 : / Ligne 3 : @@
 {{traduction}}
-{{ambox|text=Before using ampy with the ESP8266 be sure you've disabled debug output if necessary: https://learn.adafruit.com/micropython-basics-load-files-and-run-code/disable-esp8266-debug-output}}
+{{ambox|text=Avant d'utiliser ampy avec un ESP8266, vous devez avoir désactivé la sortie de débogage (si nécessaire). Voyez notre page [[x|x]]}}
 Using {{fname|ampy}} you can take Python code written on your computer and run it on a connected MicroPython board.  This gives you a simple workflow for exploring MicroPython.  Write code on your computer in your favorite text editor, then use ampy's '''run''' command to run it on a board!

← Version précédente		Version du 8 novembre 2016 à 22:35
Ligne 2 :		Ligne 2 :

	{{traduction}}		{{traduction}}
		+
		+	{{ambox\|text=Before using ampy with the ESP8266 be sure you've disabled debug output if necessary: https://learn.adafruit.com/micropython-basics-load-files-and-run-code/disable-esp8266-debug-output}}
		+
		+	Using {{fname\|ampy}} you can take Python code written on your computer and run it on a connected MicroPython board. This gives you a simple workflow for exploring MicroPython. Write code on your computer in your favorite text editor, then use ampy's '''run''' command to run it on a board!
		+
		+	To use the '''run''' command just specify a path to a Python file on your computer. Ampy will send the file to the board, wait for it to finish running, and print any output from the program.
		+
		+	For example create a file '''test.py''' on your computer and save inside it the following Python code:
		+
		+	<syntaxhighlight lang="python">
		+	print('Hello world! I can count to 10:')
		+	for i in range(1,11):
		+	print(i)
		+	</syntaxhighlight>
		+
		+	In a terminal in the same directory as test.py run the following ampy command to execute the script on a connected MicroPython board:
		+
		+	<nowiki>ampy --port /serial/port run test.py<nowiki>
		+
		+	Where '''/serial/port''' is the path or name of the serial port connected to the MicroPython board.
		+
		+	{{ambox\|text=If you don't want to constantly specify the --port option you can set the AMPY_PORT environment variable in your terminal session and ampy will use it as the board's serial port.}}
		+
		+	You should see the output of the code after it was run on the board:
		+
		+	{{ADFImage\|FEATHER-CHARGER-FICHIER-MICROPYTHON-RUNCODE-00.png}}
		+
		+	'''If you receive an error that ampy failed to receive the expected response be sure you disabled debug output as mentioned at the top of the page!''' Also double check the board is connected to your computer and you are specifying the correct serial port for the board. Be sure the file test.py is in the same directory as you're running the ampy command too.
		+
		+	'''Be aware the run command is not a shell or tool that allows you to send input from your computer to the board!''' If you need to send input you'll want to connect to the board and [[FEATHER-CHARGER-MICROPYTHON-SERIAL-REPL\|use its serial REPL]].
		+
		+	By default the run command will wait for the script to finish running on the board before printing its output. In some cases you don't want this behavior--for example if your script has a main or infinite loop that never returns you don't want ampy to sit around waiting forever for it to finish. In this case add the '''--no-output''' option to the run command. This flag tells ampy not to wait for any output and instead just start running the script and return.
		+
		+	For example modify the '''test.py''' script so that it counts numbers forever in an infinite loop:
		+
		+	<syntaxhighlight lang="python">
		+	import time
		+	print('Hello world! I can count:')
		+	i = 1
		+	while True:
		+	print(i)
		+	i += 1
		+	time.sleep(1.0) # Delay for 1 second.
		+	</syntaxhighlight>
		+
		+	Then run it with the '''--no-output''' option and notice it immediately returns:
		+
		+	<nowiki>ampy --port /serial/port run --no-output test.py</nowiki>
		+
		+	However open the board's serial REPL and watch it count numbers every second!
		+
		+	{{ADFImage\|FEATHER-CHARGER-FICHIER-MICROPYTHON-RUNCODE-01.png}}
		+
		+	Remember the program is still running, ampy just didn't wait for it to stop!
		+
		+	The '''--no-output''' option is great for writing scripts that are like an Arduino sketch. In Arduino you have an explicit '''setup''' and '''loop''' function which you fill in with code that runs once (in '''setup''') and code that runs forever (in '''loop'''). MicroPython doesn't have exactly the same concept, but you can create it yourself in your own Python scripts!
		+
		+	In fact look at the '''test.py''' above and notice all the code before the '''while True''' loop is like the '''setup''' function from an Arduino sketch, it's executed just once at the start of the program. Then the code inside the '''while True''' loop is like the '''loop''' function from Arduino, this code runs repeatedly as fast as possible. To make it a little more clear here's the '''test.py''' with comments that show where the setup code goes and where the loop code goes:
		+
		+	<syntaxhighlight lang="python">
		+	###########################################################################
		+	# Setup code goes below, this is called once at the start of the program: #
		+	###########################################################################
		+	import time
		+	print('Hello world! I can count:')
		+	i = 1
		+
		+	while True:
		+	###################################################################
		+	# Loop code goes inside the loop here, this is called repeatedly: #
		+	###################################################################
		+	print(i)
		+	i += 1
		+	time.sleep(1.0) # Delay for 1 second.
		+	</syntaxhighlight>
		+
		+	If you're coming to MicroPython with a background in Arduino, consider writing your MicroPython scripts in a similar style as the above. Put your setup code first and then a main loop that runs forever. Just be sure you add the '''--no-output''' option when running with ampy so it knows not to wait for the script to finish!

	{{FEATHER-CHARGER-FICHIER-MICROPYTHON-TRAILER}}		{{FEATHER-CHARGER-FICHIER-MICROPYTHON-TRAILER}}