Commits

tuck...@gmail.com  committed 86f0c82 Draft

doc fix

  • Participants
  • Parent commits e735e14

Comments (0)

Files changed (4)

File source/ipm.rst

 IPM : une console python
 ========================
 
-IPM est une console python interactive permettant d'exécuter le code
-directement sur le STM32F4. Malheureusement cette fonctionnalité n'est
-pas encore disponible pour le STM32F4. Le projet compile mais rien
-ne s'exécute sur la carte. Pour la simple et bonne raison que le code
-devant assurer le lien entre le shell côté PC et le STM32F4 ne communiquent pas.
+IPM est une console python interactive permettant d'exécuter votre code
+directement sur le STM32F4. Il y a différent éléments à connaître pour
+utiliser correctement cette console interactive.
 
+    - Le mode interactif n'est disponible que si vous modifiez le fichier main.py
+      afin d'exécuter la fonction ipm. Il peut se résumer à::
 
-nénamoins si vous souhaitez développez les fonctions qu'il manque. L'effort
-nécessaire, ne paraît pas gigantesque, les autres projets pouvant faire office
-d'exemple.
+           import ipm
+           ipm.ipm()
+
+    - Le mode interactif peut être utilisé directement sans le debugger et le lien st-util.
+      En effet, si vous modifiez le fichier ./src/platform/stm32f4/main.py pour exécuter
+      la fonction ipm, ce sera toujours ce programme qui sera exécuté au démarrage du
+      STM32F4. Lorsque votre programme sera prêt vous pourrez modifier le fichier 
+      ./src/platform/stm32f4/main.py pour exécutez votre fonction principale. Le fichier
+      ./src/platform/stm32f4/main.py contient quelques exemples qui vous permettrons aisément
+      de débuter.
+
+    - Toutes les commandes python ne sont pas disponibles dans cette console:
+        Par exemple actuellement, la fonction int(), n'est pas disponible.
+        la liste des commandes disponibles est celle décrite dans le répertoire lib
+        et plus particulièrement __bi.py
+
+        .. note::
+
+            int() peut être aisément remplacé par la fonction string.atoi (à besoin, on peut
+            également compléter le module __bi.py
+            ipm> from string import atoi
+            ipm> a="123"
+            ipm> len(a)
+            # atoi prend un second paramètre pour indiquer la base de calcul
+            # (la base 10 est utilisé par défaut)
+            # mais il n'est pas obligatoire
+            ipm> atoi(a) + 4
+            ipm> 138
+
+    - Toutes commandes inconnues ou nom inconnu se verra gratifié d'une jolie exception::
+
+            PM_RET_EX_NAME: Name error
+            Error:     0xEA
+              Release: 0x08
+              FileId:  0x00
+              LineNum: 0
+            Traceback (top first):
+              <ipm>()
+              ipm()
+              launch_ipm()
+              main()
+              main()
+              <module>.
+            ipm> 
+
+    - Vos propres modules doivent être également compilés pour la plateform STM32F4 :
+            Si vous souhaitez utiliser vos modules dans le mode ipm, il faudra se rappeler
+            qu'il est nécessaire de modifier le fichier ./src/platform/stm32F4/SConscript
+            afin d'ajouter votre module.
+            Recherchez la ligne contenant la déclaration des sources : PY_SOURCES::
+
+                PY_SOURCES = ["main.py", "stm32f4discovery.py", "gpio.py", "pin.py", "lcd.py", "wire.py"]
+                # et ajouter votre module pour qu'il soit compilé
+                PY_SOURCES = ["main.py", "stm32f4discovery.py", "gpio.py", "pin.py", "lcd.py", "wire.py","my_tool"]
+                # n'oubliez pas de recompiler le projet ensuite et de le recharger sur la carte
+                sconscript PLATFORM=stm32f4
+                # puis recharger le binaire pour le STM32F4
+
+Plus concrètement :
 
     o brancher le foca :
 
         - brancher le port RXD sur PA2
 
     o compiler ipm ::
+
         make ipm
         #démarrer la console ipm
         python ipm.py -f ../platform/stm32f4/pmfeatures.py  --serial=/dev/ttyUSB0 --baud=57600
 
     o modifier la vitesse de transfert (57600 par défaut) ::
+
         # modifier le fichier platform/stm32f4/SConscript et transformer la valeur 9600 en 57600
         # si ce n'est pas déjà le cas ...
 

File source/lcd/tutorials.rst

+==============================
+Un écran LCD en mode caractère
+==============================
+
+Tous les exemples décris ici, utilisent le mode ipm (mode interactif).
+Mais vous pouvez naturellement, modifier le fichier main.py afin qu'il
+contienne l'exemple souhaité sans utiliser le mode interactif. Ce dernier
+apporte juste une grande facilité pour tester ses fonctions. Vous pouvez
+également l'utiliser pour tester vos propres fonctions en ajoutant
+un module dans la liste des modules compilés par SConscript (cf :ipm:)
+
+
+1) exemple de montage (version 4bits):
+
+        +---------------+--------------+
+        |    LCD        |   STM32F4    |
+        +===============+==============+
+        |    +5v        |     +5v      |
+        +---------------+--------------+
+        |    GND        |     GND      |
+        +---------------+--------------+
+        |    RW         |    PE7       |
+        +---------------+--------------+
+        |    E          |    PE8       |
+        +---------------+--------------+
+        |    D4         |    PE9       |
+        +---------------+--------------+
+        |    D5         |    PE10      |
+        +---------------+--------------+
+        |    D6         |    PE11      |
+        +---------------+--------------+
+        |    D7         |    PE12      |
+        +---------------+--------------+
+
+2) utiliser le mode interactif (ipm) un premier exemple !::
+
+        # importe le module python nécessaire
+        from lcd import LiquidCrystal
+        # spécifie les broches de sorties sur le STM32F4
+        from pin import *
+        screen = LiquidCrystal(PE7, None, PE8, PE9, PE10, PE11, PE12)
+        # spécifie la dimension du lcd taille : 2 lignes x 16 colonnes
+        screen.begin(16,2)
+        # affiche TEOMAN on the first line
+        screen.prnt("TEOMAN")
+        # se déplace sur la deuxième ligne
+        screen.setCursor(0,1)
+        # affiche Hello World sur la deuxième ligne
+        screen.prnt("Hello World!")
+
+2) une boucle avec ipm !::
+
+        import sys
+        from lcd import LiquidCrystal
+        from pin import *
+        screen = LiquidCrystal(PE7, None, PE8, PE9, PE10, PE11, PE12)
+        screen.begin(16,2) ; screen.clear() ; screen.home()
+
+        # ne boucle pour faire clignoter notre texte
+        # noter que vous pouvez succédez plusieurs commandes
+        # sur la même ligne grâce au caracètre ';'
+        for i in range(0,100):
+            
+            screen.prnt("Hello World")
+            screen.setCursor(0,0) ; sys.wait(300)
+            screen.prnt("           ")
+            screen.setCursor(0,0) ; sys.wait(300)
+
+Voilà quelques exemples qui j'espère vous permettrons d'utiliser simplement votre LCD
+

