1. tuck
  2. pymite_stm32f4

Commits

step...@gmail.com  committed f9175b6 Merge

merge fix

  • Participants
  • Parent commits 42b803f, e4dcf07
  • Branches default

Comments (0)

Files changed (13)

File .hgignore

View file
 .swp
 build
+st_documentation

File source/_static/keepmee.txt

Empty file added.

File source/console/keepmee.txt

Empty file added.

File source/documents/PROGRAMING_MANUAL_056.pdf

Binary file added.

File source/documents/USER_MANUAL_UM1472.pdf

Binary file added.

File source/documents/foca.pdf

Binary file added.

File source/ethernet/ethernet.rst

View file
+==================================
+STM32F4 et son contrôleur ETHERNET
+==================================
+
+    o Info :
+        Le STM32F4 embarque un contrôleur Ethernet 10/100 possédant un DMA dédié qui supporte tout matériel IEEE 1588v2, MII/RMII
+        ce qui signifie, que la seul chose qui manque c'est la couche d'accès matériel nommée (PHY) et un connecteur MAGJACK.
+
+        Il est relativement simple de se procurer ce composant...
+        `PHY <http://blog.tkjelectronics.dk/2012/08/ethernet-on-stm32f4discovery-using-external-phy>`_
+
+
+    o Extension (PHY) possible  :
+ 
+        - DP83848 (~ 20 euros) 
+          un peu de doc sur le `module <http://www.ti.com/general/docs/lit/getliterature.tsp?svadoc=dp83848c&reg=en>`_
+
+    o Comment appliquer :
+        
+        a) Acheter un DP83848 Phy breakout board (ou similaire)
+
+          .. figure:: /images/DP83848.jpg
+             :align: center
+
+        b) Connecter le DP83848 PHY au STM32F4DISCOVERY en respectant le schéma de cable ci-dessous
+        
+          .. figure:: /images/Ethernet-connections.png 
+             :align: center
+

File source/ethernet/keepmee.txt

Empty file added.

File source/index.rst

View file
 
     Cette documentation ne porte que sur la plateforme linux. Il sera donc nécessaire de la compléter pour win32, et Mac Os.
 
-
 .. warning ::
     
     Pymite ne fonctionne qu'avec PYTHON 2.6 et rien d'autre
 
 .. warning ::
     
-    Il est relativement important de récupérer les sources proposés par J.SCHEMOUL
+    ipm ne fonctionne pas encore sur le STM32F4, pour la simple raison que le code qui devrait assurer cette fonction
+    n'est pas développé (cf le fichier plat.c où il reste à développer la communication avec la liaison série,
+    pour récupérer le code à exécuter ainsi que renvoyer le résultat de l'exécution)
+
+.. warning ::
+    
+    Il est relativement important de récupérer les sources proposés par J.SCHEMOUL (cf pycon fr 2012)
     pour le STM32F4. en attendant d'avoir un packaging simple à proposer.
+    sinon les dépôts suivant pour remplacer ces éléments, il restera à vous procurer la toolchain
+    fournie par ST (arm-none-eabi-gdb) :
+    
+    - `pymite fork <https://bitbucket.org/tuck/pymite>`_ (ce dépôt est à jour et résout pas mal de problème de compilation)
 
