Sviluppo di un Expert Advisor di trading da zero

Introduzione

Aumenta il numero di nuovi utenti nel mercato finanziario. Forse molti di loro non sanno nemmeno come funziona il sistema degli ordini. Tuttavia, ci sono anche utenti che vogliono davvero sapere come vanno le cose. Cercano di capire come funziona il tutto per controllare la situazione.

Naturalmente, MetaTrader 5 offre un elevato livello di controllo sulle posizioni di trading. Tuttavia, utilizzare solo la capacità manuale di effettuare ordini può essere piuttosto difficile e rischioso per gli utenti meno esperti. Inoltre, se qualcuno vuole negoziare contratti futures, quando c'è poco tempo per fare un ordine, tale faorma di trading può trasformarsi in un incubo, perché bisogna compilare correttamente tutti i campi in modo tempestivo, ma questo richiede ancora tempo e quindi si possono perdere buone opportunità o persino perdere denaro se qualche campo viene riempito in modo errato.

Ora, cosa succede se usiamo un Expert Advisor (EA) per semplificare le cose? In questo caso, si possono specificare alcuni dettagli, ad esempio la leva finanziaria o quanto ci si può permetterti di perdere e quanto si vuole guadagnare (in termini monetari, piuttosto che 'punti' o 'pip' non del tutto chiari). Quindi si usa il puntatore del mouse sul grafico per mostrare dove entrare nel mercato e indicare se si comprerà o venderà...

Pianificazione

La parte più difficile nella creazione di qualcosa è capire come dovrebbero funzionare le cose. L'idea dovrebbe essere formulata in modo molto chiaro in modo da poter creare il codice minimo richiesto, poiché più complesso è il codice da creare, maggiore è la possibilità di errori di runtime. Con questo in mente, ho cercato di rendere il codice abbastanza semplice ma comunque utilizzando il massimo delle possibilità fornite da MetaTrader 5. La piattaforma è molto affidabile, viene costantemente testata e quindi non possono esserci errori dal lato della piattaforma.

Il codice utilizzerà OOP (programmazione orientata agli oggetti). Questo approccio consente di isolare il codice e ne facilita la manutenzione e lo sviluppo futuro, nel caso in cui si desideri aggiungere nuove funzionalità e apportare miglioramenti.

Sebbene l'EA discusso in questo articolo sia progettato per il trading su B3 (borsa brasiliana) e in particolare per il trading di futures (Mini Index e Mini Dollar), può essere esteso a tutti i mercati con variazioni minime. Per rendere le cose più facili e non per elencare o controllare le attività di trading, utilizzeremo la seguente enumerazione:

enum eTypeSymbolFast {WIN, WDO, OTHER};

Se vuoi scambiare un altro asset, che utilizza alcune funzionalità speciali, aggiungilo all'enumerazione. Ciò richiederà anche piccole modifiche al codice, ma con l'enumerazione sarà molto più semplice poiché si riduce anche la possibilità di errori. Una parte interessante del codice è la funzione AdjustPrice:

   double AdjustPrice(const double arg)
     {
      double v0, v1;
      if(m_Infos.TypeSymbol == OTHER)
         return arg;
      v0 = (m_Infos.TypeSymbol == WDO ? round(arg * 10.0) : round(arg));
      v1 = fmod(round(v0), 5.0);
      v0 -= ((v1 != 0) || (v1 != 5) ? v1 : 0);
      return (m_Infos.TypeSymbol == WDO ? v0 / 10.0 : v0);
     };

Questa funzione regolerà il valore da utilizzare nel prezzo, in modo da posizionare le linee in punti precisi del grafico. Perché non possiamo semplicemente mettere una linea sul grafico? Questo perché alcuni asset hanno determinati intervalli tra i prezzi. Per WDO (Mini Dollar) questo passaggio è di soli 0,5 punti. Per WIN (Mini Index) questo intervallo è di 5 punti e per le azioni è di 0,01 punti. In altre parole, i valori dei punti differiscono per i diversi asset. Questo adegua il prezzo al valore di tick corretto in modo che nell'ordine venga utilizzato un valore corretto, altrimenti un ordine eseguito in modo errato può essere rifiutato dal server.

