jeudi 11 juillet 2013

Premier programme Expert Advisor

Alors, aujourd'hui nous allons être technique, mais ne prenez pas peur ! Il s'agit simplement d'une petite manipulation dans l'éditeur de code et de trois lignes de programmes qui vont être soigneusement expliquées. Notre premier programme ne déroge pas à la tradition de la programmation avec un "Hello World !". Il s'agit en fait des tous premiers programmes qu'on fait faire aux débutants pour qu'il sachent comment avec un langage de programmation, communiquer avec l'utilisateur. C'est-à-dire que le programme lorsqu'il fonctionne peut envoyer des messages à l'utilisateur, et c'est très utile. Nous verrons deux manières de le faire en utilisant deux fonctions différentes. Et ces programmes appelés "Hello World !" ne font qu'envoyer ce message de salutations, juste histoire d'afficher un message. Nous aurons en même temps une petite découverte de la structure d'un Expert Advisor. Rassurez-vous, elle est assez simple !

Pour commencer il faut que MetaTrader 4 soit ouvert, puis il faut cliquer dans la barre d'outils, sur le bouton avec l'icône en losange jaune et un point d'exclamation à l'intérieur. Ce bouton démarre l'éditeur de code de MetaTrader. En s'ouvrant vous constaterez une grande place vide, et deux petites fenêtres en bas et à droite. Nous allons demander un nouveau programme en cliquant sur le bouton à gauche dans la barre d'outils; celui avec la feuille blanche écrite et la croix verte, qui signifie "ajout". Il y a alors un assistant qui démarre pour nous demander le type de programme que l'on veut créer. Je rappelle qu'il y en a trois principaux: Expert Advisors (les programmes qui vont analyser et trader), les indicateurs (programmes qui ne font qu'analyser et dessiner sur le graphique pour donner des indications au trader) et les scripts (programmes qui assistent le trader dans son trading manuel pour faire des tâches répétitives, fastidieuses et avec des calculs, et ainsi aller plus vite). L'assistant propose également de faire une "Librairie", un include et de générer d'après un template. Ne vous inquiétez pas ! Voici ce dont il s'agit:

  • Librairie: fichier contenant des fonctions prêtes à être utilisées par d'autres programmes.
  • Include: fichier contenant des définitions de constantes (valeurs à utiliser) ou des déclarations de fonctions externes qu'on va utiliser (elles sont dans une librairie). Ce fichier se met en entête de notre programme pour que le compilateur sache, lorsqu'il va analyser notre programme, à quoi correspond les constantes qu'on utilise ou bien qu'on utilise correctement des fonctions externes.
  • Template: en fait l'assistant ne fait que préparer un fichier avec déjà présent des éléments qui vont nous être nécessaires selon le type de programme qu'on souhaite faire (EA, indicateur, script, librairie, include). Comme ça nous n'avons pas besoin de les saisir au clavier. Ici, avec cette dernière option, il nous propose directement que nous choisissions notre propre modèle. Il ne fera rien d'autre qu'ouvrir ce modèle qui contient déjà des éléments que nous avons préparé.

Nous choisissons donc un Expert Advisor. Cliquez sur cette option si elle n'est pas déjà cochée puis cliquez sur le bouton "suivant". L'assistant nous demande maintenant quelques informations d'auteur. Ainsi que le nom du programme et s'il y a des paramètres dont ce programme aurait besoin. Nous n'avons pas besoin de paramètres pour l'instant. Mettez juste un nom au programme tel que "Hello World". Changez les informations d'auteur si MetaQuotes vous dérange. Mais elles n'influent en rien sur le programme. Vous pourrez même les changer après, car elles apparaissent en clair en haut du code. Cliquez sur "Terminer".

