Candele Engulfing, 1 indicatore con codice completo

Ciao! Candele Engulfing. Entiendes? Ciai presente?

Le Candele Engulfing sono un pattern di candele giapponesi che (si mormora) dovrebbero indicare un’inversione di trend.

Non lo so, ci scrissi qualche EA per capire quanto fossero affidabili e le equity line erano abbastanza tristi.

Ma non è importante, ai fini di questo articolo.

No, non ti voglio ingannare, ma sfrutteremo in questo articolo, con la scusa delle Candele Engulfing, per imparare a scrivere un indicatore per la Meta Trader 5!

Già! Una volta arrivato alla fine, sarai in grado di utilizzare questo schema per ottenere un indicatore che, al verificarsi di alcune condizioni, metterà freccine e simboli nelle candele interessate!

Eccoti un’anteprima:


candele engulfing indicatore meta trader 5 automazione trading

Bene, se sei pronto a studiare gli indicatori di tipo DRAW_ARROW e le candele engulfing, eccoti l’indice dell’articolo:

Bene! Procediamo alla stesura di questo fantastico indicatore!

Candele Engulfing, definizione

Prima di buttarci nel codice, è bene definire per filo e per segno quali sono le condizioni OGGETTIVE che definiscono una candela engulfing.

Questo simpatico disegnino rende GRAFICAMENTE l’idea, ma il codice non legge le immagini, solo dei numerilli. Come possiamo trasformare questa immagine in condizioni oggettive, programmabili e intellegibili dal nostro caro Indi?

Per semplificare, possiamo dire che l’engulfing è una candela che “abbraccia” completamente ed interamente la candela precedente. Guarda l’immagine:



Orbene, come avrai capito le candele engulfing hanno il corpo candela maggiore della candela precedente, e secondo me dovrebbero avere anche high e low che superano gli high e i low della candela precedente.

Quali condizioni identificano le candele engulfing?

Partiamo dalla “bullish”: quella candela che dovrebbe presagire un movimento a rialzo. Quali condizioni possiamo definire?

  • low minore del low precedente
  • high maggiore dell’high precedente
  • corpo candela maggiore del corpo candela precedente
  • deve essere una candela rialzista successiva ad una candela ribassista

E, parimenti, per la nostra candela engulfing di tipo “bearish”, possiamo identificare queste condizioni:

  • low minore del low precedente
  • high maggiore dell’high precedente
  • corpo candela maggiore del corpo candela precedente
  • deve essere una candela ribassista successiva ad una candela rialzista

Scriviamo l’indicatore per le candele engulfing

Se non hai mai creato un indicatore sul Meta Editor, trovi la mia procedura guidata a questo link.

Una volta ultimata, cominciamo a lavorare il codice.
Io voglio che ogni volta che si presenti una engulfing candle, si disegni sopra o sotto la candela una stellina, per identificare che quella candela è una engulfing.

Così facendo, addirittura, potrò fare un backtest intelligente, perché visivamente vedrò l’efficacia o meno dei segnali generati.

In un indicatore, i dati che servono per tracciare le linee dinamicamente nella serie storica si chiamano Buffers, questi sono degli Array di valori che si aggiornano su tutta la serie storica, significa che ad ogni candela, il Buffer, per sapere dove tracciare linee, punti, stelline, prenderà il valore corrispondente dal suo bell’Array.

In questo caso, identifichiamo 2 buffer diversi: uno per le stelline long e uno per le stelline short. Anche i plot (Le parti grafiche) saranno 2. Dichiariamoli prima dell’OnInit()

//+------------------------------------------------------------------+
//|                                                EngulfingSpot.mq5 |
//|                                                 D'ario Woollover |
//|                               https://www.automazionetrading.com |
//+------------------------------------------------------------------+
#property copyright "D'ario Woollover"
#property link      "https://www.automazionetrading.com"
#property version   "1.00"
#property indicator_chart_window

#property indicator_buffers 2
#property indicator_plots 2

Dichiariamo successivamente anche gli input: il codice carattere della stellina (così lo potremo cambiare secondo QUESTA TABELLA, in qualsiasi carattere WingDing), i colori long e short e la distanza in PIXEL dalla candela. Procediamo:

input string s0="===== >Indicator Settings< ====="; //==============================
input ushort arrow=171; //Char Number for Arrows
input color CLR_Long=clrSteelBlue; //Long Engulfing Color
input color CLR_Short=clrCrimson; //Short Engulfing Color
input int distance=30; //distance in pixel from the High / Low of the candle

