Sviluppare un Expert Advisor per il trading da zero (Parte 29): La piattaforma parlante

Introduzione

E se rendessimo più divertente un Expert Advisor? Il trading sui mercati finanziari è spesso troppo noioso e monotono, ma possiamo rendere questo lavoro meno faticoso. Notare che questo progetto può essere pericoloso per chi ha problemi di dipendenza. Tuttavia, in generale, rende le cose meno noiose.

Attenzione: NON utilizzate le modifiche fornite in questo articolo se considerate il mercato come un gioco d'azzardo, perché c'è il rischio reale di subire perdite molto elevate.

Anche se l'avvertimento di cui sopra sembra uno scherzo, la verità è che alcune modifiche all'EA lo rendono pericoloso per coloro che sono dipendenti dal gioco d'azzardo in generale.

Alcune delle modifiche che apporteremo qui mirano a migliorare la stabilità e le prestazioni complessive dell'EA. Se volete mantenere alcune delle cose che stiamo eliminando in questo articolo, non è poi così difficile. Grazie al sistema di ordini creato e presente nell'EA, è possibile rimuovere alcuni elementi senza alcun danno. Pertanto, sta a voi decidere se accettare e utilizzare le cose o eliminarle.

2.0. Eliminazione di Chart Trade

Il Chart Trade è qualcosa che ha ancora senso in un sistema di ordini semplice, meno complesso di quello utilizzato nel nostro EA. Ma per il nostro EA, nell'attuale fase di sviluppo, non ha senso avere Chart Trade sul grafico, quindi possiamo rimuoverlo. Se lo si desidera, è possibile mantenerlo modificando semplicemente un comando. È vero, mi piace mantenere le cose semplici, in modo da poterle poi cambiare (o non cambiare) molto rapidamente, in modo che le modifiche non generino stress, come problemi o guasti catastrofici nei punti critici.

Per rendere il controllo molto veloce e allo stesso tempo sicuro, al codice dell’EA è stata aggiunta la seguente definizione:

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

Se questa definizione non esiste o diventa un commento, CHART TRADE non verrà compilato con l'EA. Esaminiamo i punti interessati di questa definizione. La prima e più ovvia è la seguente:

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

Anche se il codice sopra non si trova nel file dell’EA, ma nel file C_IndicatorTradeView.mqh, la definizione sarà visibile al compilatore ovunque nel codice, per cui non dovremo preoccuparci di correggere il codice. In questo caso creiamo semplicemente la definizione in un luogo facilmente accessibile, in questo caso nel codice dell’EA, e la utilizziamo dove necessario.

Ma continuiamo con il file C_IndicatorTradeView.mqh. Poiché possiamo compilare l'EA senza Chart Trade, dobbiamo implementare l'accesso ai dati definiti nella casella di messaggio di inizializzazione dell'EA, come si può vedere nell'immagine seguente:

Ricordate che dobbiamo accedere a questi dati. In precedenza li abbiamo passati a Chart Trade e, quando abbiamo avuto bisogno di conoscerli, ci siamo rivolti a Chart Trade. Ma ora, senza Chart Trade, dovremo seguire un'altra strada per accedere agli stessi dati.

Nel file C_IndicatorTradeView.mqh, questi valori vengono utilizzati solo in un punto — quando creiamo l'indicatore 0 che mostra dove si troverà l'ordine pendente. Questo posto è all'interno della funzione DispatchMessage. È mostrato nel codice sottostante:

// ... 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...

Prestate attenzione alle linee evidenziate. Non è necessario cercare questi valori EA_userXX all'interno del file - non ci sono, perché provengono dal codice dell’EA, come segue:

#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 ?

Questo da solo fornisce già un controllo simile a quello di Chart Trade sul grafico. Notate che in pratica non modifichiamo nulla nel codice. È sufficiente spostare i dati richiesti definiti dall'utente nel posto giusto. Alcuni potrebbero ritenere superflua questa configurazione da parte del trader al momento del caricamento dell'EA, e questo è vero in un certo senso, poiché il sistema di ordini consente di configurare tutte le variabili senza alcuna difficoltà. Quindi, possiamo semplicemente impostare solo il valore minimo del fattore di leva, lo Stop Loss e il Take Profit a 0, e le operazioni iniziali come Day Trade — e farlo nella funzione DispatchMessage della classe C_IndicatorTradeView. Questo non influisce affatto sul sistema, poiché il trader può modificare l'ordine sul grafico e poi inviarlo al server. Questo tipo di modifica dipende da voi, in quanto è qualcosa di molto personale.