Senza questa funzione, potrebbe essere difficile conoscere i valori corretti da utilizzare nell'ordine. E quindi c'è la possibilità per il server di notificare che l'ordine è stato eseguito in modo errato e di impedirne l'esecuzione. Passiamo ora alla funzione che è il cuore dell'Expert Advisor: CreateOrderPendent. La funzione è la seguente:

   ulong CreateOrderPendent(const bool IsBuy, const double Volume, const double Price, const double Take, const double Stop, const bool DayTrade = true)
     {
      double last = SymbolInfoDouble(m_szSymbol, SYMBOL_LAST);
      ZeroMemory(TradeRequest);
      ZeroMemory(TradeResult);
      TradeRequest.action        = TRADE_ACTION_PENDING;
      TradeRequest.symbol        = m_szSymbol;
      TradeRequest.volume        = Volume;
      TradeRequest.type          = (IsBuy ? (last >= Price ? ORDER_TYPE_BUY_LIMIT : ORDER_TYPE_BUY_STOP) : (last < Price ? ORDER_TYPE_SELL_LIMIT : ORDER_TYPE_SELL_STOP));
      TradeRequest.price         = NormalizeDouble(Price, m_Infos.nDigits);
      TradeRequest.sl            = NormalizeDouble(Stop, m_Infos.nDigits);
      TradeRequest.tp            = NormalizeDouble(Take, m_Infos.nDigits);
      TradeRequest.type_time     = (DayTrade ? ORDER_TIME_DAY : ORDER_TIME_GTC);
      TradeRequest.stoplimit     = 0;
      TradeRequest.expiration    = 0;
      TradeRequest.type_filling  = ORDER_FILLING_RETURN;
      TradeRequest.deviation     = 1000;
      TradeRequest.comment       = "Order Generated by Experts Advisor.";
      if(!OrderSend(TradeRequest, TradeResult))
        {
         MessageBox(StringFormat("Error Number: %d", TradeResult.retcode), "Nano EA");
         return 0;
        };
      return TradeResult.order;
     };

Questa funzione è molto semplice ed è progettata per essere sicura. Creeremo qui un ordine OCO (One Cancels the Other), che verrà inviato al server di trading. Tieni presente che stiamo utilizzando ordini LIMIT o STOP. Questo perché questo tipo di ordini è più semplice e la sua esecuzione è garantita anche in caso di brusche variazioni di prezzo.

Il tipo di ordine da utilizzare dipende dal prezzo di esecuzione e dal prezzo corrente dello strumento di trading, nonché dal fatto che tu stia inserendo una posizione di acquisto o di vendita. Questo è implementato nella riga seguente:

TradeRequest.type = (IsBuy ? (last >= Price ? ORDER_TYPE_BUY_LIMIT : ORDER_TYPE_BUY_STOP) : (last < Price ? ORDER_TYPE_SELL_LIMIT : ORDER_TYPE_SELL_STOP));

È inoltre possibile creare un CROSS ORDER, specificando uno strumento di trading nella riga seguente:

TradeRequest.symbol = m_szSymbol;

Ma quando lo fai dovrai anche aggiungere del codice per gestire gli ordini aperti o in sospeso tramite il sistema CROSS ORDER, poiché avrai un grafico 'sbagliato'. Vediamo un esempio. Puoi trovarti sul grafico dell'indice completo (IND) e negoziare il Mini Index (WIN), ma MetaTrader 5 non mostrerà l'ordine WIN aperto o in sospeso quando lo utilizzi sul grafico IND. Pertanto, è necessario aggiungere un codice per rendere visibili gli ordini. Questo può essere fatto leggendo i valori di posizione e presentandoli come linee sul grafico. Questo è molto utile quando fai trading e segui la cronologia di trading dei simboli. Quando utilizzi, ad esempio, CROSS ORDER, puoi negoziare WIN (Mini Index) utilizzando il grafico WIN$ (il grafico della cronologia del Mini Index).