E infine dichiariamo i due buffer. Questi buffer conterranno dei livelli di prezzo, per cui andranno dichiarati come array di tipo double

double BUF_LongEng[],BUF_ShortEng[];

Ora dobbiamo dire al compilatore come deve comportarsi con i buffer, gli array e i plots, cioè dovremo spiegare alla Meta Trader da quale array prendere i dati, a cosa corrisponde il nostro buffer, e come si comporta graficamente il suo plot.

Queste dichiarazioni sono statiche, nel senso che non cambieranno con il variare dei prezzi, per cui possiamo inserire questa serie di info nella funzione globale OnInit().

Se non te lo ricordassi, la OnInit è una funzione che viene eseguita esclusivamente una volta, al primo avvio dell’indicatore sul grafico.

Prendiamo la nostra funzione OnInit() e dichiariamo gli stili dell’indicatore:

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
   SetIndexBuffer(0, BUF_LongEng, INDICATOR_DATA);
   PlotIndexSetString(0,PLOT_LABEL,"Long Engulfing");
   PlotIndexSetInteger(0,PLOT_DRAW_TYPE,DRAW_ARROW);
   PlotIndexSetInteger(0,PLOT_ARROW_SHIFT,distance);
   PlotIndexSetInteger(0,PLOT_ARROW,arrow);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,CLR_Long);
   PlotIndexSetInteger(0,PLOT_LINE_WIDTH,3);
   
   SetIndexBuffer(1, BUF_ShortEng, INDICATOR_DATA);
   PlotIndexSetString(1,PLOT_LABEL,"Short Engulfing");
   PlotIndexSetInteger(1,PLOT_DRAW_TYPE,DRAW_ARROW);
   PlotIndexSetInteger(1,PLOT_ARROW_SHIFT,-distance);
   PlotIndexSetInteger(1,PLOT_ARROW,arrow);
   PlotIndexSetInteger(1,PLOT_LINE_COLOR,CLR_Short);
   PlotIndexSetInteger(1,PLOT_LINE_WIDTH,3);
//---
   return(INIT_SUCCEEDED);
  }

La funzione SetIndexBuffer associa il buffer all’array. I buffer sono conteggiati da zero a salire, per cui in questo caso il nostro buffer 0 sarà quello delle engulfing LONG, il buffer 1 quello delle engulfing SHORT.

Per le parti grafiche, in MQL 5 dovremo usare un PlotIndexSet per ciascun valore che vogliamo modificare, come colore, dimensione, tipo, ecc ecc.

Partiamo con il NOME di ciascun plot, che verrà scritto nella “tabella dati” una volta montato su grafico. Siccome è un nome, useremo una variabile di tipo STRINGA.

PlotIndexSetString è la funzione che ci serve, poiché associa al buffer numero 0 il nome di “Long Engulfing”.

Successivamente, stabiliamo che il tipo di plot sarà un tipo “ARROW”, gli diamo la distanza della “arrow”, il numero del carattere da utilizzare, il colore e la dimensione.

Fico!

Il processo viene ripetuto anche per le stelline short, e siamo a posto. 🙂

Inseriamo i calcoli per identificare le candele engulfing

Orbene, ecco che ora andiamo ad utilizzare gli array che vengono automaticamente riempiti dalla MT5, durante il ciclo “OnCalculate”. L’OnCalculate funziona ad ogni tick, DOPO aver ciclato tutto lo storico. Ad ogni barra chiusa, si completa un ciclo dell’OnCalculate, che si salva una serie di valori della serie storica oltre a due contatori: il rates_total e il prev_calculated.

Rates_total indica il numero totale di barre presente a grafico (o nella serie storica), mentre il prev_calculated conta quante barre sono state processate fino ad ora. Ad ogni ciclo, il codice si salva i valori di datetime (l’orario di apertura della candela), i valori OHLC, il volume tick, il volume globale e lo spread in quel momento.

Sì, hai capito bene, puoi vedere lo spread ESATTAMENTE come se fossi davvero a mercato (quasi… in realtà è lo spread al momento della chiusura della candela). Questo è molto importante a livello di accuratezza dei backtest, che però non coprirò in questo articolo.

A questo punto, potremmo scrivere una funzione che individui le engulfing bullish e bearish, ma avendo tutti i dati puri che ci servono, generati dal ciclo OnCalculate, scriveremo le condizioni di presenza della stellina direttamente nel ciclo. Poco elegante ma molto economico.

E come facciamo a far comparire la stellina?