File source/tutorial_part1.rst

-Utiliser gdb et exécuter un premier code sur la carte :
--------------------------------------------------------
+------------------------------------------
+Utiliser gdb et exécuter un premier code :
+------------------------------------------
 
     1. connecter votre STM32F4 :
 
         - 1 pour la compilation
         - 1 pour la console gdb permettant de charger le code sur le STM32F4
 
-        .. code-block :: sh
+        sh::
 
             - cd ~/stm32f4_work
             - screen
             - CTRL+A+P : précédent TAB
 
     3. démarrer le listener !::
+
         - # ce placer dans le bon répertoire ...
         - cd ~/stm32f4_work/stlink
         - steph@tuck-eeepc:~/stm32f4_work/stlink$ sudo ./gdbserver/st-util fu bar
 
     4. éditer son projet 
         le module principal de votre projet se trouve sous ~/stm32f4_work/pymite-09/src/platform/stm32f4
-        et se nomme **main.py**
-
-        .. code-block :: sh
+        et se nomme **main.py**::
 
             gvim ~/stm32f4_work/pymite-09/src/platform/stm32f4/main.py
 
         # note la commande est sensible à la cas et attend l'argument PLATFORM  en majuscule.
         - scons PLATFORM=stm32f4
 
-    6. exécuter son projet
-
-        .. code-block :: sh
+    6. exécuter son projet::
 
                 cd ~/stm32f4_work/pymite-0.9/src/platform/stm32f4
                 # si votre path est bien configuré l'appel de arm-none-eabi-gdb devrait se dérouler correctement