Quindi, presta attenzione alle seguenti righe di codice:

      TradeRequest.price         = NormalizeDouble(Price, m_Infos.nDigits);
      TradeRequest.sl            = NormalizeDouble(Stop, m_Infos.nDigits);
      TradeRequest.tp            = NormalizeDouble(Take, m_Infos.nDigits);

Queste 3 righe creeranno i livelli di arresto dell'ordine OCO e il prezzo di apertura della posizione. Se si negoziano ordini a breve termine, che possono durare solo pochi secondi, non è consigliabile entrare nel trade senza utilizzare gli ordini OCO, poiché la volatilità può far passare il prezzo da un punto all'altro senza una chiara direzione. Quando usi OCO, il server di trading stesso si prenderà cura della nostra posizione. L'ordine OCO apparirà come segue.

Nella finestra di modifica, lo stesso ordine apparirà come segue:

Una volta compilati tutti i campi richiesti, il server gestirà l'ordine. Non appena raggiunge il Max Profit o la Max Loss, il sistema chiuderà l'ordine. Ma se non specifichi Max Profit o Max Loss, l'ordine potrebbe rimanere aperto fino a quando non si verifica un altro evento. Se il tipo di ordine è impostato su Day Trade, il sistema lo chiuderà alla fine della giornata di negoziazione. In caso contrario, la posizione rimarrà aperta fino a quando non la chiuderai manualmente o fino a quando non ci saranno più fondi per mantenere la posizione aperta.

Alcuni sistemi Expert Advisor utilizzano gli ordini per chiudere le posizioni: una volta aperta una posizione, viene inviato un ordine opposto per chiudere la posizione nel punto specificato, con lo stesso volume. Ma questo potrebbe non funzionare in alcuni scenari perché se l'asset va all'asta durante la sessione per qualche motivo, l'ordine in sospeso può essere annullato e dovrebbe essere sostituito. Ciò complicherebbe l'operazione dell'EA, poiché dovresti aggiungere controlli per quali ordini sono attivi e quali no, e se qualcosa non va, l'EA invierebbe gli ordini uno dopo l'altro, senza alcun criterio.

   void Initilize(int nContracts, int FinanceTake, int FinanceStop, color cp, color ct, color cs, bool b1)
     {
      string sz0 = StringSubstr(m_szSymbol = _Symbol, 0, 3);
      double v1 = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE) / SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
      m_Infos.Id = ChartID();
      m_Infos.TypeSymbol = ((sz0 == "WDO") || (sz0 == "DOL") ? WDO : ((sz0 == "WIN") || (sz0 == "IND") ? WIN : OTHER));
      m_Infos.nDigits = (int) SymbolInfoInteger(m_szSymbol, SYMBOL_DIGITS);
      m_Infos.Volume = nContracts * (m_VolMinimal = SymbolInfoDouble(m_szSymbol, SYMBOL_VOLUME_MIN));
      m_Infos.TakeProfit = AdjustPrice(FinanceTake * v1 / m_Infos.Volume);
      m_Infos.StopLoss = AdjustPrice(FinanceStop * v1 / m_Infos.Volume);
      m_Infos.IsDayTrade = b1;
      CreateHLine(m_Infos.szHLinePrice, m_Infos.cPrice = cp);
      CreateHLine(m_Infos.szHLineTake, m_Infos.cTake = ct);
      CreateHLine(m_Infos.szHLineStop, m_Infos.cStop = cs);
      ChartSetInteger(m_Infos.Id, CHART_COLOR_VOLUME, m_Infos.cPrice);
      ChartSetInteger(m_Infos.Id, CHART_COLOR_STOP_LEVEL, m_Infos.cStop);
     };

La routine di cui sopra è responsabile dell'avvio dei dati EA come indicato dall'utente - crea un ordine OCO. Abbiamo solo bisogno di apportare la seguente modifica a questa routine.

m_Infos.TypeSymbol = ((sz0 == "WDO") || (sz0 == "DOL") ? WDO : ((sz0 == "WIN") || (sz0 == "IND") ? WIN : OTHER));

