jan 05

Ada & timer

Hola amigos,

Aujourd’hui au programme, une introduction aux timers ! Un timer est un periphérique qui va créer des unités de temps, c’est à dire va émettre des impulsions à intervalles réguliers. A quoi cela va-t-il servir ? Nous allons pouvoir générer des valeurs de tensions différentes de GND et VCC grâce aux PWM (voir plus loin), ce qui va permettre par exemple de contrôler la vitesse d’un moteur ou encore l’intensité d’une led.

En savoir plus »

jan 01

Ada et UART

Hola,

Aujourd’hui au programme, le début de la communication avec une stm32 ! Pour se faire, nous introduirons un module très utilisé : l’UART.

Mais avant tout, qu’est ce que l’UART ? UART (Universal Asynchronous Receiver Transmitter : Emetteur Récepteur Asynchrone Universel) est un composant permettant de transformer des données sous forme d’octets en une série de bits (0 ou 1). Pourquoi cela ? Dans la mémoire de notre carte, les données sont stockées en « parallèle » : lorsque l’on demande la valeur dans une case mémoire, on obtient un paquet de 8, 16, 32bits,… dépendant de la structure. Toutefois, lorsque l’on communique, nous utilisons souvent un fil unique : il faut donc sérialiser les données pour les transmettre les uns à la suite des autres. UART effectue cette conversion.

Il existe deux types d’UARTs : les synchrones (USART) et les asynchrones (UART).

En savoir plus »

déc 27

Ada et les interruptions

Hello,

Pour tout ceux qui n’auraient pas lu le titre, nous allons parler aujourd’hui des interruptions. Vous vous demandez tous (ou bien vous le savez déjà) ce que peuvent bien être les interruptions. Voici la réponse !

Une interruption en informatique est un arrêt temporaire du programme par le microcontrôleur pour effectuer une série d’instructions. La cause de ce changement est externe au programme, sinon ce phénomène s’appelle une exception (comme en Java par exemple). Au déclenchement d’une interruption, le microcontrôleur enregistre toutes les données liées à l’exécution en cours (le contexte) et charge le programme adéquat. Pour cela, il va piocher dans le vecteur d’interruption qui est une table de correspondance entre l’interruption et la séquence correspondante.

A quoi les interruptions peuvent-elles servir ? Dans le cadre le l’UART, nous devions en permanence vérifier si oui ou non une donnée avait été reçue. Pour palier à cela, nous pouvons déclencher une interruption à la réception de données. Ainsi, plus besoin d’attendre : une donnée est traitée dès qu’elle est reçue.

En savoir plus »

déc 13

Sommaire du cours d’Ada

Salut à tous,

Je vais référencer sur cette page les cours pour la programmation en Ada sur stm32. Les premiers sont à faire dans l’ordre et la fin sera un peu plus libre.

  1. Le cours d’Ada pur
  2. Installation du crosscompilateur Ada pour stm32
  3. Installation de notre api
  4. Les GPIOs
  5. Les interruptions
  6. UART
  7. Timers

 

Je viendrai au fur et à mesure rajouter des éléments à la liste :)

A+

Julien

déc 13

L’api Ada

Salut à tous,

Nous allons maintenant installer l’api ada qui nous avons développé au club. Avant de poursuivre, assurez-vous d’avoir réussi à installer le compilateur. Si ce n’est pas le cas, je vous renvois Ici.

Ensuite, assurez vous d’avoir git installé. Si ce n’est pas le cas, tapez simplement dans la console :

sudo apt-get install git

Nous pouvons maintenant récupérer l’api. Pour cela, rien de plus simple. Il suffit de cloner le dépot mis à votre disposition par le club. Entrez dans le terminal :

git clone https://github.com/telrob/ada-api

Voila, vous avez installé l’api ! Testons maintenant son fonctionnement. Rendez vous dans le dossier ada-api :

cd ada-api

Un fichier d’exemple est mis à votre disposition. Pour vérifier qu’il compile comme il faut. Entrez :

make

dans la console. Si tout se passe comme il faut, vous trouverez l’exécutable dans le dossier bin et les objets intermédiaires dans le dossier objs. Vous pouvez essayer de flasher votre carte. Pour cela, deux choix s’offrent à vous. Le premier est de réutiliser la méthode vue dans le chapitre précédent . L’autre consiste à utiliser un fichier appelé .gdbinit qui va exécuter tout seul un certain nombre de commande à l’ouverture de gdb. Il se trouve dans le fichier bin. Au premier lancement, il ne sera pas actif. Pas de problème, gdb vous le signale. Il vous dit qu’il faut écrire un ligne du genre add-auto-load-safe-path /home/julien/Documents/ADA_API_STM32/bin/.gdbinit dans le fichier /home/nom_utilisateur/.gdbinit . Si ce fichier n’existe pas, créez le et copiez-y la ligne. Relancez gdb. La consigne a disparu. Il vous suffit maintenant de faire un load pour flasher la carte. N’oubliez pas de lancer openocd avec gdb. SI des problèmes persistent, débranchez, rebranchez la carte et relancer openocd et gdb. Si vous êtes curieux, jeté un œil dans le fichier .gdbinit. Vous reconnaîtrez alors certaines commandes, parfois en abrégé. Ces commandes sont exécutées au lancement de gdb et vous pouvez les modifier ou en ajouter. Je vous renvoie vers l’article de Félix pour plus d’informations.