File source/tutorials/blinking_led.rst

 
    La carte STM32F4 possède 4 LEDs que l'on peut piloter, soit directement
    grâce au mode interactif, soit au sein de votre programme
+        
+        python2.6 ipm.py -f ../platform/stm32f4/pmfeatures.py  --serial=/dev/ttyUSB0 --baud=57600
 
         syntaxe ::
-            >> import stm32f4discovery as x
+
+            ipm> import stm32f4discovery as x
             # allume la première LED
             # dans notre exemple le deuxième argument (100) peut prendre une valeur
             # allant de 0 à 255
-            >> x.LED(0,100)
+            ipm> x.LED(0,100)
             # éteind la LED
-            >> x.LED(0,0)
-            >> import sys
+            ipm> x.LED(0,0)
+            ipm> import sys
             # une boucle qui fait clignoter la LED
             # avec un temps d'attente de 400ms entre chaque action
-            >> while True:
-                  
-                  sys.wait(400)
-                  x.LED(0,100)
-                  sys.wait(400)
-                  x.LED(0,0)
+            ipm> while True:
+            ....   sys.wait(400)
+            ....   x.LED(0,100)
+            ....   sys.wait(400)
+            ....   x.LED(0,0)
 
 
 2) Faire clignoter une LED branchée sur le port E7.
    connectez la LED ainsi que la résistance dont vous aurez calculé
    la valeur. Il ne reste plus qu'à la faire clignoter.
 
+        python2.6 ipm.py -f ../platform/stm32f4/pmfeatures.py  --serial=/dev/ttyUSB0 --baud=57600
+
         syntaxe ::
+
             # import les différents modules et fonctions nécessaires
-            >> import sys
-            >> from pin import PE7
-            >> from gpio import pin_mode, digital_write, OUTPUT, INPUT, HIGH, LOW
+            ipm> import sys
+            ipm> from pin import PE7
+            ipm> from gpio import pin_mode, digital_write, OUTPUT, INPUT, HIGH, LOW
             # configure le port PE7 en sortie
-            >> pin_mode(PE7, OUTPUT)
-            >> while True:
-                   
-                   sys.wait(400)
-                   digital_write(PE7, HIGH)
-                   sys.wait(400)
-                   digital_write(PE7, LOW)
+            ipm> pin_mode(PE7, OUTPUT)
+            ipm> while True:
+            ....    sys.wait(400)
+            ....    digital_write(PE7, HIGH)
+            ....    sys.wait(400)
+            ....    digital_write(PE7, LOW)
 
+2) Commander une LED branchée sur le port E7 grâce au bouton utilisateur (le bleu ...)
+   Suivez le schéma de montage, branchez tous les éléments sur plaque de test
+   connectez la LED ainsi que la résistance dont vous aurez calculé
+   la valeur. Il ne reste plus qu'à écrire le code dans le prompt interactif
 
+        python2.6 ipm.py -f ../platform/stm32f4/pmfeatures.py  --serial=/dev/ttyUSB0 --baud=57600
 
+        syntaxe ::
+
+            # import les différents modules et fonctions nécessaires
+            ipm> import stm32f4discovery as x
+            ipm> import sys
+            ipm> from pin import PE7
+            ipm> from gpio import pin_mode, digital_write, OUTPUT, INPUT, HIGH, LOW
+            ipm> pin_mode(PE7, OUTPUT)
+            ipm> while True :
+            ....     while 0==x.BTN():
+            ....       sys.gc()
+            ....       sys.wait(100) 
+            ....     while 0==x.BTN():
+            ....       digital_write(PE7,HIGH)
+            ....       sys.wait(300)
+            ....       digital_write(PE7,LOW)
+            ....       sys.wait(300)
+