Développer un Expert Advisor de trading à partir de zéro (partie 29) : La plateforme parlante

Introduction

Et si nous rendions un Expert Advisor plus amusant ? Le trading sur les marchés financiers est souvent ennuyeux et monotone, mais nous pouvons rendre ce travail moins fatigant. Veuillez noter que ce projet peut être dangereux pour les personnes qui ont des problèmes de dépendance. Mais d'une manière générale, cela rend les choses moins ennuyeuses.

Avertissement : N'UTILISEZ PAS les modifications proposées dans cet article si vous considérez le marché comme un jeu d'argent, car il existe un risque réel de pertes très importantes.

Bien que l'avertissement ci-dessus ait l'air d'une plaisanterie, la vérité est que certaines modifications apportées à l'EA le rendent dangereux pour les personnes qui sont dépendantes du jeu en général.

Certaines des modifications apportées ici visent à améliorer la stabilité et les performances globales de l'EA. Si vous souhaitez conserver certaines des choses que nous supprimons dans cet article, ce n'est pas difficile. Grâce au système d'ordre créé et présent dans l'EA, vous pouvez retirer certains éléments sans dommage. Il vous appartient donc d'accepter et d'utiliser les choses ou de les supprimer.

2.0. Supprimer le Chart Trade

Le Chart Trade est quelque chose qui a encore du sens dans un système d'ordre simple, moins complexe que celui utilisé dans notre EA. Mais pour notre EA, au stade actuel de développement, il n'est pas utile d'avoir Chart Trade sur le graphique, nous pouvons donc l'enlever. Vous pouvez le conserver si vous le souhaitez en modifiant simplement une commande. Il est vrai que j'aime garder les choses simples, afin de pouvoir les modifier (ou ne pas les modifier) très rapidement par la suite, de sorte que les changements ne génèrent pas de stress, tels que des problèmes ou des défaillances catastrophiques à des points critiques.

Pour rendre le contrôle très rapide et en même temps sûr, la définition suivante a été ajoutée au code de l’EA :

#define def_INTEGRATION_CHART_TRADER            // Chart trader integration with the EA ...

Si cette définition n'existe pas ou devient un commentaire, CHART TRADE ne sera pas compilé avec l'EA. Examinons les points concernés par cette définition. La première et la plus évidente d'entre elles est la suivante :

#ifdef def_INTEGRATION_CHART_TRADER
        #include <NanoEA-SIMD\SubWindow\C_TemplateChart.mqh>
#endif 

Bien que le code ci-dessus ne se trouve pas dans le fichier de l’EA, mais dans le fichier C_IndicatorTradeView.mqh, la définition sera visible par le compilateur partout dans le code? Nous n'avons donc pas besoin de nous préoccuper de la correction du code. Ici, nous créons simplement la définition à un endroit facilement accessible, en l'occurrence dans le code de l'EA, et nous l'utilisons si nécessaire.

Mais continuons avec le fichier C_IndicatorTradeView.mqh. Puisque nous pouvons compiler l'EA sans Chart Trade, nous devons implémenter l'accès aux données définies dans la boîte de message d'initialisation de l'EA, que l'on peut voir dans l'image ci-dessous :

N'oubliez pas que nous devons accéder à ces données. Auparavant, nous les transmettions à Chart Trade, et lorsque nous avions besoin de les connaître, nous nous adressions à Chart Trade. Mais maintenant, sans Chart Trade, nous devrons emprunter une autre voie pour accéder aux mêmes données.

Dans le fichier C_IndicatorTradeView.mqh, ces valeurs ne sont utilisées qu'à un seul endroit : lorsque nous créons l'indicateur 0 qui montre où l'ordre en attente sera situé. Cet endroit se trouve à l'intérieur de la fonction DispatchMessage. Il est illustré dans le code ci-dessous :