Qui aggiungiamo il tipo di simbolo di trading oltre a quelli attuali, se c'è bisogno di qualcosa di specifico.

      m_Infos.Volume = nContracts * (m_VolMinimal = SymbolInfoDouble(m_szSymbol, SYMBOL_VOLUME_MIN));
      m_Infos.TakeProfit = AdjustPrice(FinanceTake * v1 / m_Infos.Volume);
      m_Infos.StopLoss = AdjustPrice(FinanceStop * v1 / m_Infos.Volume);

Le tre righe precedenti apportano le modifiche necessarie per la corretta creazione dell'ordine. nContracts è un fattore di leva, usa valori come 1, 2, 3 ecc. In altre parole, non è necessario conoscere il volume minimo dei simboli da negoziare. Tutto ciò di cui c'è veramente bisogno è indicare il fattore di leva di questo volume minimo. Ad esempio, se il volume minimo richiesto è di 5 contratti e si specifica il fattore di leva pari a 3, il sistema aprirà un ordine di 15 contratti. Le altre due linee impostano di conseguenza Take Profit e Stop Loss, in base ai parametri specificati dall'utente. I livelli si regolano con il volume dell'ordine: se l'ordine aumenta, il livello diminuisce e viceversa. Con questo codice, non si dovranno fare calcoli per creare una posizione: l'EA calcolerà tutto da solo: istruisci l'EA su quale strumento finanziario negoziare con quale fattore di leva, quanti soldi vuoi guadagnare e quanto sei pronto a perdere, e EA effettuerà un ordine appropriato per te.

   inline void MoveTo(int X, int Y, uint Key)
     {
      int w = 0;
      datetime dt;
      bool bEClick, bKeyBuy, bKeySell;
      double take = 0, stop = 0, price;
      bEClick  = (Key & 0x01) == 0x01;    //Left mouse button click
      bKeyBuy  = (Key & 0x04) == 0x04;    //Pressed SHIFT
      bKeySell = (Key & 0x08) == 0x08;    //Pressed CTRL
      ChartXYToTimePrice(m_Infos.Id, X, Y, w, dt, price);
      ObjectMove(m_Infos.Id, m_Infos.szHLinePrice, 0, 0, price = (bKeyBuy != bKeySell ? AdjustPrice(price) : 0));
      ObjectMove(m_Infos.Id, m_Infos.szHLineTake, 0, 0, take = price + (m_Infos.TakeProfit * (bKeyBuy ? 1 : -1)));
      ObjectMove(m_Infos.Id, m_Infos.szHLineStop, 0, 0, stop = price + (m_Infos.StopLoss * (bKeyBuy ? -1 : 1)));
      if((bEClick) && (bKeyBuy != bKeySell))
         CreateOrderPendent(bKeyBuy, m_Infos.Volume, price, take, stop, m_Infos.IsDayTrade);
      ObjectSetInteger(m_Infos.Id, m_Infos.szHLinePrice, OBJPROP_COLOR, (bKeyBuy != bKeySell ? m_Infos.cPrice : clrNONE));
      ObjectSetInteger(m_Infos.Id, m_Infos.szHLineTake, OBJPROP_COLOR, (take > 0 ? m_Infos.cTake : clrNONE));
      ObjectSetInteger(m_Infos.Id, m_Infos.szHLineStop, OBJPROP_COLOR, (stop > 0 ? m_Infos.cStop : clrNONE));
     };

Il codice sopra presenterà l'ordine da creare. Usa il movimento del mouse per mostrare dove verrà piazzato l'ordine. Ma vuoi informare l'EA se vuoi acquistare (tieni premuto MAIUSC) o vendere (tieni premuto CTRL). Dopo aver fatto clic con il pulsante sinistro del mouse, a quel punto verrà creato un ordine in sospeso.

Se hai bisogno di più dati da visualizzare, ad esempio il punto di pareggio, aggiungi l'oggetto pertinente al codice.

Ora abbiamo un intero EA che funziona e può creare ordini OCO. Ma non tutto qui è perfetto...

Problema con gli ordini OCO