2.0.1. Alcuni aggiustamenti

Prima di tornare alla parte in cui rimuoviamo Chart Trade, dobbiamo fare un'altra cosa che migliorerà la stabilità dell'EA nel suo complesso.

Procediamo come segue. Nella classe C_IndicatorTradeView, definiamo una struttura di dati privata, che può essere vista di seguito:

struct st01
{
        bool    ExistOpenPosition,
                SystemInitilized;
}m_InfoSystem;

Deve essere inizializzata nel codice seguente:

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;
}

Perché creare e inizializzare questi dati qui? Ricordate che MetaTrader 5 invia eventi all'EA e uno di questi è OnTick. I sistemi semplici non presentano molti problemi. Ma quando il sistema diventa più complesso, è necessario assicurarsi che tutto funzioni. Può accadere che MetaTrader 5 invii eventi all'EA prima che quest'ultimo sia pronto ad elaborarli. Pertanto, dobbiamo assicurarci che l'EA sia pronto. Creeremo alcune variabili che indicheranno lo stato di prontezza dell'EA. Se non è ancora pronto, gli eventi di MetaTrader 5 devono essere ignorati finché l'EA non è in grado di rispondere in modo appropriato agli eventi.

Il punto più critico è visibile nel codice sottostante:

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;
                        };

I punti evidenziati non esistevano prima, quindi a volte potevano accadere cose strane. Ma ora abbiamo i controlli necessari per garantire che nulla di insolito passi inosservato.

La questione del controllo di tutto è piuttosto complicata, poiché i controlli multipli possono rendere un sistema molto stabile, ma possono anche complicare la manutenzione e la modifica del codice. Per essere efficaci, alcuni controlli devono essere eseguiti in ordine logico, il che è piuttosto costoso da fare.

Tuttavia, quando verifichiamo se esiste o meno una posizione per un simbolo monitorato dall'EA, possiamo dare una certa agilità. A maggior ragione, quando si negoziano più attività, ognuna delle quali ha un certo numero di posizioni che appariranno nell'EA. Filtrando questo punto, eliminiamo il ciclo, in modo che l'EA esegua il codice all'interno del ciclo solo quando è veramente necessario. Altrimenti, riduciamo un po' il tempo di elaborazione consumato dall'EA. Non è lungo, ma in casi molto estremi può fare una grande differenza.

2.0.2. Rimozione di Chart Trade dall'EA

Ora che abbiamo apportato le modifiche alla classe C_IndicatorTradeView, possiamo concentrarci sul codice dell'EA ed eliminare Chart Trade. La prima cosa da fare è eliminarlo dal codice 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;
}

Il codice verde sarà sostituito dal codice blu. Se non si utilizza Chart Trade, può sembrare che la differenza sia minima, che si tratti solo di una modifica della dimensione del file eseguibile. Ma non è solo questo. Notare che oltre al codice Chart Trade è stato rimosso anche l'evento OnTrade. L'EA non elaborerà più questo evento.

Si potrebbe pensare che ci sia qualcosa di sbagliato in me. Come posso rimuovere l'evento OnTrade da un EA? Come gestiremo ora gli eventi di trading? Questi eventi saranno elaborati dall'evento OnTradeTransaction. Il metodo di elaborazione sarà più efficiente di OnTrade, il che significa che l'EA sarà più semplice e affidabile.

C'è un altro momento che sta subendo dei cambiamenti:

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);  
}

Se non c'è integrazione all'interno dell'EA, le uniche righe che verranno compilate saranno quelle evidenziate. Poiché questi eventi tendono a essere abbastanza costanti (più efficiente è la gestione di questi eventi, meglio è), spesso competono con un altro evento che MetaTrader 5 attiva per l'elaborazione dell'EA. Quest'altro evento è illustrato di seguito:

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 evento di questo tipo è un vero incubo, perché di solito viene chiamato più volte e in alcuni casi può essere chiamato più volte in meno di un secondo. Ma grazie alle modifiche apportate al codice della classe C_IndicatorTradeView, l'elaborazione di questo evento è diventata un po' più efficiente. In seguito miglioreremo ulteriormente questa efficienza, ma per ora è sufficiente.

