Come creare un indicatore personalizzato (Heiken Ashi) utilizzando MQL5
312
0
Introduzione
Tutti noi abbiamo bisogno di leggere i grafici e qualsiasi strumento che possa essere utile in questo compito sarà molto apprezzato. Tra gli strumenti che possono essere utili nella lettura dei grafici vi sono gli indicatori calcolati in base ai prezzi, al volume, a un altro indicatore tecnico o a una loro combinazione, sebbene siano molte le idee che esistono nel mondo del trading. Abbiamo a disposizione molti indicatori già pronti integrati nel terminale di trading e se abbiamo bisogno di aggiungere alcune caratteristiche che si adattino al nostro stile di trading, possiamo incontrare qualche difficoltà perché potrebbe non essere modificabile, oltre a non trovare questo indicatore come incorporato nel terminale di trading.
In questo articolo condividerò con voi un metodo per superare questa sfida sfruttando la funzione iCustom e creando il vostro indicatore personalizzato secondo le vostre condizioni e in base alle vostre preferenze. Vedremo anche un esempio, creeremo un indicatore tecnico Heiken Ashi personalizzato e lo utilizzeremo negli esempi dei sistemi di trading. Ne parleremo attraverso i seguenti argomenti:
- Indicatore Personalizzato e Definizione di Heiken Ashi
- Indicatore Heiken Ashi Semplice
- EA basato sull'Indicatore Heiken Ashi Personalizzato
- Heiken Ashi - Sistema EMA
- Conclusioni
Dopo aver compreso quanto condiviso negli argomenti precedenti, dovreste essere in grado di creare il vostro indicatore personalizzato che vi aiuterà nella lettura dei grafici e che potrete utilizzare nel vostro sistema di trading. Utilizzeremo il linguaggio MQL5 (MetaQuotes Language), integrato nella piattaforma di trading MetaTrader 5, per scrivere i codici degli indicatori che verranno creati e degli EA. Se non sapete come scaricarli e utilizzarli, potete leggere l'argomento Scrivere codice MQL5 in MetaEditor da un precedente articolo, che può esservi utile.
Indicatore personalizzato e definizione di Heiken Ashi
In questa parte, impareremo a conoscere in modo più dettagliato l'indicatore personalizzato e l'indicatore Heiken Ashi. Come ho accennato nell'introduzione della sezione precedente, l'indicatore personalizzato è uno strumento di analisi tecnica che può essere creato dall'utente utilizzando il linguaggio di programmazione MQL5. Può essere utilizzato in MetaTrader 5 per analizzare e comprendere il movimento del mercato e può aiutare a prendere decisioni di investimento informate. Esistono molti utili indicatori tecnici integrati, ma a volte è necessario analizzare e comprendere come si sta muovendo il mercato sulla base di alcuni concetti matematici, statistici o tecnici aggiuntivi e specifici, e questi concetti non esistono nell'indicatore incorporato o non c'è nessun indicatore in grado di svolgere il compito. In questi casi, quindi, dobbiamo creare noi stessi l'indicatore - e questa è una delle caratteristiche della piattaforma MetaTrader 5, che ci aiuta a creare i nostri strumenti analitici o di trading per soddisfare le nostre preferenze e obiettivi specifici.
Consideriamo le fasi necessarie per iniziare a creare il vostro indicatore personalizzato:
Aprite l'IDE MetaEditor e scegliete la cartella 'Indicatori' nel Navigatore.
Fare clic sul pulsante "Nuovo" per creare un nuovo programma, come mostrato nell'immagine seguente.
Si aprirà quindi la seguente finestra, nella quale si dovrà scegliere il tipo di programma da creare. Qui scegliamo "Indicatore Personalizzato".
Dopo aver fatto clic su "Avanti", si aprirà la seguente finestra con i dettagli dell'indicatore. Specificare qui il nome dell'indicatore personalizzato e fare clic su "Avanti".
Nelle prossime finestre, si procederà alla determinazione di ulteriori dettagli dell'indicatore
Una volta completata l'impostazione delle preferenze e fatto clic su "Avanti" e poi su "Fine", si aprirà la finestra dell'editor, dove scriveremo il codice dell'indicatore.
Vediamo come sviluppare un indicatore personalizzato utilizzando come esempio l'Heiken Ashi. Dobbiamo quindi saperne di più sull'indicatore tecnico Heiken Ashi. Si tratta di un metodo grafico di tipo candlesticks che può essere utilizzato per presentare e analizzare il movimento del mercato e può essere utilizzato insieme ad altri strumenti per ottenere approfondimenti efficaci e migliori, in base ai quali possiamo prendere decisioni di trading informate dopo aver trovato buone idee e potenziali opportunità di trading.
I grafici Heiken Ashi sono simili ai normali grafici tecnici a candele, ma il calcolo per tracciare queste candele è differente. Vale a dire, esistono due metodi che si differenziano tra loro. Come sappiamo, il normale grafico a candele calcola i prezzi in base ai prezzi effettivi di apertura, massimo, minimo e chiusura in un periodo specifico, ma l'Heiken Ashi prende in considerazione i prezzi simili precedenti (apertura, massimo, minimo e chiusura) quando calcola le sue candele.
Ecco come vengono calcolati i valori rilevanti per l'Heiken Ashi:
- Apertura = (apertura della candela precedente + chiusura della candela precedente) / 2
- Chiusura = (apertura + chiusura + massimo + minimo della candela corrente) / 4
- Massimo = il valore più alto tra il massimo, l'apertura o la chiusura del periodo corrente.
- Minimo = il valore più basso tra il minimo, l'apertura o la chiusura del periodo corrente.
In base al calcolo, l'indicatore costruisce candele rialziste e ribassiste e i colori di queste candele indicano la relativa direzione del mercato: se è rialzista o ribassista. Di seguito è riportato un esempio che mostra le candele Giapponesi tradizionali e l'Heiken Ashi, in modo da vedere la differenza dal punto di vista visivo.
Nella schermata del grafico precedente, la parte superiore mostra le candele tradizionali, mentre nella parte inferiore è presente l'indicatore Heiken Ashi che appare come candele blu e rosse che definiscono la direzione del mercato. L'obiettivo di questo indicatore, secondo il suo calcolo, è quello di filtrare ed eliminare parte del rumore nel movimento del mercato, smussando i dati per evitare falsi segnali.
Indicatore Heiken Ashi Semplice
In questa parte, creeremo un semplice indicatore Heiken Ashi da utilizzare in MetaTrader 5. L'indicatore deve controllare continuamente i prezzi (apertura, massimo, minimo e chiusura) ed eseguire i calcoli matematici per generare i valori haOpen, haHigh, haLow e haClose. In base ai calcoli, l'indicatore dovrebbe tracciare i valori sul grafico sotto forma di candele di colori differenti: blu se la direzione della candela è rialzista e rossa se è ribassista. Le candele devono essere visualizzate in una finestra separata sotto il grafico tradizionale come sottofinestra.
Vediamo tutti i passaggi da completare per creare questo indicatore personalizzato.
Determinare le impostazioni dell'indicatore specificando parametri aggiuntivi tramite i valori #property e identifier, come segue:
- (indicator_separate_window) per mostrare l'indicatore in una finestra separata.
- (indicator_buffers) per determinare il numero di buffer per il calcolo dell'indicatore.
- (indicator_plots) per determinare il numero di serie grafiche nell'indicatore. Le serie grafiche sono stili di disegno che possono essere utilizzati per la creazione di un indicatore personalizzato.
- (indicator_typeN) per determinare il tipo di tracciato grafico a partire dai valori di (ENUM_DRAW_TYPE), N è il numero di serie grafiche che abbiamo determinato nell'ultimo parametro e parte da 1.
- (indicator_colorN) per determinare il colore di N, N è anche il numero di serie grafiche che abbiamo determinato in precedenza e parte da 1.
- (indicator_widthN) per determinare anche lo spessore delle serie N o grafiche.
- (indicator_labelN) per impostare un'etichetta per N delle serie grafiche determinate.
#property indicator_separate_window #property indicator_buffers 5 #property indicator_plots 1 #property indicator_type1 DRAW_COLOR_CANDLES #property indicator_color1 clrBlue, clrRed #property indicator_width1 2 #property indicator_label1 "Heiken Ashi Open;Heiken Ashi High;Heiken Ashi Low;Heiken Ashi Close"
Creare cinque array per i cinque buffer dell'indicatore (haOpen, haHigh, haLow, haClose, haColor) di tipo double.
double haOpen[]; double haHigh[]; double haLow[]; double haClose[]; double haColor[];
All'interno di OnInit(), questa funzione viene utilizzata per inizializzare l’esecuzione di un indicatore.
int OnInit()
Ordinamento dei buffer dell’indicatori con un array dinamico monodimensionale di tipo double mediante la funzione (SetIndexBuffer). I suoi parametri sono:
- index: il numero del buffer dell'indicatore, parte da 0; questo numero deve essere inferiore al valore dichiarato nel parametro determinato (indicator_buffers).
- buffer[]: l'array dichiarato nel nostro indicatore personalizzato.
- data_type: il tipo di dati da memorizzare nell'array dell’indicatore.
SetIndexBuffer(0,haOpen,INDICATOR_DATA); SetIndexBuffer(1,haHigh,INDICATOR_DATA); SetIndexBuffer(2,haLow,INDICATOR_DATA); SetIndexBuffer(3,haClose,INDICATOR_DATA); SetIndexBuffer(4,haColor,INDICATOR_COLOR_INDEX);
Impostazione del valore della proprietà dell'indicatore corrispondente utilizzando la funzione (IndicatorSetInteger) con la variante di chiamata in cui si specifica l'identificatore della proprietà. I suoi parametri sono:
- prop_id: l'identificatore della proprietà che può essere uno degli (ENUM_CUSTOMIND_PROPERTY_INTEGER), noi specificheremo (INDICATOR_DIGITS).
- prop_value: il valore della proprietà, specificheremo (_Digits).
IndicatorSetInteger(INDICATOR_DIGITS,_Digits);
Impostazione del valore della proprietà di tipo stringa corrispondente con la variante di chiamata in cui si specifica anche l'identificatore della proprietà. I suoi parametri sono:
- prop_id: l'identificatore della proprietà, che può essere uno degli (ENUM_CUSTOMIND_PROPERTY_STRING); noi specificheremo (INDICATOR_SHORTNAME) per utilizzare un nome breve per l'indicatore.
- prop_value: il valore della proprietà che specificheremo ("Simple Heiken Ashi").
IndicatorSetString(INDICATOR_SHORTNAME,"Simple Heiken Ashi");
Impostazione del valore della proprietà di tipo double dell'indicatore corrispondente mediante la funzione (PlotIndexSetDouble). I suoi parametri sono:
- plot_index: l'indice del tracciato grafico, specificheremo 0.
- prop_id: uno dei valori (ENUM_PLOT_PROPERTY_DOUBLE); sarà (PLOT_EMPTY_VALUE) per non disegnare nulla.
- prop_value: il valore della proprietà.
PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0);
Quindi restituire (INIT_SUCCEED) come parte della funzione OnInit() per terminarla, restituendo il successo dell'inizializzazione.
return(INIT_SUCCEEDED);
All'interno della funzione OnCalculate che viene richiamata nell'indicatore per l'elaborazione del cambio dei dati dei prezzi con il tipo di calcolo in base alla serie temporale del timeframe corrente.
int OnCalculate(const int rates_total, const int prev_calculated, const datetime &time[], const double &open[], const double &high[], const double &low[], const double &close[], const long &tick_volume[], const long &volume[], const int &spread[])
Creare una variabile intera "start", il cui valore verrà assegnato in seguito:
int start; Utilizzando l'istruzione 'if' per restituire i valori degli indici (minimo, massimo, apertura e chiusura) e il valore start=1 se prev_calculated è uguale a 0 o restituire il valore start assegnato a (prev_calculated-1):
if(prev_calculated==0) { haLow[0]=low[0]; haHigh[0]=high[0]; haOpen[0]=open[0]; haClose[0]=close[0]; start=1; } else start=prev_calculated-1;
Utilizzando la funzione 'for' per il ciclo principale del calcolo, l'operatore 'for' è composto da tre espressioni e operatori eseguibili.
Le tre espressioni saranno:
- i=start: per la posizione iniziale.
- i<rates_total && !IsStopped(): per le condizioni di conclusione del ciclo. IsStopped() verifica l'arresto forzato dell'indicatore.
- i++: aggiunge 1 al nuovo i.
Le operazioni che dobbiamo eseguire ogni volta durante il ciclo:
Calcolo per le quattro variabili double
- haOpenVal: per il valore di apertura dell'Heiken Ashi.
- haCloseVal: per il valore di chiusura dell'Heiken Ashi.
- haHighVal: per il valore massimo dell'Heiken Ashi.
- haLowVal: per il valore minimo dell'Heiken Ashi.
L'assegnazione dei valori calcolati nel passaggio precedente è uguale a quella che segue
- haLow[i]=haLowVal
- haHigh[i]=haHighVal
- haOpen[i]=haOpenVal
- haClose[i]=haCloseVal
Se il valore di apertura dell'Heiken Ashi è inferiore al valore di chiusura, l'indicatore deve disegnare una candela di colore blu, altrimenti deve disegnare una candela rossa.
for(int i=start; i<rates_total && !IsStopped(); i++) { double haOpenVal =(haOpen[i-1]+haClose[i-1])/2; double haCloseVal=(open[i]+high[i]+low[i]+close[i])/4; double haHighVal =MathMax(high[i],MathMax(haOpenVal,haCloseVal)); double haLowVal =MathMin(low[i],MathMin(haOpenVal,haCloseVal)); haLow[i]=haLowVal; haHigh[i]=haHighVal; haOpen[i]=haOpenVal; haClose[i]=haCloseVal; //--- set candle color if(haOpenVal<haCloseVal) haColor[i]=0.0; else haColor[i]=1.0; }
Terminare la funzione restituendo (rates_total) come prev_calculated per la chiamata successiva.
return(rates_total); Poi compiliamo il codice per assicurarci che non ci siano errori. Di seguito è riportato il codice completo in un unico blocco:
//+------------------------------------------------------------------+ //| simpleHeikenAshi.mq5 | //| Copyright 2023, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2023, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" #property indicator_separate_window #property indicator_buffers 5 #property indicator_plots 1 #property indicator_type1 DRAW_COLOR_CANDLES #property indicator_color1 clrBlue, clrRed #property indicator_width1 2 #property indicator_label1 "Heiken Ashi Open;Heiken Ashi High;Heiken Ashi Low;Heiken Ashi Close" double haOpen[]; double haHigh[]; double haLow[]; double haClose[]; double haColor[]; int OnInit() { SetIndexBuffer(0,haOpen,INDICATOR_DATA); SetIndexBuffer(1,haHigh,INDICATOR_DATA); SetIndexBuffer(2,haLow,INDICATOR_DATA); SetIndexBuffer(3,haClose,INDICATOR_DATA); SetIndexBuffer(4,haColor,INDICATOR_COLOR_INDEX); IndicatorSetInteger(INDICATOR_DIGITS,_Digits); IndicatorSetString(INDICATOR_SHORTNAME,"Simple Heiken Ashi"); PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0); return(INIT_SUCCEEDED); } int OnCalculate(const int rates_total, const int prev_calculated, const datetime &time[], const double &open[], const double &high[], const double &low[], const double &close[], const long &tick_volume[], const long &volume[], const int &spread[]) { int start; if(prev_calculated==0) { haLow[0]=low[0]; haHigh[0]=high[0]; haOpen[0]=open[0]; haClose[0]=close[0]; start=1; } else start=prev_calculated-1; for(int i=start; i<rates_total && !IsStopped(); i++) { double haOpenVal =(haOpen[i-1]+haClose[i-1])/2; double haCloseVal=(open[i]+high[i]+low[i]+close[i])/4; double haHighVal =MathMax(high[i],MathMax(haOpenVal,haCloseVal)); double haLowVal =MathMin(low[i],MathMin(haOpenVal,haCloseVal)); haLow[i]=haLowVal; haHigh[i]=haHighVal; haOpen[i]=haOpenVal; haClose[i]=haCloseVal; if(haOpenVal<haCloseVal) haColor[i]=0.0; else haColor[i]=1.0; } return(rates_total); }
Dopo la compilazione senza errori, l'indicatore dovrebbe essere disponibile nella cartella "Indicatori" della finestra Navigatore, come nella figura seguente.
Poi fate doppio clic per eseguirlo sul grafico desiderato, dopodiché apparirà la finestra comune delle informazioni sull'indicatore:
La scheda Colori mostra le impostazioni predefinite: colore blu per il movimento verso l'alto e colore rosso per quello verso il basso. Se necessario, è possibile modificare questi valori per impostare i colori preferiti. La scheda si presenta come segue:
Dopo aver premuto OK, l'indicatore sarà allegato al grafico e apparirà come nella figura seguente:
simpleHA allegatoalt
Come si può vedere nel grafico precedente, l'indicatore Simple Heiken Ashi è stato inserito nel grafico in una sottofinestra separata. Presenta candele blu e rosse in base alla direzione di queste candele (toro e orso). Ora abbiamo un indicatore personalizzato creato nella nostra MetaTrader 5 e che possiamo utilizzare in qualsiasi sistema di trading. Vedremo nei prossimi argomenti come è possibile farlo in modo semplice.
EA basato sull'Indicatore Heiken Ashi Personalizzato
In questa parte impareremo a utilizzare qualsiasi indicatore personalizzato nel nostro sistema di trading EA. Creeremo un semplice Sistema Heiken Ashi in grado di mostrarci i prezzi dell'indicatore (Apertura, Massimo, Minimo e Chiusura), poiché sappiamo già che differiscono dai prezzi reali secondo il calcolo dell'indicatore.
Il modo per farlo è scegliere di creare un nuovo Expert Advisor. Di seguito è riportato il codice completo:
//+------------------------------------------------------------------+ //| heikenAshiSystem.mq5 | //| Copyright 2023, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2023, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" int heikenAshi; int OnInit() { heikenAshi=iCustom(_Symbol,_Period,"My Files\\Heiken Ashi\\simpleHeikenAshi"); return(INIT_SUCCEEDED); } void OnDeinit(const int reason) { Print("Heiken Ashi System Removed"); } void OnTick() { double heikenAshiOpen[], heikenAshiHigh[], heikenAshiLow[], heikenAshiClose[]; CopyBuffer(heikenAshi,0,0,1,heikenAshiOpen); CopyBuffer(heikenAshi,1,0,1,heikenAshiHigh); CopyBuffer(heikenAshi,2,0,1,heikenAshiLow); CopyBuffer(heikenAshi,3,0,1,heikenAshiClose); Comment("heikenAshiOpen ",DoubleToString(heikenAshiOpen[0],_Digits), "\n heikenAshiHigh ",DoubleToString(heikenAshiHigh[0],_Digits), "\n heikenAshiLow ",DoubleToString(heikenAshiLow[0],_Digits), "\n heikenAshiClose ",DoubleToString(heikenAshiClose[0],_Digits)); }
Differenze in questo codice:
Il tipo di programma è un Expert Advisor. Pertanto, la costruzione di questo programma sarà diversa in quanto si compone di tre parti, che sono le seguenti:
- int OnInit(): viene utilizzata per inizializzare l'esecuzione dell'EA con il suo tipo consigliato che restituisce un valore intero.
- void OnDeinit: viene utilizzata per deinizializzare l'esecuzione dell'EA e non restituisce alcun valore.
- void OnTick(): viene utilizzata per gestire una nuova quotazione a ogni tick e non restituisce alcun valore.
Al di fuori dell'ambito delle funzioni precedenti e prima di esse abbiamo creato una variabile intera (heikenAshi)
int heikenAshi; Nell'ambito di OnInit(), abbiamo assegnato il valore della funzione iCustom alla variabile 'heikenAshi'. La funzione iCustom restituisce l'handle (gestore) dell'indicatore personalizzato, che in questo caso sarà il Simple Heiken Ashi, ma è possibile utilizzare qualsiasi indicatore personalizzato presente nella cartella Indicatori. I suoi parametri sono:
- symbol: il nome del simbolo, noi abbiamo usato (_Symbol) per il simbolo corrente.
- period: l'intervallo di tempo, abbiamo utilizzato (_Period) per il timeframe corrente.
- name: il nome dell'indicatore personalizzato con il suo percorso nella cartella Indicatori di MetaTrader 5. In questo caso abbiamo utilizzato "My Files\\Heiken Ashi\\simpleHeikenAshi".
Poi abbiamo terminato la funzione restituendo (INIT_SUCCEED) per l'avvenuta inizializzazione.
int OnInit() { heikenAshi=iCustom(_Symbol,_Period,"My Files\\Heiken Ashi\\simpleHeikenAshi"); return(INIT_SUCCEEDED); }
All'interno dell'ambito della funzione OnDeinit(), abbiamo utilizzato la funzione print per informare che l'EA è stato rimosso dagli expert.
void OnDeinit(const int reason) { Print("Heiken Ashi System Removed"); }
All'interno dell'ambito della funzione OnTick(), abbiamo utilizzato quanto segue per completare il nostro codice:
Creare quattro variabili di tipo double per i prezzi Heiken Ashi (Apertura, Massimo, Minimo e Chiusura).
double heikenAshiOpen[], heikenAshiHigh[], heikenAshiLow[], heikenAshiClose[]; Ottenere i dati dei buffer dell'indicatore personalizzato utilizzando la funzione CopyBuffer. I suoi parametri sono:
- indicator_handle: handle dell’indicatore, abbiamo utilizzato (heikenAshi).
- buffer_num: il numero di buffer dell'indicatore, abbiamo utilizzato (0 per l'apertura, 1 per il massimo, 2 per il minimo e 3 per la chiusura).
- start_pos: la posizione del primo elemento da copiare; abbiamo usato 0 per l'elemento corrente.
- count: la quantità di dati da copiare; noi abbiamo usato 1 e non abbiamo bisogno di altro.
- buffer[]: l'array da copiare, noi abbiamo utilizzato (heikenAshiOpen per l’apertura, heikenAshiHigh per il massimo, heikenAshiLow per il minimo e heikenAshiClose per la chiusura).
Ottenere un commento sul grafico con i prezzi Heiken Ashi correnti (Apertura, Massimo, Minimo e Chiusura) utilizzando la funzione Comment:
Comment("heikenAshiOpen ",DoubleToString(heikenAshiOpen[0],_Digits), "\n heikenAshiHigh ",DoubleToString(heikenAshiHigh[0],_Digits), "\n heikenAshiLow ",DoubleToString(heikenAshiLow[0],_Digits), "\n heikenAshiClose ",DoubleToString(heikenAshiClose[0],_Digits));
Dopo aver compilato questo codice senza errori e averlo eseguito, possiamo trovare l'EA allegato al grafico. Possiamo ricevere il segnale nello stesso modo del seguente esempio di test:
Come si può vedere nel grafico precedente, i prezzi dell'indicatore appaiono come commento nell'angolo superiore sinistro del grafico.
Heiken Ashi - Sistema EMA
In questo argomento, combineremo un altro strumento tecnico per vedere se il risultato sarà migliore oppure no. L'idea che dobbiamo applicare è quella di filtrare i segnali dell'indicatore personalizzato utilizzando la media mobile esponenziale con i prezzi. Ci sono molti metodi per farlo, possiamo creare un altro indicatore personalizzato per l'EMA, se vogliamo aggiungere altre caratteristiche all'EMA, per poi usarlo nell'EA come iCustom, come abbiamo fatto per prendere i segnali desiderati. Possiamo anche creare un indicatore smussato, smussando i valori dell'indicatore e prendendo poi i nostri segnali. Possiamo utilizzare la funzione iMA integrata nel nostro EA per ottenere i nostri segnali e utilizzeremo questo metodo per semplicità.
Ciò che dobbiamo fare è lasciare che l'EA controlli continuamente i valori attuali delle 2 EMA (Veloce e Lenta), delle precedenti EMA veloci e la chiusura Heiken Ashi per determinare le posizioni di ogni valore. Se heikenAshiClose precedente è maggiore di fastEMAarray precedente e fastEMA corrente è maggiore del valore slowEMA corrente, l'EA dovrebbe restituire un segnale di acquisto e questi valori come commento sul grafico. Se heikenAshiClose precedente è inferiore a fastEMAarray precedente e fastEMA attuale è inferiore al valore slowEMA attuale, l'EA dovrebbe restituire un segnale di vendita e questi valori come commento sul grafico.
Di seguito è riportato il codice completo per creare questo EA:
//+------------------------------------------------------------------+ //| heikenAsh-EMASystem.mq5 | //| Copyright 2023, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2023, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" input int fastEMASmoothing=9; // Fast EMA Period input int slowEMASmoothing=18; // Slow EMA Period int heikenAshi; double fastEMAarray[], slowEMAarray[]; int OnInit() { heikenAshi=iCustom(_Symbol,_Period,"My Files\\Heiken Ashi\\simpleHeikenAshi"); return(INIT_SUCCEEDED); } void OnDeinit(const int reason) { Print("Heiken Ashi-EMA System Removed"); } void OnTick() { double heikenAshiOpen[], heikenAshiHigh[], heikenAshiLow[], heikenAshiClose[]; CopyBuffer(heikenAshi,0,0,3,heikenAshiOpen); CopyBuffer(heikenAshi,1,0,3,heikenAshiHigh); CopyBuffer(heikenAshi,2,0,3,heikenAshiLow); CopyBuffer(heikenAshi,3,0,3,heikenAshiClose); int fastEMA = iMA(_Symbol,_Period,fastEMASmoothing,0,MODE_SMA,PRICE_CLOSE); int slowEMA = iMA(_Symbol,_Period,slowEMASmoothing,0,MODE_SMA,PRICE_CLOSE); ArraySetAsSeries(fastEMAarray,true); ArraySetAsSeries(slowEMAarray,true); CopyBuffer(fastEMA,0,0,3,fastEMAarray); CopyBuffer(slowEMA,0,0,3,slowEMAarray); if(heikenAshiClose[1]>fastEMAarray[1]) { if(fastEMAarray[0]>slowEMAarray[0]) { Comment("Buy Signal", "\nfastEMA ",DoubleToString(fastEMAarray[0],_Digits), "\nslowEMA ",DoubleToString(slowEMAarray[0],_Digits), "\nprevFastEMA ",DoubleToString(fastEMAarray[1],_Digits), "\nprevHeikenAshiClose ",DoubleToString(heikenAshiClose[0],_Digits)); } } if(heikenAshiClose[1]<fastEMAarray[1]) { if(fastEMAarray[0]<slowEMAarray[0]) { Comment("Sell Signal", "\nfastEMA ",DoubleToString(fastEMAarray[0],_Digits), "\nslowEMA ",DoubleToString(slowEMAarray[0],_Digits), "\nprevFastEMA ",DoubleToString(fastEMAarray[1],_Digits), "\nheikenAshiClose ",DoubleToString(heikenAshiClose[0],_Digits)); } } }
Le differenze in questo codice sono:
Creazione di input dell’utente per impostare il periodo EMA veloce e il periodo EMA lento in base alle preferenze.
input int fastEMASmoothing=9; // Fast EMA Period input int slowEMASmoothing=18; // Slow EMA Period
Creare due array per fastEMA e slowEMA.
double fastEMAarray[], slowEMAarray[]; Impostazione della quantità di dati da copiare pari a 3 nel CopyBuffer per ottenere i valori di chiusura precedenti dell'indicatore Heiken Ashi
CopyBuffer(heikenAshi,0,0,3,heikenAshiOpen); CopyBuffer(heikenAshi,1,0,3,heikenAshiHigh); CopyBuffer(heikenAshi,2,0,3,heikenAshiLow); CopyBuffer(heikenAshi,3,0,3,heikenAshiClose);
Definire l'EMA veloce e lenta utilizzando la funzione integrata iMA che restituisce l'handle dell'indicatore di media mobile. I suoi parametri sono:
- symbol: il nome del simbolo, abbiamo usato (_Symbol) per quello attuale.
- period: il tempo, abbiamo usato (_Period) per quella corrente.
- ma_period: il periodo in cui è necessario smussare la media; abbiamo utilizzato gli input (fastEMASmoothing e slowEMASmoothing).
- ma_shift: lo scostamento dell'indicatore, noi abbiamo usato 0.
- ma_method: il tipo di media mobile, noi abbiamo utilizzato MODE_SMA per la media mobile semplice.
- applied_price: il tipo di prezzo necessario da utilizzare nel calcolo, noi abbiamo utilizzato PRICE_CLOSE.
int fastEMA = iMA(_Symbol,_Period,fastEMASmoothing,0,MODE_SMA,PRICE_CLOSE); int slowEMA = iMA(_Symbol,_Period,slowEMASmoothing,0,MODE_SMA,PRICE_CLOSE);
Utilizzo della funzione ArraySetAsSeries per impostare il flag AS_SERIES. I suoi parametri sono:
- array[]: l'array utilizzato (fastEMAarray e slowEMA).
- flag: la direzione di indicizzazione dell'array, noi abbiamo usato true.
ArraySetAsSeries(fastEMAarray,true); ArraySetAsSeries(slowEMAarray,true);
Ottenere i dati del buffer dell'indicatore EMA utilizzando la funzione CopyBuffer.
CopyBuffer(fastEMA,0,0,3,fastEMAarray); CopyBuffer(slowEMA,0,0,3,slowEMAarray);
Condizioni per restituire segnali utilizzando l'istruzione 'if':
In caso di segnale di acquisto
Se heikenAshiClose precedente > di fastEMAarray precedente e fastEMAarray corrente > di slowEMAarray corrente, l'EA deve restituire un segnale di acquisto e i seguenti valori:
- fastEMA
- slowEMA
- prevFastEMA
- prevHeikenAshiClose
if(heikenAshiClose[1]>fastEMAarray[1]) { if(fastEMAarray[0]>slowEMAarray[0]) { Comment("Buy Signal", "\nfastEMA ",DoubleToString(fastEMAarray[0],_Digits), "\nslowEMA ",DoubleToString(slowEMAarray[0],_Digits), "\nprevFastEMA ",DoubleToString(fastEMAarray[1],_Digits), "\nprevHeikenAshiClose ",DoubleToString(heikenAshiClose[0],_Digits)); }
In caso di segnale di vendita
Se heikenAshiClose precedente < di fastEMAarray precedente e fastEMAarray corrente < di slowEMAarray corrente, l'EA deve restituire un segnale di vendita e valori del prezzo di:
- fastEMA
- slowEMA
- prevFastEMA
- prevHeikenAshiClose
if(heikenAshiClose[1]<fastEMAarray[1]) { if(fastEMAarray[0]<slowEMAarray[0]) { Comment("Sell Signal", "\nfastEMA ",DoubleToString(fastEMAarray[0],_Digits), "\nslowEMA ",DoubleToString(slowEMAarray[0],_Digits), "\nprevFastEMA ",DoubleToString(fastEMAarray[1],_Digits), "\nheikenAshiClose ",DoubleToString(heikenAshiClose[0],_Digits)); } }
Dopo aver compilato questo codice senza errori e averlo eseguito, possiamo ottenere i nostri segnali come mostrato nei seguenti esempi di test.
In caso di segnale di acquisto:
Come possiamo vedere nel grafico precedente, abbiamo il seguente segnale come commento nell'angolo in alto a sinistra:
- Segnale di Acquisto
- fastEMA
- prevFastEMA
- prevHeikenAshiClose
In caso di segnale di vendita:
Abbiamo i seguenti valori come segnale sul grafico:
- Segnale di Vendita
- fastEMA
- prevFastEMA
- prevHeikenAshiClose
Conclusioni
Se avete compreso tutto ciò che abbiamo discusso in questo articolo, si suppone che siate in grado di creare il vostro indicatore Heiken Ashi personalizzato o anche di aggiungere altre caratteristiche in base alle vostre preferenze. Ciò sarà molto utile per leggere i grafici e prendere decisioni efficaci in base alla propria comprensione. Inoltre, sarete in grado di utilizzare questo indicatore personalizzato nei vostri sistemi di trading come Expert Advisor, poiché lo abbiamo citato e utilizzato in due sistemi di trading come esempio.
- Sistema Heiken Ashi
- Sistema Heiken Ashi-EMA
Spero che questo articolo vi sia stato utile e che abbiate ottenuto buoni spunti sull'argomento o su qualsiasi altro argomento correlato. Spero anche che abbiate provato ad applicare quanto appreso nell'articolo, perché vi sarà molto utile nel vostro percorso di apprendimento della programmazione, dato che la pratica è un fattore molto importante nei processi educativi efficaci. Tenete presente che dovete testare tutto ciò che avete appreso in questo articolo o in altre risorse prima di utilizzarlo nel vostro conto reale, poiché potrebbe essere dannoso se non è adatto a voi. L'obiettivo principale di questo articolo è esclusivamente educativo, quindi bisogna fare attenzione.
Se questo articolo vi è stato utile e volete leggere altri articoli, potete leggerne altri attraverso gli altri articoli dell’autore. Spero che anche voi li troviate utili.
Tradotto dall’inglese da MetaQuotes Ltd.
Articolo originale: https://www.mql5.com/en/articles/12510
Algoritmi di ottimizzazione della popolazione: Ricerca dell'Armonia (Harmony Search HS)
MetaTrader 5 su macOS
Algoritmi di ottimizzazione della popolazione: Algoritmo della scimmia (MA)
Come individuare i trend e i pattern grafici utilizzando MQL5
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Accetti la politica del sito e le condizioni d’uso