MetaTrader 5 / Trading
English Русский 中文 Español Deutsch 日本語 Português 한국어 Italiano Türkçe
preview
Apprenez à concevoir un système de trading basé sur les Retracements de Fibonacci

Apprenez à concevoir un système de trading basé sur les Retracements de Fibonacci

MetaTrader 5 — Trading | 15 novembre 2024, 09:51
1 615 0
Mohamed Abdelmaaboud
Mohamed Abdelmaaboud

Introduction

Dans ce nouvel article de notre série sur l'apprentissage de la conception d'un système de trading basé sur les outils et indicateurs d'analyse technique les plus populaires, nous allons apprendre à créer un système de trading basé sur l'outil technique du Retracement de Fibonacci qui est l'un des plus populaires et des plus utilisés dans le trading. Nous pourrons utiliser ce système de trading sur notre terminal de trading MetaTrader 5. Nous utiliserons MQL5 (MetaQuotes Language 5) qui est l'IDE intégré à MetaTrader 5. Si vous souhaitez apprendre à télécharger et à utiliser MetaTrader 5 et l'IDE MQL5, vous pouvez lire cette rubrique Écrire du code MQL5 dans MetaEditor d'un article précédent.

Les thèmes abordés aujourd’hui seront les suivants :

Il est bon de mentionner qu'il sera préférable d'utiliser ce Fibonacci accompagné d'autres outils techniques comme l'analyse des tendances, le support, la résistance, etc. car cela donnera de meilleurs aperçus et résultats. Vous devez également tester toute stratégie ou outil appris dans cet article ou ailleurs avant de l'utiliser dans le monde réel afin de vous assurer qu'il sera utile et rentable pour votre trading. En tant que développeur de compétences en programmation, il est préférable que vous appliquiez et essayiez de coder vous-même ce que vous avez lu, car cette étape est très bénéfique pour vous.

Avertissement : Toutes les informations données dans cet article sont fournies "en l'état", uniquement à des fins d'information et ne sont aucunement données à des fins de trading ou de conseil. Ces informations ne garantissent aucun type de résultat. Si vous utilisez le contenu de cet article sur l'un de vos comptes de trading, vous le faites à vos propres risques et vous en serez le seul responsable.


Définition de Fibonacci

Dans cette section, nous identifierons l'outil des Retracements de Fibonacci et nous apprendrons comment l'utiliser sur notre graphique. Le Fibo est un outil technique qui peut être utilisé pour trouver des zones de support ou de résistance sur le graphique à partir desquelles nous nous attendons à un rebond. Elle est basée sur la séquence de Fibonacci qui est une série mathématique de nombres. chaque nombre de cette série est la somme des deux nombres précédents. Nous pouvons la trouver sur le graphique sous forme de lignes horizontales à des niveaux spécifiques comme 23,6%, 38,2%, 50%, et 61,8%. Ces niveaux sont les plus populaires.

Si vous vous demandez comment le trouver sur le graphique, la réponse est : vous n’avez qu’à l'insérer à partir des outils techniques disponibles dans MetaTrader 5 :

En ouvrant MetaTrader 5, naviguez dans l'onglet Insertion --> Objets --> Retracement de Fibonacci.

Insertion Fibo

Si nous avons un retracement dans une tendance haussière, nous le traçons du bas vers le haut. Et vice versa, si nous avons un retracement dans une tendance baissière, nous le traçons du haut vers le bas, comme dans les exemples suivants.

FIBO dans une tendance haussière :

Insertion Fibo haussier

FIBO dans une tendance baissière :

Insertion Fibo baissier

Comme nous pouvons le voir dans les exemples précédents, une ligne de tendance est tracée entre 2 points : la valeur la plus haute et la valeur la plus basse, avec en plus des lignes horizontales avec des niveaux spécifiques 23,6, 38,2, 50, et 61,8. Ce sont les niveaux les plus populaires. Autour de ces niveaux et après une tendance haussière ou baissière, nous assistons à des corrections ou à des retracements. Nous pouvons nous attendre à un rebond à partir de ces niveaux après la correction. Ainsi, les niveaux de FIBO peuvent agir comme des niveaux de support ou de résistance.