Gli ordini OCO hanno un problema, che non dipenda dal sistema MetaTrader 5 o del server di trading. È connesso con la stessa volatilità che è costantemente presente nel mercato. Teoricamente, il prezzo dovrebbe muoversi in modo lineare, senza rollback, ma a volte abbiamo un'elevata volatilità, che crea gap all'interno di una candela. Quando questi gap si verificano nel punto in cui si trova il prezzo dell'ordine Stop Loss o Take Profit, questi punti non si attiveranno e, pertanto, la posizione non verrà chiusa. Può anche succedere che quando l'utente sposta questi punti, il prezzo possa trovarsi oltre il corridoio formato dallo stop loss e dal take profit. Anche in questo caso l'ordine non verrà chiuso. Questa è una situazione molto pericolosa che è impossibile da prevedere. Come programmatore, devi fornire un meccanismo pertinente per ridurre al minimo i possibili danni.

Per aggiornare il prezzo e cercare di mantenerlo all'interno del corridoio, utilizzeremo due subroutine. Il primo è il seguente:

   void UpdatePosition(void)
     {
      for(int i0 = PositionsTotal() - 1; i0 >= 0; i0--)
         if(PositionGetSymbol(i0) == m_szSymbol)
           {
            m_Take      = PositionGetDouble(POSITION_TP);
            m_Stop      = PositionGetDouble(POSITION_SL);
            m_IsBuy     = PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY;
            m_Volume    = PositionGetDouble(POSITION_VOLUME);
            m_Ticket    = PositionGetInteger(POSITION_TICKET);
           }
     };

Sarà chiamato in OnTrade - la funzione chiamata da MetaTrader 5 ad ogni cambio di posizione. La successiva subroutine da utilizzare è chiamata da OnTick. Controlla e si assicura che il prezzo rientri nel corridoio o entro i limiti dell'ordine OCO. È il seguente:

   inline bool CheckPosition(const double price = 0, const int factor = 0)
     {
      double last;
      if(m_Ticket == 0)
         return false;
      last = SymbolInfoDouble(m_szSymbol, SYMBOL_LAST);
      if(m_IsBuy)
        {
         if((last > m_Take) || (last < m_Stop))
            return ClosePosition();
         if((price > 0) && (price >= last))
            return ClosePosition(factor);
        }
      else
        {
         if((last < m_Take) || (last > m_Stop))
            return ClosePosition();
         if((price > 0) && (price <= last))
            return ClosePosition(factor);
        }
      return false;
     };

Questo frammento di codice è fondamentale in quanto verrà eseguito ad ogni cambio di tick e quindi deve essere il più semplice possibile in modo che calcoli e test vengano eseguiti nel modo più efficiente possibile. Si prega di notare che mentre manteniamo il prezzo all'interno del corridoio, controlliamo anche qualcosa di interessante, che può essere rimossa se lo si desidera. Spiegherò questo test aggiuntivo nella prossima sezione. All'interno di questa subroutine, abbiamo la seguente chiamata di funzione:

   bool ClosePosition(const int arg = 0)
     {
      double v1 = arg * m_VolMinimal;
      if(!PositionSelectByTicket(m_Ticket))
         return false;
      ZeroMemory(TradeRequest);
      ZeroMemory(TradeResult);
      TradeRequest.action     = TRADE_ACTION_DEAL;
      TradeRequest.type       = (m_IsBuy ? ORDER_TYPE_SELL : ORDER_TYPE_BUY);
      TradeRequest.price      = SymbolInfoDouble(m_szSymbol, (m_IsBuy ? SYMBOL_BID : SYMBOL_ASK));
      TradeRequest.position   = m_Ticket;
      TradeRequest.symbol     = m_szSymbol;
      TradeRequest.volume     = ((v1 == 0) || (v1 > m_Volume) ? m_Volume : v1);
      TradeRequest.deviation  = 1000;
      if(!OrderSend(TradeRequest, TradeResult))
        {
         MessageBox(StringFormat("Error Number: %d", TradeResult.retcode), "Nano EA");
         return false;
        }
      else
         m_Ticket = 0;
      return true;
     };

La funzione chiuderà il volume specificato e fungerà da protezione. Tuttavia, non dimenticare che devi essere connesso, poiché la funzione viene eseguita nel terminale client MetaTrader 5: se la connessione al server fallisce, questa funzione sarà completamente inutile.

