Impara come progettare un sistema di trading tramite Fibonacci
567
0
Introduzione
In questo nuovo articolo della nostra serie su come progettare un sistema di trading basato sui più popolari strumenti e indicatori di analisi tecnica, impareremo a creare un sistema di trading basato sullo strumento tecnico del Ritracciamento di Fibonacci, uno dei più popolari e ampiamente utilizzati nel trading. Dopodiché, potremo utilizzare questo sistema di trading sul nostro terminale MetaTrader 5. Utilizzeremo il linguaggio MQL5 (MetaQuotes Language 5) che è l'IDE integrato con MetaTrader 5. Se volete sapere come scaricare e utilizzare MetaTrader 5 e l'IDE MQL5, potete leggere questo argomento Scrivere codice MQL5 in MetaEditor da un articolo precedente.
Per coprire tutto ciò, gli argomenti saranno i seguenti:
- Definizione di Fibonacci
- Strategia di Fibonacci
- Schema della strategia di Fibonacci
- Sistema di trading Fibonacci
- Conclusioni
È bene ricordare che sarà meglio utilizzare questo Fibonacci accompagnato da altri strumenti tecnici come l'analisi del trend, supporti, resistenze, ecc. in quanto fornirà approfondimenti e risultati migliori. È inoltre necessario testare qualsiasi strategia o strumento appreso da questo articolo o da qualsiasi altra parte prima di utilizzarlo nel mondo reale, per assicurarsi che sia utile e profittevole per il proprio trading. In qualità di sviluppatori di competenze di programmazione, sarà meglio che applichiate e proviate a codificare da soli ciò che avete letto, poiché questo passo vi è molto utile.
Definizione di Fibonacci
In questa sezione identificheremo lo strumento del Ritracciamento di Fibonacci e impareremo come utilizzarlo sul nostro grafico. Il Fibo è uno strumento tecnico che può essere utilizzato per trovare aree di supporto o resistenza sul grafico e ci si aspetta un rimbalzo su queste aree. Si basa sulla sequenza di Fibonacci, che è una serie matematica di numeri. Ogni numero di questa serie è la somma dei due numeri precedenti. Possiamo trovarla sul grafico disegnata come linee orizzontali a livelli specifici come 23,6%, 38,2%, 50% e 61,8% e questi livelli sono i più popolari.
Se vi state chiedendo come potete trovarlo sul grafico, la risposta sarà che tutto ciò che dovete fare è inserirlo dagli strumenti tecnici disponibili nella MetaTrader 5 e di seguito vi illustrerò i passi da seguire:
All'apertura di MetaTrader 5, navigare nella scheda Inserisci --> Oggetti --> Ritracciamento di Fibonacci
In seguito, se abbiamo un ritracciamento dopo il trend rialzista lo disegniamo dal basso verso l'alto e viceversa, se abbiamo un ritracciamento dopo il trend ribassista lo disegniamo dall'alto verso il basso, come negli esempi seguenti.
FIBO dopo trend rialzista:
FIBO dopo trend ribassista:
Come possiamo vedere negli esempi precedenti, abbiamo una trendline tracciata tra due punti, i valori più alti e quelli più bassi, oltre a linee orizzontali con livelli specifici 23,6, 38,2, 50 e 61,8. Questi livelli sono i più popolari. Intorno a questi livelli e dopo un trend rialzista o ribassista, si verificano correzioni o ritracciamenti e ci si può aspettare un rimbalzo da questi livelli dopo la correzione. Pertanto, i livelli di FIBO possono fungere da livelli di supporto o resistenza.
È possibile controllare questi livelli anche attraverso la finestra di questo strumento, facendo clic con il tasto destro del mouse sullo strumento tracciato o sul grafico e selezionando Elenco oggetti dal menu, quindi selezionando l'oggetto Fibo e la finestra si aprirà come di seguito:
Dalla scheda comune precedente è possibile controllare il nome dell'oggetto e il suo stile, come il colore, i tipi di linea e lo spessore.
Come si può vedere nell'immagine precedente, è possibile controllare e determinare le impostazioni dei livelli desiderati e anche lo stile.
Come si può vedere, nella scheda Parametri è possibile determinare la data, l'ora e il valore da cui partire, oltre alla data, all'ora e al valore con cui terminare l'oggetto Fibonacci.
Strategia di Fibonacci
In questa parte impareremo a utilizzare il ritracciamento di Fibonacci attraverso semplici strategie basate su due approcci diversi. Uno di questi è quello di determinare i livelli FIBO in base all'ultima candela giornaliera e il secondo è quello di determinare il numero di candele in qualsiasi time frame e determinare i livelli FIBO in base ad esse. Quindi utilizzeremo un'altra strategia per ottenere uno specifico segnale di acquisto o di vendita basato su un livello FIBO predeterminato per ogni approccio. Di seguito sono riportati maggiori dettagli su queste strategie.
Il primo approccio - Utilizzo dei Dati Giornalieri:
Sistema FIBO Semplice
In base a questa strategia dobbiamo ottenere i livelli di prezzo del ritracciamento FIBO in base ai dati e allo stato della candela giornaliera. Se l'ultima candela giornaliera è rialzista, dobbiamo ottenere un FIBO rialzista dal minimo al massimo della candela e i livelli di prezzo di ogni livello. Se l'ultima candela giornaliera è ribassista, dobbiamo ottenere un FIBO rosso ribassista dal massimo al minimo di questa candela e i livelli di prezzo di questo FIBO.
Semplicemente,
Chiusura dell'ultimo giorno > apertura ==> candela rialzista
Ottenere i livelli di FIBO in verde e i prezzi di questi livelli.
Chiusura dell'ultimo giorno < apertura ==> candela ribassista
Ottenere un livello di FIBO in rosso e i prezzi di questi livelli.
Segnali FIBO:
In base a questa strategia, dobbiamo ottenere entrate per acquisto e vendita in base a ciò che determiniamo come livello di FIBO rialzista o ribassista. Se abbiamo determinato un livello di 38,2 di un FIBO rialzista, dobbiamo ottenere il prezzo di questo livello come ingresso in acquisto e se determiniamo lo stesso livello come FIBO ribassista, dobbiamo ottenere il prezzo di questo livello come ingresso in vendita.
Il secondo approccio - Utilizzo di un array di candele specifiche:
Sistema FIBO Semplice 2
In base a questa strategia dobbiamo ottenere i livelli di prezzo FIBO basati su un array di candele, se abbiamo un FIBO rialzista, in base alla direzione dell'array dobbiamo ottenere i livelli di prezzo FIBO, e se abbiamo un FIBO ribassista in base alla direzione dell'array dobbiamo ottenere i suoi livelli di prezzo FIBO.
Semplicemente,
Se l'apertura della prima candela dell'array < della chiusura dell'ultima candela dello stesso array ==> FIBO rialzista, dobbiamo ottenere i livelli di prezzo di questo FIBO rialzista.
Se l'apertura della prima candela dell'array > della chiusura dell'ultima candela dello stesso array ==> FIBO ribassista, dobbiamo ottenere i livelli di prezzo di questo FIBO ribassista.
Segnali FIBO 2:
Sulla base di questa strategia, dobbiamo ottenere gli ingressi in acquisto o in vendita in base all'input dell'utente del livello FIBO desiderato indicante il livello d’ingresso. Se abbiamo un FIBO rialzista basato su quanto descritto in precedenza in base a questo approccio, dobbiamo ottenere un livello di ingresso in acquisto di un livello FIBO specifico. Se abbiamo un FIBO ribassista, dobbiamo ottenere un livello di entrata in vendita di un livello FIBO specifico.
Schema della strategia di Fibonacci
In questa parte, vedremo gli schemi di ogni strategia dei due approcci citati per capire cosa dobbiamo fare con un metodo visivo.
Il Primo approccio - Utilizzo dei Dati Giornalieri:
Come abbiamo già detto, utilizzeremo l'ultima candela giornaliera e ne determineremo l'apertura, la chiusura, il massimo e il minimo. Confrontando l'apertura e la chiusura possiamo individuare se si tratta di una candela rialzista o ribassista. In base al tipo di movimento di quest'ultima candela giornaliera, tracceremo l'oggetto Fibonacci e otterremo i segnali desiderati.
Sistema FIBO Semplice
Segnali FIBO:
Il secondo approccio - Utilizzo di array di candele specifiche:
Come abbiamo detto, utilizzeremo un numero specifico di candele in un array e determineremo il valore di apertura della prima candela, il valore di chiusura dell'ultima candela, il valore più alto e il valore più basso. Confrontando l'apertura e la chiusura possiamo individuare se si tratta di una candela rialzista o ribassista. In base al tipo di movimento di questo array, disegneremo l'oggetto Fibonacci e otterremo i segnali desiderati.
Sistema FIBO Semplice 2
Segnali FIBO 2:
Sistema di trading Fibonacci
In questa parte, impareremo come creare un sistema di trading basato su quanto detto in precedenza. Creeremo un programma in grado di restituire i livelli di Fibonacci sul grafico come commento. Utilizzeremo due approcci: il primo consiste nell'utilizzare gli ultimi dati giornalieri per tracciare i nostri livelli di Fibonacci e l'altro approccio consiste nell'utilizzare un numero predeterminato di candele per utilizzarle come array. Impareremo anche a utilizzare questi due approcci in modo che restituiscano i segnali di acquisto e di vendita basati su Fibonacci, vediamoli nel dettaglio.
Il primo approccio - Utilizzo dei Dati Giornalieri:
Sistema FIBO Semplice:
In base a questa strategia, utilizzeremo i dati giornalieri per il sistema Fibonacci e i seguenti sono i passaggi per farlo:
Definire il nome dell'oggetto necessario utilizzando la sostituzione Macro (#define) per preprocessare il codice sorgente prima della compilazione.
#define FIB_OBJ "Fibonacci Retracement"
Creare una variabile integer per barsTotal.
int barsTotal; Successivamente, nell'OnTick, creeremo una variabile integer per le barre con l'assegnazione della funzione iBar che restituisce il numero di barre storiche disponibili del simbolo. I suoi parametri sono:
- symbol: per determinare il simbolo desiderato, useremo _Symbol per quello attuale.
- timeframe: per determinare il periodo, utilizzeremo D1 per il grafico giornaliero.
int bars = iBars(_Symbol, PERIOD_D1);
Emettendo una condizione per individuare la candela giornaliera che dobbiamo utilizzare per il nostro Fibonacci, abbiamo bisogno che barsTotal non sia uguale a bars utilizzando l'operatore (!=) e allo stesso tempo abbiamo bisogno che l'ora corrente sia maggiore dell'ora finale di questa candela giornaliera. Quindi, utilizzeremo la funzione TimeCurrent e la funzione StringToTime per trasformare una stringa contenente il tempo in un numero di tipo datetime.
if(barsTotal != bars && TimeCurrent() > StringToTime("00:05"))
Una volta che questa condizione è vera, il programma deve eseguire le seguenti operazioni:
Assegnare le barre a barsTotal.
barsTotal=bars;
Eliminare qualsiasi FIB_OBJ sul grafico utilizzando la funzione ObjectDelete, i cui parametri sono:
- chart_id: per determinare l'identificativo del grafico, useremo (0) che significa il grafico corrente.
- name: per determinare il nome dell'oggetto che è (FIB_OBJ).
ObjectDelete(0,FIB_OBJ);
Creare quattro variabili di prezzo (open, close, high e low) utilizzando le funzioni iOpen, iClose, iHigh e iLow che restituiscono il prezzo della barra giornaliera. i loro parametri sono:
- symbol: per determinare il simbolo desiderato, si utilizzerà _Symbol per il simbolo corrente.
- timeframe: per determinare il time frame desiderato, utilizzeremo (PERIOD_D1) per il time frame giornaliero.
- shift: per determinare l'indice del valore ricevuto dalla serie temporale, non lo utilizzeremo qui.
double open = iOpen(_Symbol,PERIOD_D1,1); double close = iClose(_Symbol,PERIOD_D1,1); double high = iHigh(_Symbol,PERIOD_D1,1); double low = iLow(_Symbol,PERIOD_D1,1);
Determinare l'ora iniziale e l'ora finale da utilizzare successivamente per tracciare il nostro oggetto Fibonacci. Utilizzeremo la funzione iTime che restituisce l'ora di apertura della barra. I suoi parametri sono:
- symbol: per determinare il simbolo desiderato, si utilizzerà _Symbol per il simbolo corrente.
- timeframe: per determinare il time frame desiderato, utilizzeremo (PERIOD_D1) per il time frame giornaliero.
- shift: per determinare l'indice del valore ricevuto dalla serie temporale, useremo 1 per l'ora iniziale e 0 per l'ora finale.
Per l'ora di fine, sottrarremo 1 dal valore di ritorno poiché sarà durante il nuovo giorno che sarà la barra giornaliera corrente al momento di questo calcolo, quindi, lo faremo per rilevare il valore della barra precedente.
datetime startingTime = iTime(_Symbol,PERIOD_D1,1); datetime endingTime = iTime(_Symbol,PERIOD_D1,0)-1;
Dopodiché, si imposteranno due condizioni utilizzando l'operatore condizionale if-else per disegnare l'oggetto Fibonacci:
Se la chiusura è superiore all'apertura, si tratta di una candela rialzista e si verificherà quanto segue.
Creare l'oggetto utilizzando la funzione ObjectCreate per disegnare l'oggetto con i caratteri specificati. I suoi parametri sono:
- chart_id: per determinare il grafico, useremo 0 per quello corrente.
- name: per determinare il nome dell'oggetto desiderato, si utilizzerà FIB_OBJ.
- type: per determinare il tipo di oggetto, utilizzeremo OBJ_FIBO per il ritracciamento di Fibonacci.
- nwin: per determinare l'indice della finestra, utilizzeremo 0 per la finestra principale
- time1: per determinare l'ora del primo punto, utilizzeremo l'ora di partenza.
- price1: per determinare il prezzo del primo punto, utilizzeremo il valore minimo (low).
- timeN=0: per determinare l'ora dell'ultimo punto, utilizzeremo l'ora finale.
- priceN=0: per determinare il prezzo dell'ultimo punto, utilizzeremo il massimo (high).
Aggiornamento del colore dell'oggetto per adattarlo alla direzione della barra, utilizzando ObjectSetInteger e l'operatore per i cicli for. I parametri di ObjectSetInteger sono:
- chart_id: per determinare il grafico, useremo 0 per quello corrente.
- name: per determinare il nome dell'oggetto, si utilizzerà FIB_OBJ.
- prop_id: per determinare l'id della proprietà (colore), utilizzeremo OBJPROP_COLOR.
- prop_value: per determinare il valore della proprietà, utilizzeremo clrGreen.
- Utilizzo del ciclo for per aggiornare continuamente il colore dell'oggetto.
if(close>open) { ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,low,endingTime,high); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen); } double fibRetracLvl1 = NormalizeDouble(high - (high-low) * 23.6 / 100,_Digits); double fibRetracLvl2 = NormalizeDouble(high - (high-low) * 38.2 / 100,_Digits); double fibRetracLvl3 = NormalizeDouble(high - (high-low) * 50 / 100,_Digits); double fibRetracLvl4 = NormalizeDouble(high - (high-low) * 61.8 / 100,_Digits); double fibRetracLvl5 = NormalizeDouble(high - (high-low) * 100 / 100,_Digits); Comment("Last Day Open = ",open,"\n", "Last Day Close = ",close,"\n", "Fib lvl 0% = ",high,"\n", "Fib lvl 23.6% = ",fibRetracLvl1,"\n", "Fib lvl 38.2% = ",fibRetracLvl2,"\n", "Fib lvl 50% = ",fibRetracLvl3,"\n", "Fib lvl 61.8% = ",fibRetracLvl4,"\n", "Fib lvl 100% = ",fibRetracLvl5); }
Nel caso di una giornata ribassista si verificherà lo stesso, ma la differenza sarà la seguente:
- Creare l'oggetto e partire dall'alto verso il basso.
- Il colore dell'oggetto sarà rosso.
else { ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,high,endingTime,low); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed); } double fibRetracLvl1 = NormalizeDouble(low + (high-low) * 23.6 / 100,_Digits); double fibRetracLvl2 = NormalizeDouble(low + (high-low) * 38.2 / 100,_Digits); double fibRetracLvl3 = NormalizeDouble(low + (high-low) * 50 / 100,_Digits); double fibRetracLvl4 = NormalizeDouble(low + (high-low) * 61.8 / 100,_Digits); double fibRetracLvl5 = NormalizeDouble(low + (high-low) * 100 / 100,_Digits); Comment("Last Day Open = ",open,"\n", "Last Day Close = ",close,"\n", "Fib lvl 0% = ",low,"\n", "Fib lvl 23.6% = ",fibRetracLvl1,"\n", "Fib lvl 38.2% = ",fibRetracLvl2,"\n", "Fib lvl 50% = ",fibRetracLvl3,"\n", "Fib lvl 61.8% = ",fibRetracLvl4,"\n", "Fib lvl 100% = ",fibRetracLvl5); }
Quello che segue è il codice completo di questa strategia:
//+------------------------------------------------------------------+ //| Simple Fibo System#2.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" #define FIB_OBJ "Fibonacci Retracement" #property script_show_inputs input double fibRetracLvl = 38.2; int barsTotal; //+------------------------------------------------------------------+ void OnTick() { int bars = iBars(_Symbol, PERIOD_D1); if(barsTotal != bars && TimeCurrent() > StringToTime("00:05")) { barsTotal=bars; ObjectDelete(0,FIB_OBJ); double open = iOpen(_Symbol,PERIOD_D1,1); double close = iClose(_Symbol,PERIOD_D1,1); double closeCandle = iClose(_Symbol,_Period,1); double high = iHigh(_Symbol,PERIOD_D1,1); double low = iLow(_Symbol,PERIOD_D1,1); datetime startingTime = iTime(_Symbol,PERIOD_D1,1); datetime endingTime = iTime(_Symbol,PERIOD_D1,0)-1; if(close>open) { ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,low,endingTime,high); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen); } double fibRetracLvl1 = NormalizeDouble(high - (high-low) * 23.6 / 100,_Digits); double fibRetracLvl2 = NormalizeDouble(high - (high-low) * 38.2 / 100,_Digits); double fibRetracLvl3 = NormalizeDouble(high - (high-low) * 50 / 100,_Digits); double fibRetracLvl4 = NormalizeDouble(high - (high-low) * 61.8 / 100,_Digits); double fibRetracLvl5 = NormalizeDouble(high - (high-low) * 100 / 100,_Digits); double entryLvl = NormalizeDouble(high - (high-low) * fibRetracLvl /100,_Digits); Comment("Last Day Open = ",open,"\n", "Last Day Close = ",close,"\n", "Buy Entry Price: ",entryLvl,"\n", "Close: ",closeCandle,"\n"); } else { ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,high,endingTime,low); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed); } double fibRetracLvl1 = NormalizeDouble(low + (high-low) * 23.6 / 100,_Digits); double fibRetracLvl2 = NormalizeDouble(low + (high-low) * 38.2 / 100,_Digits); double fibRetracLvl3 = NormalizeDouble(low + (high-low) * 50 / 100,_Digits); double fibRetracLvl4 = NormalizeDouble(low + (high-low) * 61.8 / 100,_Digits); double fibRetracLvl5 = NormalizeDouble(low + (high-low) * 100 / 100,_Digits); double entryLvl = NormalizeDouble(low + (high-low) * fibRetracLvl /100,_Digits); { Comment("Last Day Open = ",open,"\n", "Last Day Close = ",close,"\n", "Sell Entry Price: ",entryLvl,"\n", "Close: ",closeCandle); } } } } //+------------------------------------------------------------------+
Di seguito è riportato il codice completo di questo sistema di trading:
//+------------------------------------------------------------------+ //| Simple Fibo System#1.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" #define FIB_OBJ "Fibonacci Retracement" int barsTotal; //+------------------------------------------------------------------+ void OnTick() { int bars = iBars(_Symbol, PERIOD_D1); if(barsTotal != bars && TimeCurrent() > StringToTime("00:05")) { barsTotal=bars; ObjectDelete(0,FIB_OBJ); double open = iOpen(_Symbol,PERIOD_D1,1); double close = iClose(_Symbol,PERIOD_D1,1); double high = iHigh(_Symbol,PERIOD_D1,1); double low = iLow(_Symbol,PERIOD_D1,1); datetime startingTime = iTime(_Symbol,PERIOD_D1,1); datetime endingTime = iTime(_Symbol,PERIOD_D1,0)-1; if(close>open) { ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,low,endingTime,high); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen); } double fibRetracLvl1 = NormalizeDouble(high - (high-low) * 23.6 / 100,_Digits); double fibRetracLvl2 = NormalizeDouble(high - (high-low) * 38.2 / 100,_Digits); double fibRetracLvl3 = NormalizeDouble(high - (high-low) * 50 / 100,_Digits); double fibRetracLvl4 = NormalizeDouble(high - (high-low) * 61.8 / 100,_Digits); double fibRetracLvl5 = NormalizeDouble(high - (high-low) * 100 / 100,_Digits); Comment("Last Day Open = ",open,"\n", "Last Day Close = ",close,"\n", "Fib lvl 0% = ",high,"\n", "Fib lvl 23.6% = ",fibRetracLvl1,"\n", "Fib lvl 38.2% = ",fibRetracLvl2,"\n", "Fib lvl 50% = ",fibRetracLvl3,"\n", "Fib lvl 61.8% = ",fibRetracLvl4,"\n", "Fib lvl 100% = ",fibRetracLvl5); } else { ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,high,endingTime,low); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed); } double fibRetracLvl1 = NormalizeDouble(low + (high-low) * 23.6 / 100,_Digits); double fibRetracLvl2 = NormalizeDouble(low + (high-low) * 38.2 / 100,_Digits); double fibRetracLvl3 = NormalizeDouble(low + (high-low) * 50 / 100,_Digits); double fibRetracLvl4 = NormalizeDouble(low + (high-low) * 61.8 / 100,_Digits); double fibRetracLvl5 = NormalizeDouble(low + (high-low) * 100 / 100,_Digits); Comment("Last Day Open = ",open,"\n", "Last Day Close = ",close,"\n", "Fib lvl 0% = ",low,"\n", "Fib lvl 23.6% = ",fibRetracLvl1,"\n", "Fib lvl 38.2% = ",fibRetracLvl2,"\n", "Fib lvl 50% = ",fibRetracLvl3,"\n", "Fib lvl 61.8% = ",fibRetracLvl4,"\n", "Fib lvl 100% = ",fibRetracLvl5); } } } //+------------------------------------------------------------------+
Dopo aver compilato questo codice senza errori ed averlo eseguito, i suoi segnali sono identici a quelli dei seguenti esempi dei test per i casi rialzisti e ribassisti.
La candela giornaliera è rialzista:
Quindi, si suppone di trovare il FIBO disegnato dal basso verso l'alto, che il suo colore sia verde e che i livelli del FIBO e l'apertura e la chiusura del giorno siano gli stessi che abbiamo trovato sul giornaliero. L'immagine seguente serve a questo scopo.
Come possiamo vedere nell'immagine precedente e in base alla barra rialzista giornaliera, FIBO è tracciato dal basso verso l'alto e il suo colore è verde, inoltre abbiamo bisogno di un commento sul grafico con i seguenti valori:
- L'apertura dell'ultimo giorno ==> è la stessa della finestra dei dati del grafico giornaliero.
- Chiusura dell'ultimo giorno ==> è la stessa del grafico giornaliero.
- Cinque livelli di prezzo del ritracciamento di Fibonacci.
La candela giornaliera è ribassista:
Quindi, si suppone di trovare il FIBO disegnato dal massimo al minimo, che il suo colore sia rosso e che i livelli del FIBO e l'apertura e la chiusura del giorno siano gli stessi che abbiamo trovato sul giornaliero. L'immagine seguente serve a questo scopo.
Come possiamo vedere nell'immagine precedente e in base alla barra ribassista giornaliera, il FIBO è tracciato dal massimo al minimo e il suo colore è rosso, inoltre abbiamo un commento sul grafico con i seguenti valori:
- L'apertura dell'ultimo giorno ==> è la stessa della finestra dei dati del grafico giornaliero.
- La chiusura dell'ultimo giorno ==> è la stessa del grafico giornaliero.
- Cinque livelli di prezzo del ritracciamento di Fibonacci.
Segnali FIBO:
In base a questo approccio, dobbiamo creare un sistema di trading in grado di fornire segnali di acquisto e di vendita in base all'input dell'utente del livello di entrata basato sui livelli FIBO. Di seguito è riportato il codice completo per farlo:
//+------------------------------------------------------------------+ //| Simple Fibo System#2.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" #define FIB_OBJ "Fibonacci Retracement" #property script_show_inputs input double fibRetracLvl = 38.2; int barsTotal; //+------------------------------------------------------------------+ void OnTick() { int bars = iBars(_Symbol, PERIOD_D1); if(barsTotal != bars && TimeCurrent() > StringToTime("00:05")) { barsTotal=bars; ObjectDelete(0,FIB_OBJ); double open = iOpen(_Symbol,PERIOD_D1,1); double close = iClose(_Symbol,PERIOD_D1,1); double closeCandle = iClose(_Symbol,_Period,1); double high = iHigh(_Symbol,PERIOD_D1,1); double low = iLow(_Symbol,PERIOD_D1,1); datetime startingTime = iTime(_Symbol,PERIOD_D1,1); datetime endingTime = iTime(_Symbol,PERIOD_D1,0)-1; if(close>open) { ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,low,endingTime,high); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen); } double fibRetracLvl1 = NormalizeDouble(high - (high-low) * 23.6 / 100,_Digits); double fibRetracLvl2 = NormalizeDouble(high - (high-low) * 38.2 / 100,_Digits); double fibRetracLvl3 = NormalizeDouble(high - (high-low) * 50 / 100,_Digits); double fibRetracLvl4 = NormalizeDouble(high - (high-low) * 61.8 / 100,_Digits); double fibRetracLvl5 = NormalizeDouble(high - (high-low) * 100 / 100,_Digits); double entryLvl = NormalizeDouble(high - (high-low) * fibRetracLvl /100,_Digits); Comment("Last Day Open = ",open,"\n", "Last Day Close = ",close,"\n", "Buy Entry Price: ",entryLvl); } else { ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,high,endingTime,low); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed); } double fibRetracLvl1 = NormalizeDouble(low + (high-low) * 23.6 / 100,_Digits); double fibRetracLvl2 = NormalizeDouble(low + (high-low) * 38.2 / 100,_Digits); double fibRetracLvl3 = NormalizeDouble(low + (high-low) * 50 / 100,_Digits); double fibRetracLvl4 = NormalizeDouble(low + (high-low) * 61.8 / 100,_Digits); double fibRetracLvl5 = NormalizeDouble(low + (high-low) * 100 / 100,_Digits); double entryLvl = NormalizeDouble(low + (high-low) * fibRetracLvl /100,_Digits); { Comment("Last Day Open = ",open,"\n", "Last Day Close = ",close,"\n", "Sell Entry Price: ",entryLvl); } } } } //+------------------------------------------------------------------+
Differenze in questo codice:
Aggiungere una proprietà per mostrare la finestra di input dell'utente, usando #property script_show_inputs che visualizza una finestra con le proprietà.
#property script_show_inputs
Utilizzo della variabile di input per creare un tipo di dati double per fibRetracLvl con un valore predefinito di 38,2.
input double fibRetracLvl = 38.2;
Definizione del livello di entrata in base all'input dell'utente in caso di rialzo.
double entryLvl = NormalizeDouble(high - (high-low) * fibRetracLvl /100,_Digits);
Definizione del livello di entrata in base all'input dell'utente in caso di ribasso.
double entryLvl = NormalizeDouble(low + (high-low) * fibRetracLvl /100,_Digits);
Commento sul grafico in caso di rialzo.
Comment("Last Day Open = ",open,"\n", "Last Day Close = ",close,"\n", "Buy Entry Price: ",entryLvl,"\n", "Close: ",closeCandle,"\n");
Commento sul grafico in caso di ribasso.
Comment("Last Day Open = ",open,"\n", "Last Day Close = ",close,"\n", "Sell Entry Price: ",entryLvl,"\n", "Close: ",closeCandle);
Dopo aver compilato ed eseguito questo codice, saremo pronti a ricevere i segnali e vedremo gli esempi dei test per i casi rialzisti e ribassisti.
La candela giornaliera è rialzista:
Quindi, dovremmo vedere il FIBO verde tracciato che parte dal basso verso l'alto in 15 minuti, l'apertura e la chiusura dell'ultimo giorno sono le stesse del grafico giornaliero, e il livello di ingresso è lo stesso livello di prezzo vicino al 38,2. Quanto segue per il grafico a 15 minuti:
Come possiamo vedere nel precedente grafico a 15 minuti abbiamo i seguenti valori, gli stessi che abbiamo determinato:
- L'apertura dell'ultimo giorno ==> è la stessa del grafico giornaliero.
- La chiusura dell'ultimo giorno ==> è anche la stessa.
- Il prezzo di ingresso per l'acquisto ==> è lo stesso livello di prezzo vicino al livello 38,2 FIBO.
La candela giornaliera è ribassista:
Quindi, ora controlleremo il grafico a 15 minuti per ottenere il nostro segnale basato sulla strategia di trading, che dovrebbe mostrare un livello di ingresso in vendita basato sul livello FIBO 38.2. Verifichiamo questo aspetto con la seguente immagine:
Come possiamo vedere, abbiamo i seguenti valori come segnale sul grafico a 15 minuti:
- L'apertura dell'ultimo giorno ==> è la stessa del grafico giornaliero.
- La chiusura dell'ultimo giorno ==> è anche la stessa.
- Il prezzo d’ingresso in vendita ==> è lo stesso livello vicino al livello 38,2 FIBO.
Il secondo approccio - Utilizzo di un array di candele specifiche:
Sistema FIBO Semplice 2:
Secondo questo approccio, utilizzeremo un numero predeterminato di candele da utilizzare per la creazione del Fibonacci, mentre di seguito sono i passaggi per farlo in modo diverso:
Definizione di FIB_OBJ tramite #define.
#define FIB_OBJ "Fibonacci Retracement"
Creare due variabili integer per la candela più alta e quella più bassa.
int highestCandle, lowestCandle; Creare due array per massimo e minimo.
double high[],low[]; Ordinamento dei dati negli array high e low mediante la funzione "ArraySetAsSeries". I suoi parametri:
- array[]: per determinare gli array creati high e low.
- flag: Direzione di indicizzazione dell’array, che sarà true.
ArraySetAsSeries(high,true); ArraySetAsSeries(low,true);
Ottenere i dati storici dei massimi e dei minimi utilizzando CopyHigh e CopyLow. I parametri di CopyHigh sono:
- symbol_name: sarà _Symbol per il simbolo corrente.
- timeframe: utilizzeremo _Period per quello attuale.
- start_pos: per determinare la posizione iniziale, useremo 0 per la candela corrente.
- count: per determinare il numero di dati da copiare, useremo 100.
- high_array[]: per determinare l'array di destinazione, utilizzeremo l'array high creato.
Per CopyLow i parametri saranno gli stessi, ma l'array di destinazione sarà l’array creato low.
CopyHigh(_Symbol,_Period,0,100,high); CopyLow(_Symbol,_Period,0,100,low);
Definire il prezzo di apertura della prima candela dell'array e il prezzo di chiusura dell'ultima candela dell'array utilizzando le funzioni iOpen e iClose.
double openCandle = iOpen(_Symbol,_Period,100); double closeCandle = iClose(_Symbol,_Period,1);
Definire il valore più alto e più basso negli array creati high e low, utilizzando le funzioni ArrayMaximum e ArrayMinimum. I parametri sono:
- array[]: useremo high per il valore massimo e low per il valore minimo.
- start=0: per determinare l'indice con cui iniziare la verifica, useremo 0.
- count: per determinare il numero di elementi da controllare, useremo 100 o possiamo usare anche WHOLE_ARRAY.
highestCandle=ArrayMaximum(high,0,100); lowestCandle=ArrayMinimum(low,0,100);
Creare un array per il prezzo utilizzando la funzione MqlRates per memorizzare le informazioni sui prezzi e ordinare i dati in questo array utilizzando la funzione ArraySetAsSeries.
MqlRates pArray[]; ArraySetAsSeries(pArray,true);
Ottenere i dati storici da MqlRates tramite la funzione CopyRates e i suoi parametri sono:
- symbol_name: per determinare il nome del simbolo, useremo _Symbol da applicare al simbolo corrente.
- timeframe: per determinare il timeframe si utilizzerà _Period da applicare al timeframe corrente.
- start_pos: per determinare il punto o la posizione di partenza, useremo (0) per partire dalla posizione corrente.
- count: per determinare il conteggio da copiare, utilizzeremo Bars.
- rates_array[]: per determinare l'array di destinazione da copiare, useremo pArray.
int pData=CopyRates(_Symbol,_Period,0,Bars(_Symbol,_Period),pArray);
Definizione di dateTime e del prezzo del livello zero e dei livelli 100 tramite ObjectGetInteger e ObjectGetDouble
datetime dTlvl0 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,0); double PriceFibLvl00 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,0); datetime dTlvl1 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,1); double PriceFibLvl0 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,1);
Impostazione delle condizioni dei casi rialzisti e ribassisti mediante l'operatore if-else.
In caso di rialzo (CloseCandle maggiore di openCandle), è necessario che si verifichino i seguenti passaggi:
- Eliminare l'oggetto FIBO precedentemente disegnato utilizzando ObjectDelete.
- Creare un nuovo oggetto FIBO partendo dal punto più basso a quello più alto dell'array utilizzando ObjectCreate.
- Aggiornare il colore dell'oggetto FIBO al colore verde, utilizzando ObjectSetInteger e il ciclo for per l'aggiornamento continuo in base al caso.
- Definire la fascia di prezzo ottenendo la differenza tra massimo e minimo.
- Definizione dei livelli FIBO: 23,6 - 38,2 - 50 - 61,8.
- Commento sul grafico con i livelli Array Open, Array Close e FIBO.
if(closeCandle>openCandle) { ObjectDelete(_Symbol, "Fibonacci Retracement"); ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time, pArray[lowestCandle].low,pArray[0].time,pArray[highestCandle].high); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen); } double pRange = PriceFibLvl0 - PriceFibLvl00; double PriceFibLvl1 = NormalizeDouble (PriceFibLvl0 - pRange * 23.6/100,_Digits); double PriceFibLvl2 = NormalizeDouble (PriceFibLvl0 - pRange * 38.2/100,_Digits); double PriceFibLvl3 = NormalizeDouble (PriceFibLvl0 - pRange * 50/100,_Digits); double PriceFibLvl4 = NormalizeDouble(PriceFibLvl0 - pRange * 61.8/100,_Digits); Comment("Array Open: ",openCandle,"\n", "Array Close: ",closeCandle,"\n", "Fib lvl 0% = ",PriceFibLvl0,"\n", "Fib lvl 23.6% = ",PriceFibLvl1,"\n", "Fib lvl 38.2% = ",PriceFibLvl2,"\n", "Fib lvl 50% = ",PriceFibLvl3,"\n", "Fib lvl 61.8% = ",PriceFibLvl4,"\n", "Fib lvl 100% = ",PriceFibLvl00); }
In caso di ribasso (CloseCandle inferiore a openCandle), è necessario che si verifichino i seguenti passaggi:
- Eliminare l'oggetto FIBO precedentemente disegnato utilizzando ObjectDelete.
- Creare un nuovo oggetto FIBO partendo dall'alto verso il basso dell'array utilizzando ObjectCreate.
- Aggiornare il colore dell'oggetto FIBO al colore rosso utilizzando ObjectSetInteger e il ciclo for per l'aggiornamento continuo in base al caso.
- Definire la fascia di prezzo ottenendo la differenza tra minimo e massimo.
- Definizione dei livelli FIBO: 23,6 - 38,2 - 50 - 61,8.
- Commento sul grafico con i livelli Array Open, Array Close e FIBO.
else { ObjectDelete(_Symbol, "Fibonacci Retracement"); ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time, pArray[highestCandle].high,pArray[0].time,pArray[lowestCandle].low); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed); } double pRange = PriceFibLvl00 - PriceFibLvl0; double PriceFibLvl1 = NormalizeDouble (PriceFibLvl0 + pRange * 23.6/100,_Digits); double PriceFibLvl2 = NormalizeDouble (PriceFibLvl0 + pRange * 38.2/100,_Digits); double PriceFibLvl3 = NormalizeDouble(PriceFibLvl0 + pRange * 50/100,_Digits); double PriceFibLvl4 = NormalizeDouble (PriceFibLvl0 + pRange * 61.8/100,_Digits); Comment("Array Open: ",openCandle,"\n", "Array Close: ",closeCandle,"\n", "Fib lvl 0% = ",PriceFibLvl0,"\n", "Fib lvl 23.6% = ",PriceFibLvl1,"\n", "Fib lvl 38.2% = ",PriceFibLvl2,"\n", "Fib lvl 50% = ",PriceFibLvl3,"\n", "Fib lvl 61.8% = ",PriceFibLvl4,"\n", "Fib lvl 100% = ",PriceFibLvl00); }
Di seguito è riportato il codice completo:
//+------------------------------------------------------------------+ //| Simple Fibo System 2.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" #define FIB_OBJ "Fibonacci Retracement" //+------------------------------------------------------------------+ void OnTick() { int highestCandle, lowestCandle; double high[],low[]; ArraySetAsSeries(high,true); ArraySetAsSeries(low,true); CopyHigh(_Symbol,_Period,0,100,high); CopyLow(_Symbol,_Period,0,100,low); double openCandle = iOpen(_Symbol,_Period,100); double closeCandle = iClose(_Symbol,_Period,1); highestCandle=ArrayMaximum(high,0,100); lowestCandle=ArrayMinimum(low,0,100); MqlRates pArray[]; ArraySetAsSeries(pArray,true); int pData=CopyRates(_Symbol,_Period,0,Bars(_Symbol,_Period),pArray); datetime dTlvl0 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,0); double PriceFibLvl00 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,0); datetime dTlvl1 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,1); double PriceFibLvl0 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,1); if(closeCandle>openCandle) { ObjectDelete(_Symbol, "Fibonacci Retracement"); ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time, pArray[lowestCandle].low,pArray[0].time,pArray[highestCandle].high); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen); } double pRange = PriceFibLvl0 - PriceFibLvl00; double PriceFibLvl1 = NormalizeDouble (PriceFibLvl0 - pRange * 23.6/100,_Digits); double PriceFibLvl2 = NormalizeDouble (PriceFibLvl0 - pRange * 38.2/100,_Digits); double PriceFibLvl3 = NormalizeDouble (PriceFibLvl0 - pRange * 50/100,_Digits); double PriceFibLvl4 = NormalizeDouble(PriceFibLvl0 - pRange * 61.8/100,_Digits); Comment("Array Open: ",openCandle,"\n", "Array Close: ",closeCandle,"\n", "Fib lvl 0% = ",PriceFibLvl0,"\n", "Fib lvl 23.6% = ",PriceFibLvl1,"\n", "Fib lvl 38.2% = ",PriceFibLvl2,"\n", "Fib lvl 50% = ",PriceFibLvl3,"\n", "Fib lvl 61.8% = ",PriceFibLvl4,"\n", "Fib lvl 100% = ",PriceFibLvl00); } else { ObjectDelete(_Symbol, "Fibonacci Retracement"); ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time, pArray[highestCandle].high,pArray[0].time,pArray[lowestCandle].low); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed); } double pRange = PriceFibLvl00 - PriceFibLvl0; double PriceFibLvl1 = NormalizeDouble (PriceFibLvl0 + pRange * 23.6/100,_Digits); double PriceFibLvl2 = NormalizeDouble (PriceFibLvl0 + pRange * 38.2/100,_Digits); double PriceFibLvl3 = NormalizeDouble(PriceFibLvl0 + pRange * 50/100,_Digits); double PriceFibLvl4 = NormalizeDouble (PriceFibLvl0 + pRange * 61.8/100,_Digits); Comment("Array Open: ",openCandle,"\n", "Array Close: ",closeCandle,"\n", "Fib lvl 0% = ",PriceFibLvl0,"\n", "Fib lvl 23.6% = ",PriceFibLvl1,"\n", "Fib lvl 38.2% = ",PriceFibLvl2,"\n", "Fib lvl 50% = ",PriceFibLvl3,"\n", "Fib lvl 61.8% = ",PriceFibLvl4,"\n", "Fib lvl 100% = ",PriceFibLvl00); } } //+------------------------------------------------------------------+
Dopo la compilazione e l'esecuzione di questo codice, possiamo trovare i seguenti segnali. Di seguito sono riportati alcuni esempi provenienti dai test.
Nel caso in cui l'array sia rialzista:
Come possiamo vedere, abbiamo un oggetto FIBO verde sul grafico e un commento in alto a sinistra del grafico con i seguenti valori secondo questo EA:
- Array open ==> per il prezzo di apertura della prima candela dell'array.
- Array close ==> per il prezzo di chiusura dell'ultima candela dell'array.
- Livelli FIBO 0, 23.6, 38.2, 50, 61.8, 100.
Nel caso in cui l'array sia ribassista:
Come possiamo vedere, abbiamo un oggetto FIBO rosso sul grafico e un commento in alto a sinistra del grafico con i seguenti valori secondo questo EA:
- Array open ==> per il prezzo di apertura della prima candela dell'array.
- Array close ==> per il prezzo di chiusura dell'ultima candela dell'array.
- Livelli FIBO 0, 23.6, 38.2, 50, 61.8, 100.
Segnali FIBO 2:
Ora creeremo, sulla base del secondo approccio, un sistema di trading che restituisca segnali di acquisto e vendita in base al livello FIBO inserito dall'utente. Quello che segue è il codice completo per creare questo sistema di trading:
//+------------------------------------------------------------------+ //| Fibo Signals 2.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" #define FIB_OBJ "Fibonacci Retracement" #property script_show_inputs input double fibRetracLvl = 38.2; //+------------------------------------------------------------------+ void OnTick() { int highestCandle, lowestCandle; double high[],low[]; ArraySetAsSeries(high,true); ArraySetAsSeries(low,true); CopyHigh(_Symbol,_Period,0,100,high); CopyLow(_Symbol,_Period,0,100,low); double openCandle = iOpen(_Symbol,_Period,100); double closeCandle = iClose(_Symbol,_Period,1); highestCandle=ArrayMaximum(high,0,100); lowestCandle=ArrayMinimum(low,0,100); MqlRates pArray[]; ArraySetAsSeries(pArray,true); int pData=CopyRates(_Symbol,_Period,0,Bars(_Symbol,_Period),pArray); datetime dTlvl0 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,0); double PriceFibLvl00 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,0); datetime dTlvl1 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,1); double PriceFibLvl0 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,1); if (closeCandle>openCandle) { ObjectDelete(_Symbol, "Fibonacci Retracement"); ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time, pArray[lowestCandle].low,pArray[0].time,pArray[highestCandle].high); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen); } double pRange = PriceFibLvl0 - PriceFibLvl00; double PriceFibLvl1 = NormalizeDouble(PriceFibLvl0 - pRange * 23.6/100,_Digits); double PriceFibLvl2 = NormalizeDouble(PriceFibLvl0 - pRange * 38.2/100,_Digits); double PriceFibLvl3 = NormalizeDouble(PriceFibLvl0 - pRange * 50/100,_Digits); double PriceFibLvl4 = NormalizeDouble(PriceFibLvl0 - pRange * 61.8/100,_Digits); double entryLvl = NormalizeDouble(PriceFibLvl0 - pRange * fibRetracLvl/100,_Digits); Comment("Array Open: ",openCandle,"\n", "Array Close: ",closeCandle,"\n", "Buy Entry Price: ",entryLvl); } else { ObjectDelete(_Symbol, "Fibonacci Retracement"); ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time, pArray[highestCandle].high,pArray[0].time,pArray[lowestCandle].low); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed); } double pRange = PriceFibLvl00 - PriceFibLvl0; double PriceFibLvl1 = NormalizeDouble(PriceFibLvl0 + pRange * 23.6/100,_Digits); double PriceFibLvl2 = NormalizeDouble(PriceFibLvl0 + pRange * 38.2/100,_Digits); double PriceFibLvl3 = NormalizeDouble(PriceFibLvl0 + pRange * 50/100,_Digits); double PriceFibLvl4 = NormalizeDouble(PriceFibLvl0 + pRange * 61.8/100,_Digits); double entryLvl = NormalizeDouble(PriceFibLvl0 + pRange * fibRetracLvl/100,_Digits); Comment("Array Open: ",openCandle,"\n", "Array Close: ",closeCandle,"\n", "Sell Entry Price: ",entryLvl); } } //+------------------------------------------------------------------+
Differenze in questo codice:
Aggiunta di una proprietà utilizzando #property script_show_inputs che visualizza una finestra con le proprietà e utilizzo di una variabile di input per creare un tipo di dati double per fibRetracLvl con un valore predefinito di 38,2, ad esempio.
#property script_show_inputs input double fibRetracLvl = 38.2;
Definizione del livello di entrata in base all'input dell'utente in caso di rialzi.
double entryLvl = NormalizeDouble(PriceFibLvl0 - pRange * fibRetracLvl/100,_Digits);
Definizione del livello di entrata in base all'input dell'utente in caso di ribasso.
double entryLvl = NormalizeDouble(PriceFibLvl0 + pRange * fibRetracLvl/100,_Digits);
Commento basato sul caso rialzista.
Comment("Array Open: ",openCandle,"\n", "Array Close: ",closeCandle,"\n", "Buy Entry Price: ",entryLvl);
Commento basato sul caso ribassista.
Comment("Array Open: ",openCandle,"\n", "Array Close: ",closeCandle,"\n", "Sell Entry Price: ",entryLvl);
Dopo aver compilato ed eseguito questo codice, possiamo ottenere i nostri segnali come i seguenti esempi di array rialzisti e ribassisti.
L'array è rialzista:
Come si può vedere, abbiamo un oggetto FIBO verde disegnato dal valore più basso a quello più alto dell'array e i seguenti valori come commento sul grafico:
- Array open ==> è lo stesso valore del prezzo di apertura della prima candela dell'array.
- Array close ==> è lo stesso valore del prezzo di chiusura dell'ultima candela dell'array.
- Il prezzo di ingresso per l'acquisto ==> è lo stesso valore del livello 38,2 FIBO.
L’array è ribassista:
Come si può notare, abbiamo un oggetto FIBO rosso disegnato dal valore più alto al valore più basso dell'array e i seguenti valori come commento sul grafico:
- Array open ==> è lo stesso valore del prezzo di apertura della prima candela dell'array.
- Array close ==> è lo stesso valore del prezzo di chiusura dell'ultima candela dell'array.
- Il prezzo di ingresso per la vendita ==> è lo stesso valore del livello 38,2 FIBO.
Conclusioni
Ora, si suppone che abbiate imparato a creare un semplice sistema di trading con Fibonacci con MQL5 da utilizzare per il terminale di trading MetaTrader 5, dopo aver appreso in dettaglio lo strumento tecnico di Fibonacci attraverso l'argomento della definizione di Fibonacci e aver appreso come utilizzarlo dopo averlo inserito in MetaTrader 5.
Inoltre, abbiamo condiviso qui due approcci per creare Fibonacci, uno utilizzando i dati giornalieri e l'altro utilizzando un array di candele specifiche in qualsiasi timeframe in modo da restituire i livelli di Fibonacci e ottenere livelli di ingresso in acquisto o in vendita basati su questi livelli. Confermo ancora una volta di combinare questo strumento con altri strumenti tecnici per ottenere risultati migliori e di testare le strategie o i concetti menzionati prima di utilizzarli sul vostro conto reale per assicurarvi che saranno profittevoli per il vostro trading e non c'è nulla che sia adatto a tutti, inoltre l'obiettivo principale qui è solo educativo e potete trovare alcuni perfezionamenti o ottimizzazioni per le strategie menzionate.
Spero che questo articolo sia utile e stimolante per voi, in quanto vi permetterà di imparare qualcosa di nuovo o di aprire gli occhi a nuove idee che possono migliorare i vostri risultati di trading. Se desiderate leggere altri articoli simili sulla progettazione di sistemi di trading basati sugli indicatori tecnici e sugli strumenti più diffusi, potete leggere gli altri miei articoli di questa serie, in cui condividiamo quelli più popolari, come le medie mobili, il MACD, le bande di Bollinger, lo Stocastico,etc... e spero che anche voi li troviate utili.
Tradotto dall’inglese da MetaQuotes Ltd.
Articolo originale: https://www.mql5.com/en/articles/12301
Come utilizzare MQL5 per individuare i pattern di candele
Pattern con Esempi (Parte I): Massimi Multipli
Aspettative morali nel trading
Gli Swap (Parte I): Posizioni di Blocco e Sintetiche
- 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