Nous pouvons également contrôler ces niveaux à travers la fenêtre de cet outil en faisant un clic droit sur l'outil de dessin ou en faisant un clic droit sur le graphique, puis en sélectionnant « Liste d'objets » dans le menu, puis en sélectionnant l'objet Fibo. La fenêtre s'ouvrira comme ci-dessous :

Fibo 1

Nous pouvons contrôler à partir de l'onglet Commun le nom de l'objet et son style comme la couleur, le type de ligne et l'épaisseur.

Fibo 2

Comme nous pouvons le voir dans l'image précédente, nous pouvons contrôler et déterminer les niveaux de réglage souhaités, ainsi que le style.

Fibo 3

Comme nous pouvons le voir dans l'onglet Paramètres, nous pouvons déterminer la date, l'heure et la valeur à partir desquelles nous voulons commencer, ainsi que la date, l'heure et la valeur à laquelle nous voulons terminer l'objet Fibonacci.


Stratégie de Fibonacci

Dans cette partie, nous allons apprendre à utiliser le retracement de Fibonacci à travers des stratégies simples basées sur 2 approches différentes. L'une d'entre elles consiste à déterminer les niveaux FIBO sur la base de la dernière bougie journalière. La seconde consiste à déterminer le nombre de bougies de n'importe quelle période et à déterminer les niveaux FIBO sur la base de ces bougies. Nous utiliserons ensuite une autre stratégie pour obtenir un signal d'achat ou de vente spécifique basé sur un niveau FIBO prédéterminé pour chaque approche.

Première approche : Utilisation des données quotidiennes

Système FIBO simple

Si la dernière bougie quotidienne est haussière, nous devons obtenir une FIBO haussière du plus bas au plus haut de la bougie et les niveaux de prix de chaque niveau. Si la dernière bougie quotidienne est baissière, nous devons obtenir une FIBO rouge baissière du plus haut au plus bas de cette bougie et les niveaux de prix de cette FIBO.

Plus simplement :

Clôture du dernier jour > ouverture ==> bougie haussière

Obtenir des niveaux de FIBO verts et les prix de ces niveaux.  

Clôture du dernier jour < ouverture ==> bougie baissière

Obtenir des niveaux de FIBO rouges et les prix de ces niveaux.

Signaux FIBO

Sur la base de cette stratégie, nous devons obtenir des entrées d’achat et de vente, basées les niveaux de FIBO haussiers ou baissiers. Si nous avons déterminé un niveau de FIBO haussier de 38,2, nous devons obtenir le prix de ce niveau comme prix d’entrée pour un achat. Et si nous déterminons le même niveau de FIBO baissier, nous devons obtenir le prix de ce niveau comme entrée pour une vente.

Deuxième approche : Utilisation d'un tableau de bougies spécifiques

Système FIBO simple 2 :

Selon cette stratégie, nous devons obtenir les niveaux de prix FIBO basés sur un tableau de bougies. Si nous avons un FIBO haussier basé sur la direction du tableau, nous devons obtenir les niveaux de prix FIBO, et si nous avons un FIBO baissier basé sur la direction du tableau, nous devons obtenir ses niveaux de prix FIBO.

Plus simplement :

Si l'ouverture de la première bougie du tableau < la clôture de la dernière bougie du même tableau ==> FIBO haussier, il faut obtenir les niveaux de prix de ce FIBO haussier.

Si l'ouverture de la première bougie du tableau > la clôture de la dernière bougie du même tableau ==> FIBO baissier, nous devons obtenir les niveaux de prix de ce FIBO baissier.

Signaux FIBO 2 : 

Sur la base de cette stratégie, nous devons obtenir les entrées d'achat ou de vente en fonction de la saisie par l'utilisateur du niveau FIBO souhaité comme niveau d'entrée. Si nous avons un FIBO haussier sur la base de ce que nous avons décrit précédemment, nous devons obtenir le niveau d'entrée d'achat d'un niveau FIBO spécifique. Si nous avons un FIBO baissier, nous devons obtenir le niveau d'entrée de vente d'un niveau FIBO spécifique.


Schéma de la stratégie de Fibonacci

Dans cette partie, nous verrons les plans de chaque stratégie dans les deux approches mentionnées afin de comprendre ce que nous devons faire d'une manière visuelle.

Première approche : Utilisation des données quotidiennes