+    - `stlink <https://github.com/texane/stlink>`_ (ce dépôt est à jour et est nettement plus performant que l'archive de pycon)
 
 .. toctree::
    :maxdepth: 2
 
    installation
    tutorial_part1
-   ETHERNET/ethernet
+   ipm
+   ethernet/ethernet
 
 
 Introduction sur la plaque STM32F4 (discovery) :
 
 + quelques éléments de documentation :
 
-   * un document commercial sur la carte "Discovery" :
+   * un document commercial sur la carte "Discovery" intitulé `Manuel Utilisateur <http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/USER_MANUAL/DM00039084.pdf>`_
 
-    - http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/USER_MANUAL/DM00039084.pdf
+   * un `document technique <http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/DATASHEET/DM00037051.pdf>`_ plus complet mais plus technique ...
 
-   *  un document plus complet mais plus technique ... :
+   * la page `Ressources <http://www.st.com/stonline/stappl/resourceSelector/app?page=resourceSelectorPage&doctype=st_software_rsrc&SubClassID=1521>`_ où l'on peut télécharger la documentation complète :
 
-    - http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/DATASHEET/DM00037051.pdf
-
-   * la page où l'on peut télécharger la documentation complète :
-
-    - http://www.st.com/stonline/stappl/resourceSelector/app?page=resourceSelectorPage&doctype=st_software_rsrc&SubClassID=1521
-      sélectionnez ensuite l'archive
+    - sélectionnez ensuite l'archive
       *STM32F4 DSP and standard peripherals library, including 82 examples for 26 different peripherals and template project for 5 different IDEs*
       cette archive contient notamment, un fichier .chm contenant toute la documentation sur la librairie c/c++ mis à disposition ainsi que
       les 82 exemples en c/c++. Ce qui pourrait faire un point de départ intéressant pour tous les gens qui souhaitent développer des
       librairies pour permettre d'accéder à des périphériques internes ou externes.
 
-   * un blog sur le STM32F4 : http://www.emcu.it/STM32F4xx/STM32F4xx.html
+   * un `blog <http://www.emcu.it/STM32F4xx/STM32F4xx.html>`_ sur le STM32F4
 
    * le portage japonais de pymite pour le STM32F4 (avec une démo de IPM): http://stm32f4.web.fc2.com/pymite.html
 
 
     * les plus : 
         
-            - Coût/Puissance : Une carte très intéressante car moins cher qu'un arduino basic, mais nettement plus puissante.
-                Comprenez : l'arduino apparait alors comme un tracteur et pour un coût bien plus élevé.
-                            Enfin bon, on trouve toujours des fans de moisonneuse :)
+            - Coût/Puissance : Une carte très intéressante (12€ -> 17€ selon les sites) car moins cher qu'un arduino basic,
+                mais nettement plus puissante. Comprenez : L'arduino apparait alors comme un tracteur et pour un coût bien
+                plus élevé. Enfin bon, on trouve toujours des fans de moisonneuse :)
 