Une fenêtre de code s'est ouverte. On voit en premier lieu un cadre en haut où il y a le nom que nous avons donné plus une extension ".mq4". et les informations de copyright dans le même cadre. On peut changer toutes ces informations cela n'aura aucune influence sur le programme et ne changera pas le nom du fichier qui restera "Hello World.mq4". En fait si les lignes commencent pas un double slash "//", cela signifie que c'est un commentaire, et le compilateur s'en fout, il passe sans regarder. Il y a plusieurs lignes de commentaires dans ce fichier de code. Vous devrez apprendre à les ignorer pour se concentrer sur le code, et s'il y en a trop les supprimer. Agrandissez la fenêtre et nous pouvons constater qu'il y a plusieurs choses, les commentaires mis à part:

  • Les cadres d'intitulés mis en commentaires: Il ne servent qu'à repérer les différentes parties du code. En tant que cadres il ne sont pas gênants.
  • Des petites lignes de commentaires "//----" : supprimez ces lignes elles sont gênantes pour visualiser le code. Elles étaient là pour qu'on puisse y mettre des commentaires, mais contrairement à la plupart des programmeurs, je pratique ce qu'on appelle le "clean code": c'est-à-dire en autres choses que les commentaires sont bannis. Si on a besoin de commentaires pour comprendre ce qu'on a codé, c'est que c'est très mal codé ! Je vous montrerai comment faire un code propre qui est tellement clair et explicite que vous le comprendrez trop facilement et les commentaires deviendront totalement inutiles, et même gênants. Une fois supprimés, vous avez une ligne avec une accolade ouvrante, un retour à la ligne et une ligne vide sauf avec des espaces au début pour que le code s'aligne avec l'accolade ouvrante. Puis un retour à la ligne avec un "return (0);" aussi aligné avec l'accolade. Et enfin un retour à la ligne et une accolade fermante alignée elle aussi. Et ça dans chacune des trois parties.
  • Des #property en dessous du cadre entête principal: ces lignes définissent des valeurs (propriétés) utilisables dans le programme. Ici des informations de copyright. On s'en fout pour l'instant. Je vous expliquerai les properties dans un autre post quand nous en aurons besoin.
  • Trois sections construites sur le même modèle:
    • expert initialization function : la fonction qui va s'exécuter une seule fois, quand le programme va démarrer
    • expert deinitialization function : la fonction qui va s'exécuter une seule fois, quand le programme va être arrêté.
    • expert start function : la fonction qui va être exécutée à chaque fois que MetaTrader reçoit une nouvelle mise à jour des cours en temps réel. C'est-à-dire environ un fois par seconde. Ça peut être plus, ça peut être moins, c'est variable en fonction du moment de la journée.