Comme nous l'avons mentionné ici, nous utiliserons la dernière bougie journalière et déterminerons son ouverture, sa clôture, son plus haut et son plus bas. En comparant l'ouverture et la clôture, nous pouvons détecter si nous avons une bougie haussière ou baissière. En fonction du type de mouvement de cette dernière bougie journalière, nous dessinerons l'objet de Fibonacci et obtiendrons les signaux souhaités.

Système FIBO simple

Plan du système Fibo simple

Signaux FIBO

Plan du Signal Fibo

Deuxième approche : Utilisation d'un tableau de bougies spécifiques

Comme nous l'avons mentionné ici, nous utiliserons un nombre spécifique de bougies dans un tableau et nous déterminerons la valeur d'ouverture de la première bougie, la valeur de clôture de la dernière bougie, la valeur la plus élevée et la valeur la plus basse. En comparant l'ouverture et la clôture, nous pouvons détecter si nous avons une bougie haussière ou baissière. En fonction du type de mouvement de ce tableau, nous dessinerons l'objet de Fibonacci et obtiendrons les signaux souhaités.

Système FIBO simple 2 :

Système Fibo simple 2

Signaux FIBO 2

Plan du Signal Fibo 2

Système de trading de Fibonacci

Dans cette partie, nous allons apprendre à créer un système de trading basé sur les éléments mentionnés précédemment. Nous allons créer un programme qui peut renvoyer les niveaux de Fibonacci sur le graphique sous forme de commentaire. Nous utiliserons deux approches : la première consiste à utiliser les dernières données quotidiennes pour tracer nos niveaux de Fibonacci sur cette base, et l'autre approche consiste à utiliser un nombre prédéterminé de bougies pour s'en servir comme tableau. Nous allons également apprendre à utiliser ces deux approches pour renvoyer des signaux d'achat et de vente basés sur Fibonacci. Voyons cela en détail.

Première approche : Utilisation des données quotidiennes

Système FIBO simple

Selon cette stratégie, nous utiliserons les données quotidiennes pour le système de Fibonacci. Voici les étapes suivantes pour y parvenir :

Définir le nom de l'objet nécessaire en utilisant la substitution de macro (#define) pour prétraiter le code source avant la compilation.

#define FIB_OBJ "Fibonacci Retracement"

Création d'une variable entière barsTotal.

int barsTotal;

Ensuite, dans la fonction onTick, nous créerons une variable de type entière pour les barres avec la fonction iBar qui renvoie le nombre de barres historiques disponibles pour le symbole. Ses paramètres sont :

  • symbol : pour déterminer le symbole souhaité, nous utiliserons _Symbol pour le symbole actuel.
  • timeframe : pour déterminer la période, nous utiliserons D1 pour le graphique journalier.
int bars = iBars(_Symbol, PERIOD_D1);

Nous émettons une condition pour détecter la bougie journalière que nous devons utiliser pour notre Fibonacci car nous avons besoin que barsTotal ne soit pas égal à bars en utilisant l'opérateur !=. Nous avons également besoin que l'heure actuelle soit supérieure à l'heure de fin de cette bougie journalière. Nous allons donc utiliser la fonction TimeCurrent et la fonction StringToTime pour transformer une chaîne contenant l'heure en un nombre de type date-heure.

if(barsTotal != bars  && TimeCurrent() > StringToTime("00:05"))

Une fois que cette condition est remplie, le programme doit effectuer les opérations suivantes :

Affecter les barres à barsTotal.

barsTotal=bars;

Supprimer n'importe quel FIB_OBJ sur le graphique en utilisant la fonction ObjectDelete, dont les paramètres sont les suivants :

  • chart_id : pour déterminer l'identifiant du graphique, nous utiliserons 0 qui signifie le graphique actuel. 
  • name : pour déterminer le nom de l'objet qui est FIB_OBJ.
ObjectDelete(0,FIB_OBJ);

Créer 4 variables pour les prix (open, close, high et low) en utilisant les fonctions iOpen, iClose, iHigh et iLow pour renvoyer le prix de la barre journalière :

  • symbol : pour déterminer le symbole souhaité, nous utiliserons _Symbol pour le symbole actuel.
  • timeframe : pour déterminer la période souhaitée, nous utiliserons PERIOD_D1 pour la période en jours.
  • shift : pour déterminer l'indice de la valeur reçue à partir de la série temporelle, nous ne l'utiliserons pas ici.
      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);