// ... Previous code ...

                                        case CHARTEVENT_MOUSE_MOVE:
                                                Mouse.GetPositionDP(dt, price);
                                                mKeys   = Mouse.GetButtonStatus();
                                                bEClick  = (mKeys & 0x01) == 0x01;    //Left mouse click
                                                bKeyBuy  = (mKeys & 0x04) == 0x04;    //SHIFT pressed
                                                bKeySell = (mKeys & 0x08) == 0x08;    //CTRL pressed
                                                if (bKeyBuy != bKeySell)
                                                {
                                                        if (!bMounting)
                                                        {
#ifdef def_INTEGRATION_CHART_TRADER
                                                                m_Selection.bIsDayTrade = Chart.GetBaseFinance(m_Selection.vol, valueTp, valueSl);
#else 
                                                                m_Selection.vol = EA_user20 * Terminal.GetVolumeMinimal();
                                                                valueTp = EA_user21;
                                                                valueSl = EA_user22;
                                                                m_Selection.bIsDayTrade = EA_user23;
#endif 
                                                                valueTp = Terminal.AdjustPrice(valueTp * Terminal.GetAdjustToTrade() / m_Selection.vol);
                                                                valueSl = Terminal.AdjustPrice(valueSl * Terminal.GetAdjustToTrade() / m_Selection.vol);
                                                                m_Selection.it = IT_PENDING;
                                                                m_Selection.pr = price;
                                                        }

// ... The rest of the code...

Il n'est pas nécessaire de rechercher les valeurs EA_userXX dans le fichier. Elles n'y sont pas, car elles proviennent du code de l'EA :

#ifdef def_INTEGRATION_CHART_TRADER
        input group "Chart Trader"
#else 
        input group "Base Operacional do EA"
#endif 
input int       EA_user20   = 1;     //Levering factor
input double    EA_user21   = 100;   //Take Profit (financial)
input double    EA_user22   = 81.74; //Stop Loss (financial)
input bool      EA_user23   = true;  //Day Trade ?

Cette seule fonction offre déjà un contrôle similaire à celui de Chart Trade sur le graphique. Veuillez noter que nous ne modifions pratiquement rien dans le code. Nous déplaçons simplement les données requises définies par l'utilisateur au bon endroit. Certaines personnes peuvent trouver que cette configuration de la part du trader lors du chargement de l'EA n'est pas nécessaire. C'est vrai dans un sens, puisque le système d'ordres permet de configurer toutes les variables sans aucune difficulté. Nous pouvons ainsi simplement fixer la valeur minimale du facteur de levier, du Stop Loss et du Take Profit à 0, et les opérations initiales comme Day Trade - faites-le dans la fonction DispatchMessage de la classe C_IndicatorTradeView. Cela n'affecte en rien le système, puisque le trader peut modifier l'ordre sur le graphique et l'envoyer ensuite au serveur. Ce type de modification vous appartient, car il s'agit de quelque chose de très personnel.

2.0.1. Quelques ajustements

Avant de revenir à la partie où nous supprimons Chart Trade, nous devons faire une dernière chose qui améliorera la stabilité de l'EA dans son ensemble.

Procédons de la manière suivante. Dans la classe C_IndicatorTradeView, nous définissons une structure de données privée :

struct st01
{
        bool    ExistOpenPosition,
                SystemInitilized;
}m_InfoSystem;

Elle doit être initialisée dans le code suivant :

void Initilize(void)
{
        static int ot = 0, pt = 0;
                                
        m_InfoSystem.ExistOpenPosition = false;
        m_InfoSystem.SystemInitilized = false;
        ChartSetInteger(Terminal.Get_ID(), CHART_SHOW_TRADE_LEVELS, false);
        ChartSetInteger(Terminal.Get_ID(), CHART_DRAG_TRADE_LEVELS, false);                             
        if ((ot != OrdersTotal()) || (pt != PositionsTotal()))
        {
                ObjectsDeleteAll(Terminal.Get_ID(), def_NameObjectsTrade);
                ChartRedraw();
                for (int c0 = ot = OrdersTotal(); c0 >= 0; c0--)  IndicatorAdd(OrderGetTicket(c0));
                for (int c0 = pt = PositionsTotal(); c0 >= 0; c0--) IndicatorAdd(PositionGetTicket(c0));
        }
        m_InfoSystem.SystemInitilized = true;
}

Pourquoi créons-nous et initialisons-nous ces données ici ? Rappelez-vous que MetaTrader 5 envoie des événements à l'EA. L'un de ces événements est OnTick. Les systèmes simples ne posent pas beaucoup de problèmes. Mais à mesure que le système devient plus complexe, il faut s'assurer que tout fonctionne. Il peut arriver que MetaTrader 5 envoie des événements à l'EA avant que ce dernier ne soit prêt à les traiter. Nous allons créer des variables qui indiqueront l'état de préparation de l'EA. S'il n'est pas encore prêt, les événements de MetaTrader 5 doivent être ignorés jusqu'à ce que l'EA puisse répondre de manière appropriée aux événements.

Le point le plus critique est illustré dans le code ci-dessous :

inline double SecureChannelPosition(void)
                        {
                                static int nPositions = 0;
                                double Res = 0;
                                ulong ticket;
                                int iPos = PositionsTotal();
                                
                                if (!m_InfoSystem.SystemInitilized) return 0;
                                if ((iPos != nPositions) || (m_InfoSystem.ExistOpenPosition))
                                {
                                        m_InfoSystem.ExistOpenPosition = false;
                                        for (int i0 = iPos - 1; i0 >= 0; i0--) if (PositionGetSymbol(i0) == Terminal.GetSymbol())
                                        {
                                                m_InfoSystem.ExistOpenPosition = true;
                                                ticket = PositionGetInteger(POSITION_TICKET);
                                                if (iPos != nPositions) IndicatorAdd(ticket);
                                                SetTextValue(ticket, IT_RESULT, PositionGetDouble(POSITION_VOLUME), Res += PositionGetDouble(POSITION_PROFIT), PositionGetDouble(POSITION_PRICE_OPEN));
                                        }
                                        nPositions = iPos;
                                }
                                return Res;
                        };

Les points mis en évidence n'existaient pas auparavant. Donc des choses étranges pouvaient parfois se produire. Mais nous disposons désormais des contrôles nécessaires pour nous assurer que rien d'inhabituel ne passe inaperçu.

Cette question de la vérification de tout est assez compliquée, car des vérifications multiples peuvent rendre un système très stable, mais aussi compliquer la maintenance et la modification du code. Certains contrôles doivent être effectués dans un ordre logique pour être efficaces, ce qui est assez coûteux.

Mais il faut noter que lorsque nous vérifions s'il existe ou non une position pour un symbole surveillé par l'EA, nous pouvons donner un peu d'agilité. C'est encore plus vrai lorsque l'on trade plusieurs actifs, chacun d'entre eux ayant un certain nombre de positions qui apparaîtront dans l'EA. En filtrant ici, nous éliminons la boucle de sorte que l'EA n'exécute le code à l'intérieur de la boucle que lorsque c'est vraiment nécessaire. Dans le cas contraire, nous réduisons légèrement le temps de traitement consommé par l'EA. La boucle n'est pas longue, mais dans des cas très extrêmes, cela peut faire une grande différence.

2.0.2. Supprimer Chart Trade de l'EA

Maintenant que nous avons modifié la classe C_IndicatorTradeView, nous pouvons nous concentrer sur le code de l'EA et supprimer Chart Trade. La première chose à faire est de le supprimer du code OnInit :

int OnInit()
{       
        Terminal.Init();

#ifdef def_INTEGRATION_WITH_EA
        WallPaper.Init(user10, user12, user11);
        VolumeAtPrice.Init(user32, user33, user30, user31);
        TimesAndTrade.Init(user41);
        EventSetTimer(1);
#endif 

        Mouse.Init(user50, user51, user52);
        
#ifdef def_INTEGRATION_CHART_TRADER
        static string   memSzUser01 = "";
        if (memSzUser01 != user01)
        {
                Chart.ClearTemplateChart();
                Chart.AddThese(memSzUser01 = user01);
        }
        Chart.InitilizeChartTrade(EA_user20 * Terminal.GetVolumeMinimal(), EA_user21, EA_user22, EA_user23);
        TradeView.Initilize();
        OnTrade();
#else 
        TradeView.Initilize();
#endif 
   
        return INIT_SUCCEEDED;
}

Le code vert sera remplacé par le code bleu. Si nous n'utilisons pas Chart Trade, il peut sembler que la différence est faible, qu'il s'agit seulement d'un changement dans la taille du fichier exécutable. Mais ce n'est pas tout. Veuillez noter qu'en plus du code Chart Trade, nous avons également supprimé l'événement OnTrade. L'EA ne traitera plus cet événement.

Vous pourriez penser que quelque chose ne va pas chez moi. Comment puis-je supprimer l'événement OnTrade d'un EA ? Comment allons-nous gérer les événements de trading maintenant ? Ces événements seront traités par l'événement OnTradeTransaction. La méthode de traitement sera plus efficace que celle de OnTrade, ce qui signifie que l'EA sera plus simple et plus fiable.

Autre chose est en train de changer :

void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
{
        Mouse.DispatchMessage(id, lparam, dparam, sparam);
#ifdef def_INTEGRATION_WITH_EA
        switch (id)
        {
                case CHARTEVENT_CHART_CHANGE:
                        Terminal.Resize();
                        WallPaper.Resize();
                        TimesAndTrade.Resize();
        break;
        }
        VolumeAtPrice.DispatchMessage(id, sparam);
#endif 

#ifdef def_INTEGRATION_CHART_TRADER
        Chart.DispatchMessage(id, lparam, dparam, sparam);
#endif 

        TradeView.DispatchMessage(id, lparam, dparam, sparam);  
}

S'il n'y a pas d'intégration dans l'EA, les seules lignes qui seront compilées seront les lignes surlignées. Comme ces événements ont tendance à être relativement constants (plus le traitement de ces événements est efficace, mieux c'est), ils sont souvent en concurrence avec un autre événement que MetaTrader 5 déclenche pour que l'EA le traite. Cet autre événement est illustré ci-dessous :

void OnTick()
{
#ifdef def_INTEGRATION_CHART_TRADER
        Chart.DispatchMessage(CHARTEVENT_CHART_CHANGE, 0, TradeView.SecureChannelPosition(), C_Chart_IDE::szMsgIDE[C_Chart_IDE::eRESULT]);
#else 
        TradeView.SecureChannelPosition();
#endif 

#ifdef def_INTEGRATION_WITH_EA
        TimesAndTrade.Update();
#endif 
}

Un tel événement est un véritable cauchemar car il est généralement appelé plusieurs fois. Dans certains cas, il peut être appelé plusieurs fois en moins d'une seconde. Mais grâce aux modifications apportées au code de la classe C_IndicatorTradeView, le traitement de cet événement est devenu un peu plus efficace. Nous améliorerons encore cette efficacité plus tard. Mais pour l'instant, cela suffira.

Après tous ces changements, Chart Trade ne sera plus intégré dans l'EA. Nous pouvons transformer Chart Trade en un indicateur, ce qui présente certains avantages tout en permettant à l'EA de se concentrer sur son activité principale : le traitement, le positionnement et la gestion du système d'ordres. Mais transformer Chart Trade en un indicateur implique quelques changements supplémentaires. C'est pourquoi je ne montrerai pas maintenant comment le faire, nous le verrons plus tard. Mais en général, oui, nous pouvons déplacer Chart Trade dans un indicateur et être toujours en mesure d'envoyer des ordres à travers lui.

3.0. Ajout de sons

Souvent, nous ne regardons pas le graphique, mais nous voulons quand même savoir ce qui se passe en ce moment. L'une des façons d'être informé de quelque chose est de recevoir une alerte sonore. C'est l'un des meilleurs types d'alerte, car il attire immédiatement notre attention. Parfois, nous savons déjà comment agir rien qu'en écoutant l'alerte, sans avoir à vérifier d'autres messages.

Apprenons donc à mettre en place quelques alertes sonores de base. Dans certains cas, il s'agit d'une phrase qui raconte quelque chose de spécifique. Bien que ce que je montre maintenant et ce qui est disponible dans la pièce jointe n'offre que des fonctions de base, cela pourrait peut-être vous motiver à augmenter le nombre d'alertes et d'avertissements existants, afin que vous ne perdiez pas de temps à lire les messages. Un son peut indiquer un événement spécifique, ce qui vous permet de gagner en agilité à des moments précis du trading. Croyez-moi, cela fait une grande différence.

La première chose à faire est de créer un nouveau fichier qui contiendra la nouvelle classe et qui supportera et isolera notre système sonore. Une fois que cela sera fait, nous pourrons commencer à produire des choses de manière très stable. L'ensemble de la classe est présenté dans le code ci-dessous :

class C_Sounds
{
        protected:
                enum eTypeSound {TRADE_ALLOWED, OPERATION_BEGIN, OPERATION_END};
        public  :
//+------------------------------------------------------------------+
inline bool PlayAlert(const int arg)
                {
                        return PlaySound(StringFormat("NanoEA-SIMD\\RET_CODE\\%d.wav", arg));
                }
//+------------------------------------------------------------------+
inline bool PlayAlert(const eTypeSound arg)
                {
                        string str1;
        
                        switch (arg)
                        {
                                case TRADE_ALLOWED   : str1 = def_Sound00; break;
                                case OPERATION_BEGIN : str1 = def_Sound01; break;
                                case OPERATION_END   : str1 = def_Sound02; break;
                                default : return false;
                        }
                        PlaySound("::" + str1);
                        
                        return true;
                }
//+------------------------------------------------------------------+
};

Malgré l'extrême simplicité de ce code, il contient quelque chose d'intéressant. Notez que nous réécrivons la fonction PlayAlert. Nous avons donc 2 versions de la même fonction. Pourquoi ? Le fonctionnement du système de sonorisation exige que nous ayons 2 variantes. Dans le cas de la première version de la fonction, nous jouerons un son provenant d'un fichier. Dans la seconde version, nous jouerons le son qui fait partie de l'EA, c'est-à-dire sa fonction. Il y a maintenant quelque chose que beaucoup de gens ne savent pas faire : jouer des sons directement à partir de fichiers audio. Mais ne vous inquiétez pas, je vais vous montrer comment faire. La raison d'être de la première version est que certaines personnes peuvent vouloir mettre leur propre voix ou un autre son comme alerte et le modifier à tout moment sans avoir à recompiler l'EA. En fait, vous pouvez modifier ces sons même lorsque l'EA est exécuté dans MetaTrader 5. À partir du moment où le son doit être joué, l'EA utilisera la dernière version. Vous n'aurez donc qu'à remplacer un fichier audio par un autre — l'EA ne remarquera même pas la différence, ce qui est très utile. Mais il y a une autre raison que l'on peut déceler dans le code de l'EA.

En fait, la première option est utilisée à un endroit assez spécifique, comme on peut le voir dans le code mis en évidence ci-dessous :

class C_Router
{
        protected:
        private  :
                MqlTradeRequest TradeRequest;
                MqlTradeResult  TradeResult;
//+------------------------------------------------------------------+
inline bool Send(void)
        {
                if (!OrderSend(TradeRequest, TradeResult))
                {
                        if (!Sound.PlayAlert(TradeResult.retcode))Terminal.MsgError(C_Terminal::FAILED_ORDER, StringFormat("Error Number: %d", TradeResult.retcode));
                        
                        return false;
                }
                return true;
        }

// ... The rest of the class code....

Imaginez la quantité de travail nécessaire pour traiter toutes les erreurs possibles renvoyées par le serveur de trades. Mais si nous enregistrons un fichier audio et que nous le nommons en fonction de la valeur que le serveur de trades renvoie, l'EA saura quel fichier lire, ce qui nous simplifie grandement la vie. En effet, dans ce cas, il suffit de spécifier le fichier à utiliser en fonction de la valeur renvoyée par le serveur — l'EA trouvera et lira ce fichier, en nous donnant un avertissement sonore ou un message vocal pour que nous sachions exactement ce qui s'est passé. Merveilleux, n'est-ce pas ? Aujourd'hui, par exemple, si un ordre est rejeté, la plateforme nous informe très clairement de ce qui s'est passé ou de ce qui ne va pas. Cela se fera d'une manière très pratique qui représente quelque chose de spécifique pour vous, quelque chose qui peut être exclusif et unique dans votre façon de trader et d'agir sur le marché. Voyez combien d'agilité vous gagnerez, car dans le même fichier audio, vous pouvez expliquer clairement comment résoudre le problème.

Mais nous avons aussi un deuxième mode de fonctionnement, dans lequel les sons sont stockés à l'intérieur du fichier exécutable de l’EA. Il s'agit de la deuxième version de la même fonction, qui sera utilisée à ce stade à 3 endroits différents pour indiquer 3 types d'événements différents. La première place est indiquée dans le code ci-dessous :

int OnInit()
{
        if (!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
        {
                Sound.PlayAlert(C_Sounds::TRADE_ALLOWED);
                return INIT_FAILED;
        }
        
        Terminal.Init();

// ... The rest of the code...

Ce code vérifie si le Trading Algorithmique est activé dans la plateforme. Si nous avons oublié de l'activer, l'EA nous indiquera qu'il ne sera pas disponible pour le trading. Pour vérifier si l'option est activée ou non, il suffit de regarder le marqueur dans la plateforme, comme le montre l'image suivante :

Le deuxième endroit où nous utiliserons un son est illustré ci-dessous :

void CreateIndicator(ulong ticket, eIndicatorTrade it)
{
        string sz0;
                                
        switch (it)
        {
                case IT_TAKE    : macroCreateIndicator(it, clrForestGreen, clrDarkGreen, clrNONE); break;
                case IT_STOP    : macroCreateIndicator(it, clrFireBrick, clrMaroon, clrNONE); break;
                case IT_PENDING:
                        macroCreateIndicator(it, clrCornflowerBlue, clrDarkGoldenrod, def_ColorVolumeEdit);
                        m_BtnCheck.Create(ticket, sz0 = macroMountName(ticket, it, EV_CHECK), def_BtnCheckEnabled, def_BtnCheckDisabled);
                        m_BtnCheck.SetStateButton(sz0, true);
                        macroInfoBase(IT_PENDING);
                        break;
                case IT_RESULT  :
                        macroCreateIndicator(it, clrSlateBlue, clrSlateBlue, def_ColorVolumeResult);
                        macroInfoBase(IT_RESULT);
                        Sound.PlayAlert(C_Sounds::OPERATION_BEGIN);
                        m_InfoSystem.ExistOpenPosition = true;
                        break;
        }
        m_BtnClose.Create(ticket, macroMountName(ticket, it, EV_CLOSE), def_BtnClose);
}

Chaque fois qu'un indicateur de position est créé, un son est émis. Cela nous facilitera grandement la vie, car nous saurons que l'ordre en attente est devenu une position et que nous devons commencer à y prêter attention.

Le troisième et dernier point où nous avons un son est lorsqu'une position est fermée pour une raison quelconque. Cela se fait à un endroit très précis :

inline void RemoveIndicator(ulong ticket, eIndicatorTrade it = IT_NULL)
{
        ChartSetInteger(Terminal.Get_ID(), CHART_EVENT_OBJECT_DELETE, false);
        if ((it == IT_NULL) || (it == IT_PENDING) || (it == IT_RESULT))
        {
                if (macroGetPrice(ticket, IT_RESULT, EV_LINE) > 0) Sound.PlayAlert(C_Sounds::OPERATION_END);
                ObjectsDeleteAll(Terminal.Get_ID(), StringFormat("%s%c%llu%c", def_NameObjectsTrade, def_SeparatorInfo, ticket, (ticket > 1 ? '*' : def_SeparatorInfo)));
        } else ObjectsDeleteAll(Terminal.Get_ID(), StringFormat("%s%c%llu%c%c", def_NameObjectsTrade, def_SeparatorInfo, ticket, def_SeparatorInfo, (char)it));
        ChartSetInteger(Terminal.Get_ID(), CHART_EVENT_OBJECT_DELETE, true);
        m_Selection.ticket = 0;
        Mouse.Show();
        ChartRedraw();
}

Vous pourriez penser que lorsque vous supprimez l'EA, il jouera le son de fermeture de position, mais non. Cela ne se produira pas car la ligne de prix sera toujours présente dans le système. Mais lorsque la position est fermée, quelque chose de différent se produit, et la ligne de prix de la position se trouve à un niveau de prix 0 — à ce moment-là, un son est émis pour indiquer que la position a été fermée.

Étant donné que ces sons, qui sont des ressources de l'EA, suivront le fichier exécutable partout où il ira et qu'ils ne peuvent pas être modifiés sans recompiler le code, ils sont plus limités. Mais en même temps, ils permettent de porter l'EA à d'autres endroits sans qu'il soit nécessaire d'emporter des fichiers audio.

Mais dans le cas des sons utilisés pour signaler les défaillances ou les erreurs, la logique est différente : ils doivent être déplacés séparément et placés à un endroit prédéterminé afin de pouvoir fonctionner en cas de besoin.

La pièce jointe contient un dossier appelé SOUNDS. Ne laissez pas ce dossier dans le même dossier que celui où se trouve le code, car les sons contenus dans ce dossier ne seront pas joués. Déplacez-le dans un endroit différent et facile à trouver. Si vous ne savez pas où il se trouve, ne vous inquiétez pas, nous le verrons plus tard :

#property copyright "Daniel Jose"
//+------------------------------------------------------------------+
void OnStart()
{
        Print(TerminalInfoString(TERMINAL_PATH));
}
//+------------------------------------------------------------------+

Lorsque vous exécutez ce script, vous obtenez des informations dans la barre d'outils qui indiquent l'emplacement que nous utiliserons. Un exemple du résultat de l'exécution est présenté dans l'image ci-dessous :

Vous devez procéder comme suit :

1. Ouvrez la pièce jointe
2. Ouvrez l'explorateur de fichiers
3. Allez dans le dossier indiqué dans la figure ci-dessus
4. Copiez le contenu du dossier SOUNDS du fichier joint dans le dossier indiqué ci-dessus.
5. Si vous le souhaitez, vous pouvez supprimer ces trois fichiers (WARNING, BEGIN, END), car ils seront compilés avec l'EA.
6. Si vous le souhaitez, vous pouvez changer le contenu de .WAV en quelque chose que vous aimez ; assurez-vous simplement de ne pas changer le nom.
7. Utilisez l'EA sur la plateforme MetaTrader 5 et soyez heureux !

Mais n'oubliez pas que pour que les sons (WARNING, BEGIN, END) soient compilés dans l'EA, vous devez avoir le dossier SOUNDS avec les mêmes sons dans le répertoire de code MQL5, sinon ils ne seront pas intégrés dans le code de l'EA.

Conclusion

Dans cet article, vous avez appris à ajouter des sons personnalisés au système de l’EA. Nous avons utilisé ici un système très simple pour démontrer comment procéder. Mais vous n'êtes pas limité à un simple EA. Vous pouvez également l'utiliser dans des indicateurs ou même dans des scripts.

L'avantage est que si vous utilisez les mêmes concepts et idées que ceux proposés ici, vous pouvez enregistrer des messages vocaux disant ou avertissant de quelque chose. Et lorsque l'EA, ou tout autre processus exécuté par MetaTrader 5 et qui utilise le système sonore, est activé par les déclencheurs présentés dans l'article, vous recevrez un message sonore vous informant ou vous avertissant d'une action que vous avez déjà prévue et que vous devez faire.

Il ne s'agit pas d'un texte, mais d'un message vocal, ce qui le rend beaucoup plus efficace, car vous pouvez rapidement expliquer à toute personne utilisant le système ce qu'il faut faire ou quelle est la cause qui a généré un tel message.

Ce système n'est pas limité à ce schéma. Vous pouvez aller au-delà de ce qui a été démontré ici. L'idée est précisément de permettre à l'utilisateur d'avoir un allié dans la plateforme. En ayant une interaction vocale avec l'opérateur, nous pouvons transmettre un message qui est peut-être plus facile à comprendre qu'un simple texte. La seule chose qui vous limite ici, c'est votre créativité.