Dopo tutte queste modifiche, Chart Trade non sarà integrato nell'EA. Possiamo trasformare Chart Trade in un indicatore, che avrà alcuni vantaggi mantenendo il funzionamento dell'EA concentrato sull'attività principale: gestione, posizionamento e supporto al sistema di ordini. Ma il passaggio di Chart Trade ad un indicatore comporta alcune modifiche aggiuntive, quindi non mostrerò ora come farlo, lo vedremo in un altro momento. In generale, però, è possibile modificare Chart Trade in un indicatore e continuare a inviare ordini attraverso di esso.

3.0. Aggiunta dei suoni

Spesso non guardiamo il grafico, ma vogliamo comunque sapere cosa sta succedendo al momento. Uno dei modi per essere avvisati di qualcosa è ricevere un avviso sonoro. Questo è uno dei tipi di avviso migliori, perché cattura subito la nostra attenzione. A volte sappiamo già come agire solo ascoltando l'avviso, senza dover controllare altri messaggi.

Impariamo quindi a impostare alcuni avvisi sonori di base. In alcuni casi, si tratta di una frase che ci dice qualcosa di specifico. Anche se ciò che sto mostrando ora e ciò che è disponibile nell'allegato fornisce solo funzioni di base, forse può motivarvi ad aumentare la quantità di avvisi e segnalazioni esistenti, in modo da non dover perdere tempo a leggere i messaggi. Un suono può indicare un evento specifico, consentendo di guadagnare agilità in determinati momenti di trading. Credetemi, questo fa molta differenza.

La prima cosa da fare è creare un nuovo file che contenga la nuova classe e che supporterà e isolerà il nostro sistema audio. Una volta fatto questo, potremo iniziare a produrre in modo molto stabile. L'intera classe è visibile nel codice sottostante:

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;
                }
//+------------------------------------------------------------------+
};

Nonostante l'estrema semplicità di questo codice, c'è qualcosa di interessante all’interno. Notare che stiamo riscrivendo la funzione PlayAlert quindi abbiamo due versioni della stessa funzione. Perché? Il modo in cui il sistema audio funzionerà prevede due varianti. Nel caso della prima versione della funzione, riprodurremo un suono da un file; nella seconda versione riprodurremo il suono che fa parte dell'EA, cioè la sua funzione. Ora c'è qualcosa che molti non sanno fare: riprodurre i suoni direttamente dai file audio. Ma non preoccupatevi, vi mostrerò come fare. Il motivo della prima versione è che alcuni potrebbero voler inserire la propria voce o un altro suono come avviso e cambiarlo in qualsiasi momento senza dover ricompilare l'EA. Infatti, è possibile modificare questi suoni anche quando l'EA è in esecuzione in MetaTrader 5. Dal momento in cui il suono deve essere riprodotto, l'EA utilizzerà la versione più recente, quindi è sufficiente sostituire un file audio con un altro — l'EA non noterà nemmeno la differenza, il che aiuta molto. Ma c'è un'altra ragione che si può notare dal codice dell’EA.

In realtà, la prima opzione viene utilizzata in un punto piuttosto specifico, come si può vedere nel codice della classe evidenziato di seguito:

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....

Immaginate la quantità di lavoro che sarebbe necessaria per elaborare tutti i possibili errori restituiti dal server di trade. Ma se registriamo un file audio e lo nominiamo in base al valore restituito dal server di trade, l'EA saprà quale file riprodurre, semplificandoci notevolmente la vita. Poiché in questo caso è sufficiente specificare quale file utilizzare in base al valore restituito dal server, l'EA troverà e riprodurrà questo file, fornendoci un avviso sonoro o un messaggio vocale in modo da sapere esattamente cosa è successo. Meraviglioso, vero? Ora, ad esempio, se un ordine viene rifiutato, la piattaforma ci informerà in modo molto chiaro su cosa è successo o cosa non va. Questo sarà fatto in un modo molto adeguato che rappresenta qualcosa di specifico per voi, qualcosa che può essere esclusivo e unico per il vostro modo di fare trading e di agire sul mercato. Vedete quanta agilità guadagnerete, perché nello stesso file audio potrete chiarire come risolvere il problema.

Ma esiste anche una seconda modalità di funzionamento, in cui i suoni sono memorizzati all'interno del file eseguibile dell’EA. Questa è la seconda versione della stessa funzione, che verrà utilizzata in questa fase in 3 punti diversi per indicare 3 diversi tipi di eventi. Il primo posto è visibile nel codice sottostante:

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

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