Déterminer l'heure de début et l'heure de fin qui seront utilisées ultérieurement pour dessiner notre objet de Fibonacci. Nous utiliserons la fonction iTime qui renvoie l'heure d'ouverture de la barre. Ses paramètres sont :

  • symbol : pour déterminer le symbole souhaité, nous utiliserons _Symbol pour le symbole actuel.
  • timeframe : pour déterminer la période souhaitée, nous utiliserons PERIOD_D1 pour la période en jours.
  • shift : pour déterminer l'indice de la valeur reçue à partir de la série temporelle, nous utiliserons 1 pour l'heure de début et 0 pour l'heure de fin.

Pour l'heure de fin, nous soustrayons 1 à la valeur de retour car elle se situera pendant le nouveau jour qui sera la barre journalière actuelle au moment de ce calcul, nous faisons donc cela pour détecter la barre de sens précédente.

      datetime startingTime = iTime(_Symbol,PERIOD_D1,1);
      datetime endingTime = iTime(_Symbol,PERIOD_D1,0)-1;

Nous fixerons ensuite 2 conditions en utilisant l'opérateur conditionnel if-else pour dessiner l'objet Fibonacci :

Si la clôture est supérieure à l'ouverture, il s'agit d'une bougie haussière et on peut continuer.

Création de l'objet en utilisant la fonction ObjectCreate avec les caractéristiques spécifiées. Ses paramètres sont :

  • chart_id : pour déterminer le graphique, nous utiliserons 0 pour le graphique actuel.
  • name : pour déterminer le nom de l'objet désiré, nous utiliserons FIB_OBJ.
  • type : pour déterminer le type d'objet, nous utiliserons OBJ_FIBO pour le retracement de Fibonacci.
  • nwin : pour déterminer l'index de la fenêtre, nous utiliserons 0 pour la fenêtre principale
  • time1 : pour déterminer l'heure du premier point, nous utiliserons l'heure de départ.
  • price1 : pour déterminer le prix du premier point, nous utiliserons le plus bas (low).
  • timeN=0 : pour déterminer l'heure du dernier point, nous utiliserons l'heure de fin.
  • priceN=0 : pour déterminer le prix du dernier point, nous utiliserons le plus haut (high).

Mise à jour de la couleur de l'objet pour l'adapter à la direction de la barre en utilisant ObjectSetInteger et l'opérateur de boucle for. Les paramètres de ObjectSetInteger sont les suivants :

  • chart_id : pour déterminer le graphique, nous utiliserons 0 pour le graphique actuel.
  • name : pour déterminer le nom de l'objet, nous utiliserons FIB_OBJ.
  • prop_id : pour déterminer l'identifiant de la propriété color, nous utiliserons OBJPROP_COLOR.
  • prop_value : pour déterminer la valeur de la propriété, nous utiliserons clrGreen.
  • Utilisation de la boucle for pour actualiser en permanence la couleur de l'objet.
Définition des niveaux de Fibonacci, 23,6 - 38,2 - 50 - 61,8 - 100. Un commentaire est placé sur le graphique avec l’ouverture et la clôture du dernier jour. 
      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);
        }

Dans le cas d'une journée baissière, la même chose se produira, mais la différence sera la suivante :

  • Création de l'objet et du plus haut vers le plus bas.
  • La couleur de l'objet sera rouge.
      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);
        }

Voici le code complet de cette stratégie :

//+------------------------------------------------------------------+
//|                                         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);
           }
        }
     }
  }
//+------------------------------------------------------------------+

Voici le code complet de ce système de 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);
        }
     }
  }
//+------------------------------------------------------------------+

Après avoir compilé ce code sans erreur et l'avoir exécuté, des signaux seront générés comme dans les exemples suivants pour les cas haussiers et baissiers.

La bougie journalière est haussière :

Système Fibo Simple - haussier - quotidien

Ainsi, nous sommes censés trouver le FIBO, tracé du plus bas vers le plus haut, de couleur verte. Les niveaux du FIBO ainsi que l'ouverture et la clôture du jour sont les mêmes que ceux que nous avons trouvés sur le quotidien. Vous pouvez le voir sur l'image suivante :

Système Fibo simple - haussier