Guardando questi ultimi due codici, possiamo vedere che possiamo eliminare il volume dato ad un certo punto. In questo modo o chiudiamo parzialmente o riduciamo la nostra esposizione. Scopriamo come utilizzare questa funzione.

Lavorare con ordini parziali

Gli ordini parziali sono qualcosa che piace ed è utilizzata da molti trader. L'Expert Advisor consente di lavorare con chiusura parziale, ma non mostrerò come implementare tale codice, poiché gli ordini parziali dovrebbero essere oggetto di un problema separato. Tuttavia, se si desidera implementare il lavoro con chiusure parziali, è sufficiente chiamare la routine CheckPosition e specificare il prezzo a cui verrà eseguito l'ordine e il volume, mentre l'EA farà il resto.

Dico che gli ordini parziali sono un caso a parte perché sono molto individuali ed è difficile creare una soluzione generalizzata che soddisfi tutti. L'uso di un array dinamico non sarebbe adatto qui, poiché potresti andare alla cieca: funzionerà per il day trading solo se non chiuderai l'EA. Se è necessario chiudere l'EA per qualsiasi motivo, la soluzione array non funzionerà. Dovrai utilizzare un supporto di archiviazione, in cui la formattazione dei dati dipenderà da cosa farai con questi dati.

In ogni caso, dovresti evitare il più possibile chiusure parziali utilizzando l'ordine di apertura delle posizioni, poiché il rischio di avere dei mal di testa è enorme. Lascia che ti spieghi: supponiamo che tu abbia una posizione di acquisto con leva 3x e desideri realizzare un profitto di 2x pur avendo una posizione con leva 1x. Questo può essere fatto vendendo una leva 2x. Tuttavia, se il tuo EA invia un ordine di vendita a mercato, può accadere che la volatilità faccia aumentare il prezzo e raggiunga il tuo Take Profit prima che l'ordine di vendita venga effettivamente eseguito. In questo caso l'EA aprirà una nuova posizione corta in direzione sfavorevole. Facoltativamente, puoi inviare un Sell Limit o un Sell Stop per ridurre la posizione della leva 2x. Questa potrebbe sembrare una soluzione adeguata. Ma cosa succede se un altro ordine viene inviato prima che il prezzo raggiunga il punto parziale - puoi avere una sorpresa molto spiacevole: la posizione aperta verrà interrotta e poco dopo l'ordine si riaprirà e aumenterà le perdite. Se la volatilità diventa più forte, la situazione diventerà la stessa di cui abbiamo parlato sopra.

Quindi, a mio avviso, come programmatore, l'opzione migliore per effettuare ordini parziali è emulare l'invio di ordini al prezzo di mercato. Ma dovresti stare molto attento a non superare il volume aperto. In questo EA l'ho fatto esattamente in questo modo. Se lo desideri, puoi implementare altri metodi di chiusura parziale.

Conclusione

Creare un Expert Advisor per il trading non è così banale come pensano alcune persone; è abbastanza semplice rispetto ad alcuni degli altri problemi che spesso affrontiamo durante la programmazione, tuttavia costruire qualcosa di abbastanza stabile e affidabile da rischiare i tuoi soldi è qualcosa che spesso è un compito difficile. In questo articolo ho suggerito qualcosa che può semplificare la vita a coloro che stanno iniziando a utilizzare MetaTrader 5 e non hanno le conoscenze necessarie per programmare un EA. Questo è un buon inizio, poiché questo EA non apre gli ordini ma aiuta solo ad aprire gli ordini in un modo più affidabile. Una volta effettuato l'ordine, l'EA non ha nient'altro da fare e MetaTrader 5 inizia a funzionare, ad eccezione dei frammenti di codice sopra menzionati.

L'Expert Advisor presentato in questo articolo può essere migliorato in vari modi per lavorare con set di parametri, ma ciò richiederebbe più codice che lo renderà più indipendente da MetaTrader 5.

Il grande successo di questo EA è che utilizza MetaTrader 5 stesso per eseguire azioni che non sono nel suo codice, e quindi è estremamente stabile e affidabile.