Détaillons maintenant le contenu. Comme je l’ai déjà précisé, le dossier bin va contenir les exécutables que vous génèrerez. Le dossier objs, qui n’a pas trop d’importance, contient les fichiers intermédiaires. Le dossier hwinterface contient les fonctions de base qui nous permettrons de programmer sur la stm32. Le dossier doc contient la documentation des fonctions utilisables (en cours d’écriture à l’heure actuelle). Pour la lire, ouvrez le fichier masterindex.html avec votre navigateur préféré ;)

Vous trouverez ensuite un fichier Makefile. Si vous ne savez pas ce que c’est, sachez qu’il s’agit d’un fichier souvent présent dans les projets de programmation et qui permet d’effectuer des actions prédéfinies, comme compiler par exemple. Quand nous avons appelé make, nous avons en réalité appelé la première fonction du Makefile qui a compilé le programme. Vous pouvez aussi supprimer tous les fichiers créés pendant la compilation en tapant make clean . Le Makefile est un concept très important et je vous conseille fortement d’apprendre à l’utiliser :)

Si nous regardons le contenu du Makefile, on peut voir que arm-none-eabi-gnatmake est appelée. Souvenez vous, c’est cette fonction que nous avons utilisé pour vérifier l’installation du compilateur. Cette fois, elle est accompagnée du plus d’arguments, et notamment un appel au fichier build.gpr . Il s’agit d’un fichier pour gérer les projets (on l’inclut d’ailleurs avec -P). Dedans, vous trouverez des définitions liées à l’organisation du projet. On y définit par exemple l’emplacement des fichiers sources, l’emplacement des exécutables, des options de compilation,… Une option nous intéresse plus particulièrement : Main. C’est la liste des fichiers dont nous souhaitons obtenir les exécutables. Ainsi, si vous rajoutez un exécutable, vous pouvez venir le l’ajouter à la liste :

for Main use ("example", "projet1","foo");

Pour les plus téméraires, vous pouvez aussi jouer avec les autres options de compilation.

Voilà, je pense avoir fait le tour. Vous devriez maintenant être capable de poursuivre avec les cours sur le site ou en solo.

 

A+,

Julien

oct 24

Photos de la séance peinture

 

 

 

 

 

 

 

 

IMG_20141023_213907 IMG_20141023_213905 IMG_20141023_213859 IMG_20141023_213851 IMG_20141023_210918 IMG_20141023_210734 IMG_20141023_210720

oct 05

Installer le compilateur Ada

Salut à tous,

Aujourd’hui s’achève le premier week-end robotique de l’année et un certain nombre de leçons furent tirées concernant l’installation d’Ada. Voici donc un résumé des étapes à suivre.

En savoir plus »

oct 04

Ada et les GPIOs

Salut à tous,

Aujourd’hui un petit tutorial pour mieux comprendre l’utilisation des GPIOs sur stm32 avec Ada ! C’est parti !

Avant de commencer, expliquons ce que sont les GPIOs. GPIO (General Purpose Input/Output = Entrée/Sortie à usage général) sont des ports pouvant jouer soit le rôle d’entrée sur le microcontrolleur, soit le rôle de sortie. On accède en général aux données du port GPIO via des registres, qui sont des emplacements mémoire internes au processeur. C’est une des mémoires les plus rapides mais aussi une des plus chères à produire.

Sur notre stm32f4-discovery, les ports GPIOs se trouvent sur les côtés et sont faits de telle sorte qu’ils soient facile d’accés.
En savoir plus »

Image

Porte clés du club

image

#jenveuxun

sept 14

Ada et Robots #1: démarrage

Nos robots sont programmés en Ada. Pourquoi? Alexis écrivait en 2008 « c’est un langage beaucoup plus sûr ». C’est vrai – mais excessivement réducteur.

Cette série d’articles va vous apporter les premiers pas d’Ada pratique sur STM32 – on ne va pas trop parler au début du typage fort et des restrictions du profile Ravenscar.

Le programme est le suivant:

  1. Démarrage: installer les outils de développement (GNAT, bibliothèques, outils associés); compiler un premier programme (vide).
  2. Clignotons des diodes: comment (presque) contrôler le monde
  3. Bases d’Ada en 60 secondes chrono: packages, fichiers programme, GNATMake…
  4. Le multitâche basique: faisons plein de choses en même temps – sans effort.

[Cette liste sera mise à jour au fur et à mesure de la publication des articles]
En savoir plus »

Articles plus anciens «