Comme nous pouvons le voir dans l'image précédente et selon la barre haussière quotidienne, le FIBO est dessiné du bas vers le haut et sa couleur est verte. Nous avons également besoin d'un commentaire sur le graphique avec les valeurs suivantes :

  • Ouverture du dernier jour ==> la même que dans la fenêtre de données du graphique journalier.
  • Clôture du dernier jour ==> la même que pour le graphique journalier.
  • Cinq niveaux de retracement de Fibonacci.

La bougie journalière est baissière :

Système Fibo Simple - baissier - quotidien

Nous sommes donc censés trouver le FIBO, tracé du plus haut vers le plus bas, de couleur rouge. Les niveaux du FIBO et l'ouverture et la clôture du jour sont les mêmes que ceux que nous avons trouvés sur le journalier. Vous pouvez le voir sur l'image suivante :

Système Fibo simple - baissier

Comme nous pouvons le voir dans l'image précédente et selon la barre baissière quotidienne, le FIBO est dessiné du haut vers le bas et sa couleur est rouge. Et nous avons un commentaire sur le graphique avec les valeurs suivantes :

  • Ouverture du dernier jour ==> la même que dans la fenêtre de données du graphique journalier.
  • Clôture du dernier jour ==> la même que celle du graphique journalier.
  • Cinq niveaux de retracement de Fibonacci.

Signaux FIBO

Selon cette approche, nous devons créer un système de trading capable de renvoyer des signaux d'achat et de vente en fonction de la saisir de l'utilisateur du niveau d'entrée basé sur les niveaux FIBO. Voici le code complet :

//+------------------------------------------------------------------+
//|                                         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);
           }
        }
     }
  }
//+------------------------------------------------------------------+

Voici les différences dans ce code :

Ajout d'une propriété permettant d'afficher la fenêtre de saisie de l'utilisateur en utilisant la propriété #property script_show_inputs.

#property script_show_inputs

Utilisation de la variable d'entrée pour créer une variable fibRetracLvl de type double avec une valeur par défaut de 38.2.

input double fibRetracLvl = 38.2;

Définition du niveau d'entrée en fonction de l'entrée de l'utilisateur dans le cas d'une tendance haussière.

double entryLvl = NormalizeDouble(high - (high-low) * fibRetracLvl /100,_Digits);

Définition du niveau d'entrée en fonction de l'entrée de l'utilisateur dans le cas d'une tendance baissière.

double entryLvl = NormalizeDouble(low + (high-low) * fibRetracLvl /100,_Digits);

Commentaire sur le graphique dans le cas où la tendance est haussière.

         Comment("Last Day Open = ",open,"\n",
                 "Last Day Close = ",close,"\n",
                 "Buy Entry Price: ",entryLvl,"\n",
                 "Close: ",closeCandle,"\n");

Commentaire sur le graphique en cas de tendance baissière.

            Comment("Last Day Open = ",open,"\n",
                    "Last Day Close = ",close,"\n",
                    "Sell Entry Price: ",entryLvl,"\n",
                    "Close: ",closeCandle);

Après avoir compilé ce code et l'avoir exécuté, nous recevrons des signaux comme dans les exemples des tests pour les cas haussiers et baissiers.

La bougie journalière est haussière :

Signal Fibo - haussier - quotidien

Nous sommes donc censés voir le FIBO vert dessiné, partant du bas vers le haut en 15 min, l'ouverture et la clôture du dernier jour sont les mêmes que sur le graphique journalier, et le niveau d'entrée est le même niveau de prix, au niveau 38,2. Voici le résultat sur un graphique de 15 minutes :

Signal Fibo - haussier

Comme nous pouvons le voir dans le graphique 15 min précédent, les valeurs suivantes sont identiques à celles que nous avons déterminées :

  • Ouverture du dernier jour ==> la même que celle du graphique journalier.
  • Clôture du dernier jour ==> également le même.
  • Prix d'entrée à l'achat ==> le même niveau de prix à côté du niveau 38.2 FIBO.

La bougie journalière est baissière :

Signal Fibo - baissier - quotidien

Nous allons maintenant examiner le graphique en 15 minutes pour obtenir notre signal basé sur la stratégie de trading. Il est censé montrer un niveau d'entrée de vente basé sur le niveau FIBO 38,2. Vérifions-le à l'aide de l'image suivante :

Signal Fibo - baissier

Comme nous pouvons le voir, nous avons les valeurs suivantes comme signal sur le graphique 15 min :

  • Ouverture du dernier jour ==> la même que celle du graphique journalier.
  • Clôture du dernier jour ==> également le même.
  • Prix d’entrée de la vente ==> le même niveau à côté du niveau 38.2 FIBO.