Questo codice verifica se AlgoTrading è abilitato nella piattaforma. Se ci si dimentica di abilitarlo, l'EA ci dirà che non sarà disponibile per il trading. Per verificare se l'opzione è abilitata o meno, è sufficiente osservare l'indicatore nella piattaforma, come mostrato nell'immagine seguente:

Il secondo punto in cui utilizzeremo un suono ausiliario è mostrato di seguito:

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);
}

Ogni volta che viene creato un indicatore di posizione, verrà emesso un suono. Questo ci renderà la vita molto più facile, in quanto sapremo che l'ordine pendente è diventato una posizione e che dobbiamo iniziare a prestargli attenzione.

Il terzo e ultimo punto in cui abbiamo un suono ausiliario è quando una posizione viene chiusa per qualsiasi motivo. Questo avviene in un posto molto preciso:

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();
}

Si potrebbe pensare che quando si rimuove l'EA venga emesso il suono di chiusura della posizione, ma non è così. Questo non accadrà perché la linea del prezzo sarà ancora presente nel sistema. Ma quando la posizione viene chiusa accade qualcosa di diverso, e la linea del prezzo della posizione si troverà al livello di prezzo 0 — in questo momento verrà emesso un suono che indica che la posizione è stata chiusa.

Poiché questi suoni, che sono risorse dell'EA, seguiranno il file eseguibile ovunque esso vada e non possono essere modificati senza ricompilare il codice, sono più limitati, ma allo stesso tempo aiutano a portare l'EA in altri luoghi senza dover portare con sé i file audio.

Ma nel caso dei suoni utilizzati come avviso di guasti o errori, la logica è diversa: devono essere spostati separatamente e collocati in un luogo predeterminato in modo che possano funzionare quando necessario.

L'allegato contiene una cartella chiamata SOUNDS. Non lasciate questa cartella nella stessa cartella in cui si trova il codice, perché i suoni contenuti in questa cartella non verranno riprodotti. Spostatelo in una posizione diversa e facilmente individuabile. Se non sapete dove si trova, non preoccupatevi — lo vedremo più tardi:

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

Quando si esegue questo script, nella barra degli strumenti vengono visualizzate informazioni che indicano la posizione che verrà utilizzata. Un esempio del risultato dell'esecuzione è mostrato nell'immagine seguente:

È necessario eseguire le seguenti operazioni:

1. Aprire l'allegato
2. Aprire Esplora File
3. Andare alla cartella mostrata nella figura precedente
4. Copiare il contenuto della cartella SOUNDS dal file allegato alla cartella indicata sopra.
5. Se si vuole, si possono eliminare questi tre file (WARRING, BEGIN, END), perché verranno compilati insieme all'EA
6. Se si vuole, si può cambiare il contenuto di .WAV con qualcosa di proprio gradimento; basta assicurarsi di non cambiare il nome
7. Utilizzate l'EA nella piattaforma MetaTrader 5 e siate felici!

Ma ricordate che per far sì che i suoni (WARRING, BEGIN, END) vengano compilati nell'EA, dovete avere la cartella SOUNDS con gli stessi suoni nella directory del codice MQL5, altrimenti non verranno integrati nel codice dell'EA.

Conclusioni

In questo articolo abbiamo appreso come aggiungere suoni personalizzati al sistema dell’EA. Qui abbiamo utilizzato un sistema molto semplice per dimostrare come si fa, ma non ci si limita a un EA, si può utilizzare anche negli indicatori o addirittura negli script.

Il bello è che se si utilizzano gli stessi concetti e le stesse idee qui proposte, si possono registrare messaggi vocali che dicono o avvertono di qualcosa. Quando l'EA, o qualsiasi altro processo eseguito da MetaTrader 5 e che utilizza il sistema sonoro, viene attivato tramite i fattori illustrati nell'articolo, riceverete un messaggio sonoro che vi informa o vi avverte di un'azione che avevate già previsto e che dovreste compiere.

E non si tratta di un testo, ma di un messaggio vocale, il che lo rende molto più efficace, in quanto è possibile spiegare rapidamente a chiunque utilizzi il sistema cosa si deve fare o qual è la causa che ha generato il messaggio.

Il sistema non si limita a questo schema e si può andare oltre quanto dimostrato qui. L'idea è proprio questa: permettere all'utente di avere un alleato nella piattaforma. Grazie all'interazione vocale con il trader, possiamo trasmettere un messaggio forse più comprensibile di un semplice testo. L'unica cosa che vi limita è la vostra creatività.