Molto semplice! Se il nostro plot è di tipo DRAW_ARROW, semplicemente dovremo dare valore nullo in tutti i momenti in cui NON sussistono le condizioni per far apparire la stellina.

Al contrario, quando si verificano le condizioni per cui vogliamo la stellina, dobbiamo assegnare un valore all’array pari al valore di prezzo dove vorremo far apparire la stellina. Ecco le condizioni codificate per la candela engulfing BULLISH:

 if(high[bar]>=high[bar-1] && low[bar]<=low[bar-1] &&                     
         open[bar]<close[bar] && open[bar-1]>close[bar-1] &&                                           
        close[bar]-open[bar]> open[bar-1]-close[bar-1] )                                     
        {
         BUF_LongEng[bar]=low[bar];
        }

L’indice [bar] è il numero progressivo della barra in cui si fanno i calcoli, considera che in MQL5 la prima barra dello storico ha indice 0 mentre l’ultima ha come indice il numero totale di barre.

Per chi proviene dalla MQL4 è completamente contro-intuitivo, eppure è decisamente più efficiente, poiché in questo modo le barre hanno un indice univoco, anziché variare nel tempo.

Va da sé che l’indice [bar-1] si riferisce quindi alla candela precedente.

Ma che cos’è questo “bar”?

BAR è un numero progressivo che andremo ad aumentare di una unità ogni volta che il ciclo OnCalculate si chiude, e lo ripetiamo ogni nuova barra. Ecco tutta la funzione OnCalculate, per la gioia dei tuoi occhi:

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
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=1;
   if(prev_calculated>0)
      start=prev_calculated-1;
//--- Calculation loop
   for(int bar=1; bar<rates_total; bar++)
     {
      BUF_ShortEng[bar]=EMPTY_VALUE;
      BUF_LongEng[bar]=EMPTY_VALUE;
      
      if(high[bar]>=high[bar-1] && low[bar]<=low[bar-1] &&
         open[bar]<close[bar] && open[bar-1]>close[bar-1] &&  
        close[bar]-open[bar]> open[bar-1]-close[bar-1] )                     
        {
         BUF_LongEng[bar]=low[bar];
        }

      if(high[bar]>=high[bar-1] && low[bar]<=low[bar-1] && 
         open[bar]>close[bar] && open[bar-1]<close[bar-1] &&     
        open[bar]-close[bar]> close[bar-1] - open[bar-1])                                    
        {
         BUF_ShortEng[bar]=high[bar];
        }

     }
//--- return value of prev_calculated for next call
   return(rates_total);
  }

Ed ecco che, aggiungendo questo codice nell’OnCalculate, potremo avere tutta la logica di isolamento delle Candele Engulfing, e di conseguenza l’indicatore disegnerà il carattere scelto (nel mio caso una stellina rossa per le bearish engulfing e azzurra per le bullish engulfing) a 30 pixel di distanza dal minimo o dal massimo della candela prescelta.

Hai tutto il codice! Vai e spacca!

Candele Engulfing: proseguire lo studio

Le Candele Engulfing di per sé non sono sta gran trovata… è un modo arbitrario per decidere qualche ingresso, ma non è detto che siano profittevoli.

Sta a te trovare delle modalità, dei filtri , delle CONTESTUALIZZAZIONI in cui possano rivelarsi un buon segnale di ingresso.

Potresti provare a disegnare le stelline SOLO se si presenta ANCHE un’altra condizione, come un valore specifico dell’RSI, la posizione della candela rispetto una media mobile e molti altri. Gioca, sperimenta, studia!

L’obiettivo di questo articolo è quello di renderti autonomo a disegnare indicatori che possano aiutarti nell’individuare delle candele segnale, e fare in modo che tu possa backtestare in modo più rapido un’idea di trading. Siamo pure sotto le 100 righe di codice per le Candele Engulfing!

Prova a pensare cosa dovresti cambiare del codice se volessi identificare la terza candela ribassista consecutiva… è un bell’esercizio e magari anche più utile delle Candele Engulfing :D!

Spero che questo articolo ti abbia aiutato nella creazione di un semplice custom indicator, che tu possa usarlo come base per altri tuoi studi, che sarò felice di leggere nei commenti o sui miei canali social!

Happy trading!

SPAZIO PUBBLICITARIO:
XM è un broker che mi sta piacendo molto,
ha una bella politica di rebates e bonus di benvenuto molto importanti.

A me piace la rapidità di versamento e di prelievo con Carta di Credito, che non fa problemi nemmeno con la Revolut (15€ gratis se ti iscrivi da qui)

Leave a Reply