Deuxième approche : Utilisation d'un tableau de bougies spécifiques

Système FIBO simple 2

Selon cette approche, nous utiliserons un nombre prédéterminé de bougies à utiliser pour la création de Fibonacci. Ce qui suit est la marche à suivre pour le faire différemment :

Définition du FIB_OBJ à l'aide de #define :

#define FIB_OBJ "Fibonacci Retracement"

Création de 2 variables entières pour les bougies les plus hautes et les plus basses.

int highestCandle, lowestCandle;

Création de 2 tableaux high et low pour les haut et les bas.

double high[],low[];

Tri des données dans les tableaux high et low à l'aide de la fonction "ArraySetAsSeries". Ses paramètres sont :

  • array[] : pour déterminer les tableaux créés high et low.
  • flag : Sens d'indexation du tableau, qui sera ’true’.
ArraySetAsSeries(high,true);
ArraySetAsSeries(low,true);

Obtention des données historiques du plus haut et du plus bas en utilisant CopyHigh et CopyLow. Les paramètres de CopyHigh sont les suivants :

  • symbol_name : nous allons _Symbol pour utiliser le symbole actuel.
  • timeframe : nous utiliserons _Period pour utiliser la période actuelle. 
  • start_pos : pour déterminer la position de départ, nous utiliserons 0 pour la bougie actuelle.
  • count : pour déterminer le nombre de données à copier, nous utiliserons 100.
  • high_array[] : pour déterminer le tableau cible, nous utiliserons le tableau high créé.

Pour CopyLow, les paramètres seront les mêmes, mais le tableau cible sera un tableau low créé.

CopyHigh(_Symbol,_Period,0,100,high);
CopyLow(_Symbol,_Period,0,100,low);

Définition du prix d'ouverture de la première bougie du tableau et du prix de clôture de la dernière bougie du tableau à l'aide des fonctions iOpen et iClose.

double openCandle = iOpen(_Symbol,_Period,100);
double closeCandle = iClose(_Symbol,_Period,1);

Définition de la valeur la plus élevée et de la valeur la plus basse dans les tableaux high et low créés en utilisant les bougies ArrayMaximum et ArrayMinimum. Ses paramètres sont les suivants :

  • array[] : nous utiliserons high pour la valeur maximale et low pour la valeur minimale.
  • start=0 : pour déterminer l'index avec lequel commencer la vérification, nous utiliserons 0.
  • count : pour déterminer le nombre d'éléments à vérifier, nous utiliserons 100 ou nous pouvons également utiliser WHOLE_ARRAY.
highestCandle=ArrayMaximum(high,0,100);
lowestCandle=ArrayMinimum(low,0,100);

Création d'un tableau pour le prix en utilisant la fonction MqlRates pour stocker des informations sur les prix et tri des données dans ce tableau en utilisant la fonction ArraySetAsSeries.

MqlRates pArray[];
ArraySetAsSeries(pArray,true);

Obtention des données historiques à partir de MqlRates par la fonction CopyRates, ses paramètres sont les suivants :

  • symbol_name : pour déterminer le nom du symbole, nous utiliserons _Symbol pour le symbole actuel.
  • timeframe : pour déterminer la période, nous utiliserons _Period pour appliquer pour la période actuelle.
  • start_pos : pour déterminer le point ou la position de départ, nous utiliserons 0 pour partir de la position actuelle.
  • count : pour déterminer le nombre de copies à effectuer, nous utiliserons Bars.
  • rates_array[] : pour déterminer la cible du tableau à copier, nous utiliserons pArray.
int pData=CopyRates(_Symbol,_Period,0,Bars(_Symbol,_Period),pArray);

Définition de la date et de l'heure ainsi que le prix du niveau zéro et du niveau 100 en utilisant ObjectGetInteger et 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);

Définition des conditions des cas haussiers et baissiers à l'aide de l'opérateur if-else.

