Se sei un trader esperto o alle prime armi, probabilmente hai già sentito parlare del MetaTrader 5 e del suo potente indicatore MACD. Oggi parliamo dell'EA MACD Sample, un esempio di come utilizzare questo indicatore per migliorare le tue operazioni di trading.
Il file dell'Expert Advisor MACD Sample.mq5 si trova nella cartella terminal_data_folder\MQL5\Experts\Examples\MACD\. Questo EA è un esempio perfetto di un approccio orientato agli oggetti nello sviluppo degli Expert Advisor.
1. Proprietà dell'EA
1.1. Proprietà dell'EA
//+------------------------------------------------------------------+ //| MACD Sample.mq5 | //| Copyright 2009-2013, MetaQuotes Software Corp. | //| https://www.mql5.com | //+------------------------------------------------------------------+
Le prime cinque righe contengono un commento, mentre le righe successive impostano le proprietà del programma MQL5 (copyright, link, versione e descrizione) utilizzando le direttive del preprocessore #property.
Quando esegui l'Expert Advisor, queste informazioni vengono visualizzate nella scheda "Comune":
Figura 1: Parametri comuni dell'EA MACD Sample
1.2. File Inclusi
Successivamente, la direttiva #include indica al compilatore di includere i file che contengono le classi di trading della Libreria Standard.
- Trade.mqh (CTrade - classe per operazioni di trading);
- SymbolInfo.mqh (CSymbolInfo - classe per lavorare con le proprietà di uno strumento di trading);
- PositionInfo.mqh (CPositionInfo - classe per lavorare con le proprietà delle posizioni aperte);
- AccountInfo.mqh (CAccountInfo - classe per lavorare con le proprietà del conto di trading).
//--- file inclusi #include <Trade\Trade.mqh> #include <Trade\SymbolInfo.mqh> #include <Trade\PositionInfo.mqh> #include <Trade\AccountInfo.mqh>
Le istanze delle classi appropriate vengono poi utilizzate come variabili membro della classe CExpert (Sezione 3).
1.3. Input
Successivamente troviamo il tipo, il nome, i valori predefiniti e un commento. Il loro ruolo è mostrato nella figura 2.
//--- Parametri di input dell'Expert Advisor input double InpLots = 0.1; // Lots input int InpTakeProfit = 50; // Take Profit (in pips) input int InpTrailingStop = 30; // Livello di Trailing Stop (in pips) input int InpMACDOpenLevel = 3; // Livello di apertura MACD (in pips) input int InpMACDCloseLevel = 2; // Livello di chiusura MACD (in pips) input int InpMATrendPeriod = 26; // Periodo di tendenza MA
Nota che i nomi dei parametri di input iniziano con il prefisso "Inp", mentre le variabili globali hanno il prefisso "Ext". Questo approccio semplifica l'uso di molte variabili diverse.
InpLots rappresenta il volume di trading, mentre InpTakeProfit e InpTrailingStop determinano i livelli di Take Profit e Trailing Stop.
I commenti accanto ai parametri di input, insieme ai valori predefiniti, sono visualizzati nella scheda "Opzioni" invece del nome del parametro:
Figura 2: Parametri di input dell'EA MACD Sample
1.4. Variabili Globali
Successivamente viene dichiarata la variabile globale ExtTimeOut, che verrà utilizzata per controllare il tempo di esecuzione delle operazioni di trading.
int ExtTimeOut=10; // tempo (in secondi) tra le operazioni di trading
Dopo la dichiarazione della classe CSampleExpert, nella riga 76 viene dichiarata un'altra variabile globale: ExtExpert - istanza della classe CSampleExpert:
//--- la variabile globale ExtExpert CSampleExpert ExtExpert;
L'oggetto ExtExpert (campione della classe CSampleExpert) contiene la logica di base della strategia di trading (Sezione 3).
2. Funzioni di Gestione Eventi
Le funzioni di gestione eventi sono cruciali per il funzionamento dell'EA. Vediamo in dettaglio:
2.1. Funzione di inizializzazione OnInit()
La funzione OnInit() viene chiamata una sola volta all'avvio iniziale dell'Expert Advisor. Durante l'handler di eventi OnInit(), l'EA è preparato per l'operazione: i parametri di input vengono controllati, gli indicatori e i parametri vengono inizializzati, ecc. In caso di errori critici, la funzione esce con un codice di ritorno INIT_FAILED.
//+------------------------------------------------------------------+ //| Funzione di inizializzazione dell'Expert |
//+------------------------------------------------------------------+
int OnInit(void) {
//--- inizializzazione e creazione di tutti gli oggetti richiesti
if(!ExtExpert.Init())
return(INIT_FAILED);
//--- inizializzazione avvenuta con successo
return(INIT_SUCCEEDED);
}
In questo caso, viene chiamato il metodo Init() dell'oggetto ExtExpert, che restituisce true o false a seconda della preparazione di tutti gli oggetti richiesti per l'operazione.
2.2. Funzione OnTick()
La funzione OnTick() viene chiamata ogni volta che viene ricevuta una nuova quotazione per il simbolo del grafico su cui viene eseguito l'EA.
//+------------------------------------------------------------------+ //| Funzione di gestione del nuovo tick dell'Expert | //+------------------------------------------------------------------+
void OnTick(void) {
static datetime limit_time=0; // memorizza l'ora dell'ultima chiamata + timeout
//--- non operare se non è trascorso il tempo richiesto
if(TimeCurrent()>=limit_time) {
//--- controllo dati
if(Bars(Symbol(),Period())>2*InpMATrendPeriod) {
//--- dopo la chiamata al metodo Processing() aumentare il valore di limit_time di ExtTimeOut
if(ExtExpert.Processing())
limit_time=TimeCurrent()+ExtTimeOut;
}
}
}
All'interno dell'handler di eventi OnTick() è incluso un meccanismo per chiamate periodiche del metodo ExtExpert.Processing(), che viene utilizzato per l'analisi di mercato e le operazioni di trading quando le condizioni di trading sono soddisfatte.
2.3. Funzione di deinizializzazione OnDeInit()
La funzione OnDeInit() viene chiamata quando un EA viene rimosso dal grafico. Se un programma posiziona oggetti grafici durante l'operazione, possono essere rimossi dal grafico.
In questo esempio non viene utilizzata alcuna funzione di deinizializzazione, quindi non vengono eseguite azioni.
3. La classe CSampleExpert
3.1. La classe CSampleExpert
//+------------------------------------------------------------------+ //| Esempio della classe EA MACD Sample |
//+------------------------------------------------------------------+
class CSampleExpert {
protected: //--- variabili protette - membri della classe disponibili solo all'interno dei metodi della classe
double m_adjusted_point; // moltiplicatore per quotazioni 3/5 cifre
CTrade m_trade; // campione classe CTrade
CSymbolInfo m_symbol; // campione classe CSymbolInfo
CPositionInfo m_position; // campione classe CPositionInfo
CAccountInfo m_account; // campione classe CAccountInfo
//--- gestori degli indicatori
int m_handle_macd; // gestore dell'indicatore MACD
int m_handle_ema; // gestore dell'indicatore Moving Average
//--- buffer degli indicatori
double m_buff_MACD_main[]; // buffer della linea principale dell'indicatore MACD
double m_buff_MACD_signal[]; // buffer della linea di segnale dell'indicatore MACD
double m_buff_EMA[]; // buffer dell'indicatore EMA
//--- valori correnti degli indicatori
double m_macd_current;
double m_macd_previous;
double m_signal_current;
double m_signal_previous;
double m_ema_current;
double m_ema_previous;
//--- livelli (in punti standard)
double m_macd_open_level;
double m_macd_close_level;
double m_traling_stop;
double m_take_profit;
public: //--- costruttore
CSampleExpert(void);
//--- distruttore
~CSampleExpert(void);
//--- metodo di inizializzazione
bool Init(void);
//--- metodo di deinizializzazione
void Deinit(void);
//--- metodo di elaborazione
bool Processing(void);
protected: //--- metodi protetti accessibili solo all'interno dei metodi della classe
bool InitCheckParameters(const int digits_adjust);
bool InitIndicators(void);
bool LongClosed(void);
bool ShortClosed(void);
bool LongModified(void);
bool ShortModified(void);
bool LongOpened(void);
bool ShortOpened(void);
};
La classe EA contiene la dichiarazione di variabili (membri della classe) e funzioni (metodi della classe).
Per semplificare il lavoro con le variabili, tutti i membri della classe hanno il prefisso "m_" (membro), che indica che una variabile è un membro della classe. Prima della dichiarazione di una variabile o di un metodo, viene specificato il tipo.
La visibilità delle variabili e dei metodi membri della classe è definita utilizzando modificatori di accesso. Nella classe CSampleExpert vengono utilizzati i modificatori protected e public. Tutte le variabili e i metodi definiti nella sezione pubblica sono pubblici e accessibili dall'esterno. La classe CSampleExpert ha cinque di questi metodi:
- CSampleExpert(void) - un costruttore (chiamato automaticamente quando si crea un'istanza della classe);
- ~CSampleExpert(void) - un distruttore (chiamato automaticamente quando si elimina un'istanza della classe);
- bool Init(void) - metodo di inizializzazione, in cui vengono preparati tutti i dati necessari per l'operazione;
- void Deinit(void) - metodo di deinizializzazione;
- bool Processing(void) - metodo di elaborazione.
Le variabili membri della classe dichiarate con il modificatore di accesso protected saranno disponibili solo all'interno dei metodi della classe CSampleExpert (e nelle classi figlie).
3.2. Il Costruttore della Classe CSampleExpert
//+------------------------------------------------------------------+ //| Costruttore della Classe CSampleExpert |
CSampleExpert::CSampleExpert(void) : m_adjusted_point(0),
m_handle_macd(INVALID_HANDLE),
m_handle_ema(INVALID_HANDLE),
m_macd_current(0),
m_macd_previous(0),
m_signal_current(0),
m_signal_previous(0),
m_ema_current(0),
m_ema_previous(0),
m_macd_open_level(0),
m_macd_close_level(0),
m_traling_stop(0),
m_take_profit(0) {
ArraySetAsSeries(m_buff_MACD_main,true);
ArraySetAsSeries(m_buff_MACD_signal,true);
ArraySetAsSeries(m_buff_EMA,true);
}
Il costruttore della classe viene chiamato automaticamente quando viene creato un oggetto della classe. Durante la chiamata, vengono impostati i valori predefiniti (tra parentesi) per le variabili membri della classe.
3.3. Il Distruttore della Classe CSampleExpert
//+------------------------------------------------------------------+ //| Distruttore della classe CSampleExpert |
CSampleExpert::~CSampleExpert(void) {
}
Il distruttore della classe CSampleExpert non contiene alcun codice.
3.4. Il Metodo Init della Classe CSampleExpert
//+------------------------------------------------------------------+ //| Inizializzazione e verifica dei parametri di input |
bool CSampleExpert::Init(void) {
m_symbol.Name(Symbol()); // simbolo
m_trade.SetExpertMagicNumber(12345); // magic
int digits_adjust=1;
if(m_symbol.Digits()==3 || m_symbol.Digits()==5)
digits_adjust=10;
m_adjusted_point=m_symbol.Point()*digits_adjust;
m_macd_open_level = InpMACDOpenLevel*m_adjusted_point;
m_macd_close_level= InpMACDCloseLevel*m_adjusted_point;
m_traling_stop = InpTrailingStop*m_adjusted_point;
m_take_profit = InpTakeProfit*m_adjusted_point;
m_trade.SetDeviationInPoints(3*digits_adjust);
if(!InitCheckParameters(digits_adjust))
return(false);
if(!InitIndicators())
return(false);
return(true);
}
Nel metodo Init(), le variabili membri della classe vengono inizializzate e i parametri di input vengono verificati.
4. Backtesting
Puoi trovare i migliori valori dei parametri utilizzando il Tester di Strategia del terminale MetaTrader 5.
La figura 3 mostra i risultati del test dell'Expert Advisor per il 2013 con le impostazioni predefinite.
Figura 3: Risultati del backtesting dell'Expert Advisor MACD Sample
Conclusioni
Il MACD Sample Expert Advisor, incluso nel pacchetto standard del MetaTrader 5, è un esempio di approccio orientato agli oggetti nello sviluppo degli Expert Advisor. Sfruttando al massimo questo strumento, potrai migliorare le tue operazioni di trading e ottimizzare i tuoi profitti.
Commento 0