Chaque section commence par un mot clef du langage car il est en bleu: int. Puis il y a le nom de la fonction: init, deinit ou start. avec une paire de parenthèses. Ensuite l'accolade ouvrante, la ligne vide qu'on a laissé, un return (0); sans oublier le point-virgule puis l'accolade fermante. Le zéro est en vert car l'éditeur le considère comme un nombre dans le programme. les mots-clefs du langage sont en bleu et les mots en noir sont des noms librement choisis, sauf que les noms de ces fonctions-là ne peuvent être changés car MetaTrader va appeler des fonctions qui se nomment ainsi. Si on les change, ça ne fonctionnera plus. Comme vous pouvez le voir avec les property: l'éditeur met en vert-bleuté ce qu'il considère comme du texte dans le programme. C'est-à-dire que le programme prendra pour des données textuelles. Et ces données doivent être encadrées par des guillemets simples ou doubles pour être reconnues comme des données textuelles. Nous allons tout de suite les utiliser. Tout d'abord sachez qu'une fonction est un ensemble d'instructions qui font faire quelque chose au programme. On demande d'exécuter cet ensemble d'instructions en appelant la fonction tout simplement par son nom. La fonction est construite en mettant sur la première ligne le type de la valeur qu'elle donnera à la fin de son exécution, ici int pour integer, soit un nombre entier (O, 1, 2, 3, ... et aussi -1, -2, -3 ...). Puis il y a le nom de la fonction qu'on peut donner librement. (sauf certaines qui ont obligation de porter un nom précis) et des parenthèses (nous verrons plus tard ce qu'on peut y placer). Il y a une accolade ouvrante pour délimiter le début des instructions de la fonction. Puis les instructions. En général ces instructions finissent par une instruction return qui donne la valeur que la fonction doit retourner. En gros le résultat de la fonction. Mais ici, ce résultat est un code d'erreur 0 qui signifie tout s'est bien passé. Donc MetaTrader appelle une fonction nommée init(), et reçoit quand elle est finie, la valeur 0 qui signifie que tout s'est bien passé. Si on détecte que quelque chose s'est mal passé dans la fonction, il faudra retourner un nombre différent de 0. Puis on ferme l'accolade pour dire que c'est la fin de la fonction.

  1. Placez-vous dans la ligne vide de la première section, celle de la fonction nommée init().
  2. Nous allons appeler une fonction déjà toute prête qui nous permet d'informer l'utilisateur: c'est la fonction print(). Cette fonction envoie du texte dans l'onglet "Experts" de la fenêtre du bas de MetaTrader. Donc si on veut recevoir un message ici, c'est la fonction print(). Comme tout appel de fonction il faut mettre des parenthèses. Et dans ces parenthèses, il faut placer ce qu'on veut que le fonction prenne comme données. Ici on veut qu'elle prenne un message.
  3. Tapez "prin", et vous verrez que l'éditeur vous aura proposé une liste de termes pouvant correspondre, et avec les quatre premières lettres il aura trouvé print. Vous pouvez alors appuyer sur "Entrée" pour valider. Je vous conseille d'utiliser cette fonction, comme ça vous éviterez de nombreuses erreurs dues au fautes de frappe. Cette fonctionnalité d'un éditeur de code s'appelle l'auto-complétion. (ça complète automatiquement). Vous constaterez que les fonctions standards de MetaTrader sont colorées en violet et en plus il faut aura mis la majuscule que la fonction réclame. Quand vous tapez donc une fonction standard, soyez donc attentif au fait qu'elle soit en violet et commence par une majuscule. Alors vous ne vous n'aurez pas fait de fautes dans la saisie du nom de cette fonction. (et ça arrive souvent !)
  4. tapez une parenthèse ouvrante.
  5. Tapez le texte "Hello Trading World, l\'Expert Advisor s\'initialise !" entre guillemets doubles. On doit mettre l'antislash devant le guillemet simple qui sert d'apostrophe car sinon il indique la fin de la chaîne et c'est pas ce qu'on veut. l'antislash est un échappement, c'est a dire qu'il permet d'annuler l'effet d'un caractère ou de lui donner une signification précise. Ici le guillemet simple a déjà une signification précise: il indique le début ou la fin d'un texte. Si on le place tel quel, le compilateur va considérer qu'on a fini notre texte, or il y aura le reste du texte qui va suivre et il ne va pas comprendre ce qu'il y a après car ça n'aura aucune signification pour lui. On place donc un échappement pour dire d'annuler l'effet du guillemet simple. Vous pouvez constater que sans l'antislash, la couleur verte s'arrête au guillemet, avec elle continue jusqu'au guillemet double.
  6. tapez la parenthèse fermante.*
  7. Tapez un point-virgule. Chaque instruction doit se terminer par un point-virgule, c'est la règle pour dire au compilateur que l'instruction est complète. Ici notre instruction était d'appeler la fonction Print().
  8. Nous continuons et tapons une ligne similaire pour la deuxième section, celle de la dé-initialisation (lors de l'arrêt du programme): Print("Good-bye Trading World ! L\'Expert Advisor se dé-initialise !");
  9. Cliquez sur le bouton disquette pour enregistrer, ou bien faites la combinaison de touches CTRL+S.
  10. Cliquez sur le bouton Compile pour que le compilateur analyse et transforme ça en un fichier exécutable par l'ordinateur, et surtout exécutable par MétaTrader. Vous vérifiez dans la fenêtre du bas qu'il y ait indiqué "0 error(s), 0 warning(s)", qui signifie que le compilateur a tout analysé et n'a pas trouvé d'erreurs et qu'il a pu transformer ça en fichier exécutable. Les warnings sont des avertissements qui disent qu'on ne doit pas ou plus faire comme ça, mais que ce n'est pas une erreur empêchant la compilation. Si vous avez une erreur ou un warning, vérifiez ce que vous avez tapé.

Maintenant retournez dans MetaTrader, et vous cliquez sur la croix de expert consultant dans la petite fenêtre de gauche pour dérouler tous les experts existants, et oh ! Surprise, le notre s'y trouve déjà ! Pour démarrer cet expert, c'est très simple, il suffit d'une glisser-déposer: vous cliquez sur l'expert voulu, et sans relâcher vous le déplacer jusqu'au graphique du cours désiré, ici EURUSD par exemple et vous relâchez dessus. Une fenêtre apparaît et qui nous permet de faire les réglages de paramètres, mais nous n'en avons pas ici, donc cliquez sur OK. L'expert Advisor a démarré et vous pouvez cliquer sur l'onglet experts de la fenêtre du bas pour constater qu'il y a plusieurs messages. Les messages sont chronologiques et s'empilent les uns sur les autres, donc le plus haut est le plus récent. Il y en a trois, du plus ancien au plus récent (du bas vers le haut):

  • Hello World EURUSD,M1 : loaded successfully. C'est MetaTrader qui nous dit que notre expert "Hello World" a été chargé en mémoire sans problèmes pour le cours EURUSD et timeframe M1.
  • Hello World EURUSD,M1 : Hello Trading World ! L'expert Advisor s'initialise !. C'est notre message quand la fonction init() a été exécutée.
  • Hello World EURUSD,M1 : initialized. C'est MetaTrader qui dit que l'initialisation c'est bien passée, car a la fin de l'exécution de la fonction init(), il a reçu le code d'erreur 0, qui veut dire tout va bien.

Chaque message d'expert advisor, est précédé de son nom, du cours sur lequel il travaille et du timeframe. Car on peut ouvrir plusieurs cours de la même paire de devises sur différents timeframes et avec chacun les experts advisors de notre choix. Nous allons maintenant l'arrêter en faisant un clic droit sur le graphique et dans le menu sur Experts Consultants cliquez sur Retirer dans le sous menu qui s'ouvre. Nous obtenons en bas, quatre messages cette fois-ci. Notre message de Good-bye, puis un message de MetaTrader pour dire que la fonction deinit() s'est bien passée (valeur de retour 0), puis un message "uninit reason 1" donné par MetaTrader pour dire pour quelle raison l'expert a été arrêté parce qu'il y a plusieurs raisons qui peuvent provoquer l'arrêt d'un expert (ici la numéro 1), et enfin un dernier message de MetaTrader "removed" pour dire que notre programme a bien été déchargé de la mémoire.

Nous allons maintenant ajouter une instruction dans la dernière section et voir une autre manière d'afficher des messages. Ce n'est plus la fonction Print(), mais la fonction Alert(). Cette fonction ne met rien dans la fenêtre du bas, elle ouvre sa propre fenêtre à côté du graphique et donne le message, mais aussi tous les messages précédents. Cette fenêtre ne bloque pas l'éxecution de notre fonction car elle est indépendante. La fonction Alert() fait ouvrir cette nouvelle fenêtre, mais continue son exécution tout de suite et donc ne bloque pas notre programme quand cette fenêtre est ouverte. Nous allons la placer dans la fonction start. Je rappelle que c'est la fonction que MetaTrader appelle à chaque fois qu'il y a une mise à jour des cours. Elle va donc nous inonder de messages ! vous arrêterez donc l'expert advisor rapidement par le clic droit sur le graphique, car il y a en plus une sonnerie à chaque message, normal comme l'indique le nom de la fonction c'est une alerte !

  1. Allez dans la section expert start function.
  2. Dans la ligne vide tapez: ale .
  3. L'auto-complétion vous propose déjà la bonne fonction tapez la touche entrée.
  4. Complétez la ligne pour obtenir: Alert("nouveau tick"); On demande donc d'afficher le texte "nouveau tick". N'oubliez pas le point-virgule de la fin d'instruction.
  5. Cliquez sur le bouton disquette, ou faites CTRL+S pour sauvegarder.
  6. Cliquez sur le bouton Compile. Et vérifier que le compilateur vous indique bien 0 erreur et 0 warning. Sinon vérifiez ce que vous avez tapé. Le code complet doit identique à ceci (peu importe les informations d'auteur et copyright) :

//+------------------------------------------------------------------+
//|                                                  Hello World.mq4 |
//|                 Copyright 2013, argent-facile-avec-robots-forex. |
//|               http://argent-facile-avec-robots-forex.blogspot.fr |
//+------------------------------------------------------------------+
#property copyright "Copyright 2013, argent-facile-avec-robots-forex."
#property link    "http://argent-facile-avec-robots-forex.blogspot.fr"

//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
  {
   Print("Hello Trading World ! L\'expert Advisor s\'initialise !");
   return(0);
  }
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
  {
   Print("Good-bye Trading World ! L\'Expert Advisor se dé-initialise !");
   return(0);
  }
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
  {
   Alert("Nouveau tick");
   return(0);
  }
//+------------------------------------------------------------------+
  1. Allez dans MetaTrader et glissez et déposer l'expert sur le graphique pour le démarrer.
  2. Cliquez sur Ok dans la fenêtre des paramètres.
  3. Vous êtes désormais bombardé de sonneries et de messages au rythme des actualisations du cours.
  4. Sans fermer la fenêtre des messages d'alerte, faire un clic droit sur le graphique puis dans experts consultants du menu contextuel, cliquer sur retirer.
  5. Vous pouvez donc constater que les mises à jours se font à un rythme soutenu dans la journée, souvent plus d'une fois par seconde. Si vous faites ça le soir ou la nuit, c'est plus calme.
  6. Vous constatez aussi les messages d'initialisation et de dé-initialisation dans le journal des experts advisors en bas.

Voilà pour votre tout premier EA (Expert Advisor), qui ne sert à rien ! Mais vous avez découvert la structure principale d'un EA et manipulé deux fonctions de messages différentes. Je vous fais pratiquer tout ça dans la vidéo ci-dessous. Vous utiliserez la combinaison de touches ALT+TAB pour passer de la vidéo à MetaTrader. Une précision sur cette combinaison de touches: lorsque vous la faites une fois vous revenez sur le logiciel qui était utilisé juste avant, mais si sans relâcher le ALT vous appuyer encore une fois sur TAB vous remonter plus loin dans l'ordre chronologique des logiciels que vous avez utilisés. Vous devrez basculer entre la vidéo de cette page, MetaTrader et l'éditeur de code. Donc les trois plus récents dans l'ordre. Je serai donc là présent, si vous ne coupez pas la vidéo pour vous dire quoi taper dans l'éditeur et quoi faire.


Dans le prochain post je vous initierai à une notion fondamentale en programmation: les variables.

Aucun commentaire:

Enregistrer un commentaire