Dans le cas d'une hausse (CloseCandle est supérieur à openCandle), il faut que les étapes suivantes se produisent :

  • Suppression de l'objet FIBO précédemment dessiné en utilisant ObjectDelete.
  • Création d'un nouvel objet FIBO en partant du plus bas au plus haut du tableau à l'aide de la fonction ObjectCreate.
  • Mise à jour de la couleur de l'objet FIBO en vert à l'aide de ObjectSetInteger et d'une boucle for pour poursuivre la mise à jour selon le cas.
  • Définition de la fourchette de prix en obtenant la différence entre le prix le plus haut et le prix le plus bas.
  • Définition des niveaux de FIBO, 23,6 - 38,2 - 50 - 61,8.
  • Commentaire sur le graphique avec les niveaux Array Open, Array Close et 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);
     }

Dans le cas d'une baisse (CloseCandle est inférieur à openCandle), il faut que les étapes suivantes se produisent :

  • Suppression de l'objet FIBO précédemment dessiné en utilisant ObjectDelete.
  • Création d'un nouvel objet FIBO en commençant par la valeur la plus élevée jusqu'à la valeur la plus basse du tableau à l'aide de la fonction ObjectCreate.
  • Mise à jour de la couleur de l'objet FIBO en rouge à l'aide de ObjectSetInteger et d'une boucle for pour poursuivre la mise à jour selon le cas.
  • Définition de la fourchette de prix en obtenant la différence entre le prix le plus bas et le prix le plus élevé.
  • Définition des niveaux de FIBO, 23,6 - 38,2 - 50 - 61,8.
  • Commentaire sur le graphique avec les niveaux Array Open, Array Close et 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);
     }

Le code complet se trouve ci-dessous :

//+------------------------------------------------------------------+
//|                                         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);
     }
  }
//+------------------------------------------------------------------+

Après avoir compilé et exécuté ce code, nous pouvons voir les signaux suivants de l'EA. Voici quelques exemples de signaux issus de mes tests.

Dans le cas où le tableau est haussier :

Système de Fibo Simple 2 - haussier

Comme nous pouvons le voir, nous avons un objet FIBO vert sur le graphique et un commentaire en haut à gauche du graphique avec les valeurs suivantes :

  • Array open ==> pour le prix d’ouverture de la première bougie du tableau.
  • Array close ==> pour le prix de clôture de la dernière bougie du tableau.
  • Niveaux FIBO 0, 23,6, 38,2, 50, 61,8, 100.

Dans le cas où le tableau est baissier :

Système de Fibo Simple 2 - baissier

Comme nous pouvons le voir, nous avons un objet FIBO rouge sur le graphique et un commentaire en haut à gauche du graphique avec les valeurs suivantes :

  • Array open ==> pour le prix d’ouverture de la première bougie du tableau.
  • Array close ==> pour le prix de clôture de la dernière bougie du tableau.
  • Niveaux FIBO 0, 23,6, 38,2, 50, 61,8, 100.

Signaux FIBO 2 :

Nous allons maintenant créer, sur la base de la deuxième approche, un système de trading qui renvoie des signaux d'achat et de vente en fonction du niveau de FIBO saisi par l'utilisateur. Voici le code complet permettant de créer ce système de trading simple :

//+------------------------------------------------------------------+
//|                                               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);
     }
  }
//+------------------------------------------------------------------+

Voici les différences dans ce code :

Ajout d'une propriété avec #property script_show_inputs, qui affiche une fenêtre avec les propriétés, et utilisation d’une variable d'entrée de type double fibRetracLvl avec une valeur par défaut de 38,2 :

#property script_show_inputs
input double fibRetracLvl = 38.2;

Définition du niveau d'entrée en fonction de la saisie de l'utilisateur dans le cas d'une hausse.

double entryLvl = NormalizeDouble(PriceFibLvl0 - pRange * fibRetracLvl/100,_Digits);

Définition du niveau d'entrée en fonction de la saisie de l'utilisateur dans le cas d'une tendance baissière.

double entryLvl = NormalizeDouble(PriceFibLvl0 + pRange * fibRetracLvl/100,_Digits);

Commentaire basé sur le cas haussier.

      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Buy Entry Price: ",entryLvl);

Commentaire basé sur le cas baissier.

      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Sell Entry Price: ",entryLvl);

Après avoir compilé et exécuté ce code, nous obtenons nos signaux comme dans les exemples suivants de tableaux haussiers et baissiers issus des tests.

Le tableau est haussier :

Signaux de Fibo 2 - haussier