-            - Des périphériques en plus : (Accéléromètre, leds incorporés, possibilité de lire du son)
+            - Des périphériques en plus : (Accéléromètre, leds incorporés, possibilité de lire et d'enregistrer du son)
                     
             - Language : Python 2.6, grâce à la mémoire dont il dispose, on arrive à embarquer
-                une vm python et votre programme python. Ceci est rendu possible grâce au projet pymite
+                une vm python et votre programme python. Ceci est rendu possible grâce au projet `pymite <http://code.google.com/p/python-on-a-chip>`_
 
             - GPIO : la carte est très riche côté pin /GPIO (un plus face à l'arduino de base)
 
 
             - Documentation :
               
-            très peu de documentation END USER, de blog, tutorial, ou site parlant de cette
-            plateforme. Apparement ce sont des japonais qui se sont intéressés les premiers à cette plateforme
-            pour y intégrer python.
+                très peu de documentation END USER, de blog, tutorial, ou site parlant de cette
+                plateforme. Apparement ce sont des japonais qui se sont intéressés les premiers à cette plateforme
+                pour y intégrer python.
 
             - Librairies :
             
-            Il y a nettement moins de librairies pour accéder à des périphérique comme
-            un écran LCD. La plateforme est par contre plus récente que l'Arduino et ne bénéficie donc
-            pas d'une communeauté aussi forte ...
+                Il y a nettement moins de librairies pour accéder à des périphérique comme
+                un écran LCD. La plateforme est par contre plus récente que l'Arduino et ne bénéficie donc
+                pas d'une communeauté aussi forte ...
             
             - Packaging & Debug :
               
-            Un manque certain de facilité, par rapport à l'IDE de l'ARDUINO où toutes
-            les difficulté techniques sont masqués à l'utilisateur. Le debug n'est pas inclu également ...
+                Un manque certain de facilité, par rapport à l'IDE de l'ARDUINO où toutes
+                les difficulté techniques sont masqués à l'utilisateur. Le debug n'est pas inclu également ...
 
 .. note::
 
-    Si vous voulez faire du debug, il vous faut rajouter un petit bout d'électronique pour
-    utiliser la console série (UART) de la carte (on branche deux fils sur les pattes qui vont bien
+    Si vous voulez faire du debug, il vous faut rajouter un petit bout d'électronique (FOCA) pour
+    utiliser la console série (UART) de la carte (on branche deux fils nécessaires : TXD=>PA3 et RXD=>PA2 qui vont bien
     et on connecte l'engin sur un autre port usb, il ne restera plus qu'à écouter sur l'usb
-    avec putty par exemple : 
+    avec putty par exemple :
     
     .. code-block :: sh
 
 sur un micro controleur. La vm fonctionne avec des greenthreads, scheduler interne qui gère les
 threads ...
 
-    - Le wiki officiel : http://wiki.python.org/moin/PyMite
+    - `Le wiki officiel <http://wiki.python.org/moin/PyMite>`_
 
-    - Le projet python on a chip : http://code.google.com/p/python-on-a-chip/
+    - `Le projet python on a chip <http://code.google.com/p/python-on-a-chip>`_
 
 
 Indices and tables

File source/installation.rst

View file
         
         .. note::
 
-            J.SCHEMOUL devrait publier dans peu de temps un dépôt sur github ou bitbucket contenant
-            les éléments nécessaires. Ceux-ci étaient fournis lors de l'atelier
+            Suite à l'atelier sur le STM32F4 (pycon fr 2012), un dépôt devrait publier dans peu de temps 
+            sur github ou bitbucket contenant les éléments nécessaires, tout du moins ceux qui étaient
+            fournis lors de l'atelier. En attendant ces éléments cette documentation essaira de couvrir
+            les urls, dépôts permettant d'être autonome et de tenir à jour son projet.
 
         .. note::
 
-            Il parait relativement important de reprendre les sources de J.SCHEMOUL qui semble règler
-            pas mal de problèmes
+            Il parait relativement important de se tenir à jour de l'évolution du projet et d'avoir
+            les dernière versions des différents packages.
 
     * pour le reste de la documentation on supposera que tout se passe dans un répertoire
-      créé pour l'exemple :
-      
-        .. code-block :: sh
+      créé pour l'exemple ::
 
-                   virtualenv --python=python2.6 myvenv
-                   source ./myvenv/bin/activate
-                   mkdir ~/stm32f4_work
-                   cp stlink.tar.gz ~/stm32f4_work
-                   cp pymite-09.tar.gz ~/stm32f4_work
-                   cp arm-2011.09-69-arm-none-eabi.bin ~/stm32f4_work
+           virtualenv --python=python2.6 myvenv
+           source ./myvenv/bin/activate
+           mkdir ~/stm32f4_work
+           cp stlink.tar.gz ~/stm32f4_work
+           cp pymite-09.tar.gz ~/stm32f4_work
+           cp arm-2011.09-69-arm-none-eabi.bin ~/stm32f4_work
 
     * installer la chaîne de compilation
 
-        - exécuter le binaire arm-2011.09-69-arm-none-eabi.bin
+        - exécuter le binaire arm-2011.09-69-arm-none-eabi.bin::
 
-            .. code-block :: sh
-
-                       cd ~/stm32f4_work
-                      ./arm-2011.09-69-arm-none-eabi.bin
-
+               cd ~/stm32f4_work
+               ./arm-2011.09-69-arm-none-eabi.bin
 
             vous pouvez exécuter ce binaire depuis votre utilisateur habituel (pas besoin de sudo)
             cela exécute un installeur basé en java, suivre la procédure d'installation, le programme
              + ~/Sourcery_CodeBench_Lite_for_ARM_EABI
              + ~/CodeSourcery/
 
-        - rendre accessible le binaire arm-none-eabi-gdb pour cela modifier votre PATH :
+        - rendre accessible le binaire arm-none-eabi-gdb pour cela modifier votre PATH ::
 
-            .. code-block :: sh
+               export PATH=$PATH:~/CodeSourcery/Sourcery_CodeBench_Lite_for_ARM_EABI/bin/
 
-                        export PATH=$PATH:~/CodeSourcery/Sourcery_CodeBench_Lite_for_ARM_EABI/bin/
+        - installer des librairies nécessaires (facultatif et fonction du système ...)::
 
-        - installer des librairies nécessaires (facultatif et fonction du système ...) :
+                sudo apt-get install libusb--dev
+                sudo apt-get install libusb-1.0-0
+                sudo apt-get install libusb-1.0-0-dev
+                sudo apt-get install libsgutils2-dev
+                sudo apt-get install scons
 
-            .. code-block :: sh
+        - compiler stlink: stlink peut être obtenue à partir d'un dépôt directement depuis github::
 
-                        sudo apt-get install libusb--dev
-                        sudo apt-get install libusb-1.0-0
-                        sudo apt-get install libusb-1.0-0-dev
-                        sudo apt-get install libsgutils2-dev
-                        sudo apt-get install scons
+            git clone https://github.com/texane/stlink stlink
+            # please read README file ...
+            ./autogen.sh
+            ./configure
+            make
 
-        - compiler stlink :
+            .. note::
+                    
+                    Pour ceux qui l'archive tar.gz fournie lors de pycon.fr 2012, les sources disponibles
+                    depuis github sont sans commune mesure plus à jour. Il est donc fortement recommandée
+                    d'utiliser ce dépôt. J'ai pu constater d'importantes différences dans les temps de chargement
+                    du binaire sur le STM32F4 entre les 2 versions. C'est donc un projet qui évolue vite, n'hésitez
+                    donc pas à **mettre à jour stlink régulièrement**
+ 
 
-            .. code-block :: sh
-
-                        cd ~/stm32f4_work
-                        tar -zxvf stlink.tar.gz
-                        cd stlink
-                        make
             .. note::
 
-                   En cas de problème de compilation, regarder du côté des librairies de développement
+                   En cas de problème de compilation, regarder du côté des librairies de développement. La plus
+                   part du temps, les messages d'erreurs sont explicites et indiquent clairement ce qu'il manque.
+                   (is google youre friend ?)
 
-        - décompresser l'archive de pymite  :
+        - décompresser l'archive de pymite ou récupèrer le projet depuis bitbucket :
 
-            .. code-block :: sh
+            si vous avez déjà l'archive pymite::
+              cd ~/stm32f4_work
+              tar -zxvf pymite-09.tar.gz
 
-                        cd ~/stm32f4_work
-                        tar -zxvf pymite-09.tar.gz
+            dans le cas contraire s ::
+              hg clone https://bitbucket.org/tuck/pymite
 
+

File source/ipm.rst

View file
+========================
+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.
+
+
+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.
+
+    o brancher le foca :
+
+        - brancher le port TXD sur PA3
+
+        - 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=9600
+
+    o modifier la vitesse de transfert (9600 par défaut) ::
+        # modifier le fichier platform/stm32f4/SConscript et transformer la valeur 9600 en 57600
+
+        vars.Add("PM_UART_BAUD", "Baud rate of the ipm serial connection.", "9600")
+        vars.Add("PM_UART_ALT_BAUD", "ALT Baud rate of the ipm serial connection.", "9600")
+
+        # pour passer à 57600 bauds (nettement plus rapide :) )
+
+        vars.Add("PM_UART_BAUD", "Baud rate of the ipm serial connection.", "57600")
+        vars.Add("PM_UART_ALT_BAUD", "ALT Baud rate of the ipm serial connection.", "57600")
+        
+        # recompiler ensuite le binaire et recharger le main.elf sur le STM32F4
+        scons PLATFORM=stm32f4
+
+.. note::
+
+    Pour rappel (comme toujours) tout doit être exécuté et compilé avec python 2.6
+

File source/lcd/keepmee.txt

Empty file added.

File source/tutorial_part1.rst

View file
         - 1 pour la compilation
         - 1 pour la console gdb permettant de charger le code sur le STM32F4
 
-        .. note::
-
-        Je conseille d'utiliser screen (en attendant d'avoir un IDE, dédié / ou pas ...)
-
         .. code-block :: sh
 
-            cd ~/stm32f4_work
-            screen
-            export PATH=$PATH:~/CodeSourcery/Sourcery_CodeBench_Lite_for_ARM_EABI/bin/
-            # CTRL+A+C : un nouveau TAB
-            # CTRL+A+N : prochain TAB
-            # CTRL+A+P : précédent TAB
+            - cd ~/stm32f4_work
+            - screen
+            - export PATH=$PATH:~/CodeSourcery/Sourcery_CodeBench_Lite_for_ARM_EABI/bin/
+            - CTRL+A+C : un nouveau TAB
+            - CTRL+A+N : prochain TAB
+            - CTRL+A+P : précédent TAB
 
-    3. démarrer le listener !
-
-        .. code-block :: sh
-
-            # ce placer dans le bon répertoire ...
-            cd ~/stm32f4_work/
-            steph@tuck-eeepc:~/stm32f4_work/stlink$ sudo ./gdbserver/st-util fu bar
-                non-option ARGV-elements: fu bar 
-                2012-09-15T19:00:57 INFO src/stlink-common.c: Loading device parameters....
-                2012-09-15T19:00:57 INFO src/stlink-common.c: Device connected is: F4 device, id 0x10016413
-                2012-09-15T19:00:57 INFO src/stlink-common.c: SRAM size: 0x30000 bytes (192 KiB), Flash: 0x100000 bytes (1024 KiB) in pages of 16384 bytes
-                Chip ID is 00000413, Core ID is  2ba01477.
-                KARL - should read back as 0x03, not 60 02 00 00
-                init watchpoints
-                Listening at \*:4242...
+    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
+            non-option ARGV-elements: fu bar 
+            2012-09-15T19:00:57 INFO src/stlink-common.c: Loading device parameters....
+            2012-09-15T19:00:57 INFO src/stlink-common.c: Device connected is: F4 device, id 0x10016413
+            2012-09-15T19:00:57 INFO src/stlink-common.c: SRAM size: 0x30000 bytes (192 KiB), Flash: 0x100000 bytes (1024 KiB) in pages of 16384 bytes
+            Chip ID is 00000413, Core ID is  2ba01477.
+            KARL - should read back as 0x03, not 60 02 00 00
+            init watchpoints
+            Listening at \*:4242...
 
     4. éditer son projet 
         le module principal de votre projet se trouve sous ~/stm32f4_work/pymite-09/src/platform/stm32f4
     5. compiler son projet :
         ATTENTION À PYTHON 2.6 compiler le binaire pour la plateform stm32f4 suppose que votre interpréteur
         par défaut soit python2.6, sinon créer un virtualenv pour que ce soit le cas.
-
-        .. code-block :: sh
-
-            cd ~/stm32f4_work/pymite-0.9
-            # note la commande est sensible à la cas et attend l'argument PLATFORM  en majuscule.
-            scons PLATFORM=stm32f4
+        - cd ~/stm32f4_work/pymite-0.9
+        # 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
 
                 cd ~/stm32f4_work/pymite-0.9/src/platform/stm32f4
-                arm-none-eabi-gdb
                 # si votre path est bien configuré l'appel de arm-none-eabi-gdb devrait se dérouler correctement
                 # sinon un appel directe fera l'affaire :
-                ~/CodeSourcery/Sourcery_CodeBench_Lite_for_ARM_EABI/bin/arm-none-eabi-gdb
+                    ~/CodeSourcery/Sourcery_CodeBench_Lite_for_ARM_EABI/bin/arm-none-eabi-gdb
+                arm-none-eabi-gdb
+
+                        GNU gdb (Sourcery CodeBench Lite 2011.09-69) 7.2.50.20100908-cvs
+                        Copyright (C) 2010 Free Software Foundation, Inc.
+                        License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
+                        This is free software: you are free to change and redistribute it.
+                        There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
+                        and "show warranty" for details.
+                        This GDB was configured as "--host=i686-pc-linux-gnu --target=arm-none-eabi".
+                        For bug reporting instructions, please see:
+                        <https://support.codesourcery.com/GNUToolchain/>.
+                        (gdb) target extended localhost:4242
+                        Remote debugging using localhost:4242
+                        0x080007bc in ?? ()
+                        (gdb) load main.elf
+                        Loading section .text, size 0x15ce8 lma 0x8000000
+                        Loading section .ARM.excep, size 0x8 lma 0x8015ce8
+                        Loading section .data, size 0x59c lma 0x8015cf0
+                        Start address 0x80007bc, load size 90764
+                        Transfer rate: 665 bytes/sec, 9076 bytes/write.
+                        (gdb) continue
+                        Continuing.
+
+
                 # cela démarre la console gdb et vous donne la main
                 target extended localhost:4242
                 # charge le fichier elf (préalablement compilé, cf `scons PLATFORM=stm32f4`
     7. having fun ...
         Si tout c'est bien passé, votre code python tourne sur la plaque.
 
+.. note::
+        Je conseille d'utiliser screen ou byobu (en attendant d'avoir un IDE, dédié / ou pas ...)