Comme nous pouvons le voir, nous avons un objet FIBO vert dessiné de la valeur la plus basse à la valeur la plus haute du tableau et les valeurs suivantes en tant que commentaire sur le graphique :

  • Array open ==> la même valeur que le prix d’ouverture de la première bougie du tableau.
  • Array close ==> la même valeur que le prix de clôture de la dernière bougie dans le tableau.
  • Prix d'entrée d'achat ==> la même valeur que le niveau 38.2 FIBO.

Le tableau est baissier :

Signaux de Fibo 2 - baissier

Comme nous pouvons le voir, nous avons un objet FIBO rouge dessiné de la valeur la plus élevée à la valeur la plus basse du tableau et les valeurs suivantes en tant que commentaire sur le graphique :

  • Array open ==> la même valeur que le prix d’ouverture de la première bougie du tableau.
  • Array close ==> la même valeur que le prix de clôture de la dernière bougie dans le tableau.
  • Prix d'entrée de vente ==> la même valeur que le niveau 38.2 FIBO.


Conclusion

Vous avez maintenant appris comment créer un système simple de trading basé sur Fibonacci en MQL5 et à utiliser dans le terminal de trading MetaTrader 5. Vous avez vu également l'outil technique de Fibonacci en détail grâce à la définition de Fibonacci et vous avez appris comment nous pouvons l'utiliser après l'avoir inséré dans MetaTrader 5.

Nous avons également partagé ici 2 approches pour créer les niveaux de Fibonacci : l'une en utilisant les données quotidiennes et l'autre en utilisant un tableau de bougies spécifiques sur n'importe quelle période pour retourner les niveaux de Fibonacci et obtenir des niveaux d'entrée d'achat ou de vente basés sur ces niveaux. Je vous rappelle à nouveau qu'il faut combiner cet outil avec d'autres outils techniques pour obtenir de meilleurs résultats, et que vous devez tester les stratégies ou concepts mentionnés avant de les utiliser sur votre compte réel pour vous assurer qu'ils seront rentables pour votre trading. Rien ne convient à tout le monde. L'objectif principal ici est uniquement éducatif et vous pouvez trouver quelques raffinements ou optimisations pour les stratégies mentionnées.

J'espère que cet article vous sera utile et qu'il vous permettra d'apprendre quelque chose de nouveau ou d'ouvrir les yeux sur de nouvelles idées susceptibles d'améliorer vos résultats de trading. Si vous souhaitez lire d'autres articles similaires sur la conception de systèmes de trading basés sur les indicateurs et outils techniques les plus populaires, vous pouvez lire mes autres articles dans cette série car nous partageons la plupart des indicateurs populaires comme les moyennes mobiles, le MACD, les bandes de Bollinger, le Stochastique...etc. et j'espère que vous les trouverez également utiles.

Traduit de l’anglais par MetaQuotes Ltd.
Article original : https://www.mql5.com/en/articles/12301

Avertissement: Tous les droits sur ces documents sont réservés par MetaQuotes Ltd. La copie ou la réimpression de ces documents, en tout ou en partie, est interdite.

Autres articles par cet auteur

Aller à la discussion
Comment utiliser MQL5 pour détecter des figures de chandeliers ? Comment utiliser MQL5 pour détecter des figures de chandeliers ?
Un nouvel article pour apprendre à détecter automatiquement des figures de chandeliers sur les prix avec MQL5.
Figures et exemples (partie I) : Multiple Top, ou Hauts Multiples Figures et exemples (partie I) : Multiple Top, ou Hauts Multiples
Cet article est le premier d'une série consacrée aux figures (ou motifs, modèles, patterns) d'inversion dans le cadre du trading algorithmique. Nous commencerons par la famille de modèles la plus intéressante, qui trouve son origine dans les modèles Double Top et Double Bottom.
Attentes morales dans le trading Attentes morales dans le trading
Cet article est consacré aux attentes morales. Nous examinerons plusieurs exemples de son utilisation dans le trading, ainsi que les résultats qui peuvent être obtenus grâce à cela.
Swaps (Partie 1) : Verrouillage et Positions Synthétiques Swaps (Partie 1) : Verrouillage et Positions Synthétiques
Dans cet article, j'essaierai d'élargir le concept classique des méthodes de trading par swap. J'expliquerai pourquoi je suis arrivé à la conclusion que ce concept mérite une attention particulière et qu'il est absolument recommandé de l'étudier.