Comment créer un indicateur Canal de Donchian (Donchian Channel) personnalisé avec MQL5

Introduction

Dans cet article, nous parlerons d'un concept très important dans le trading, à savoir l'identification des tendances, et nous découvrirons un outil technique qui peut s'avérer utile à cet égard, à savoir l'indicateur du Canal de Donchian. Cet indicateur est un suiveur de tendance comme nous allons le voir.

Nous couvrirons tous ces aspects à travers les thèmes suivants :

• Définition du Canal de Donchian
• Canal Donchian personnalisé
• EA Canal de Donchian
• Conclusion

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 du Canal de Donchian

Dans cette partie, nous allons identifier l'indicateur du Canal de Donchian et comprendre le concept principal qui le sous-tend pour l'utiliser efficacement. Le Canal de Donchian a été développé par le trader Richard Donchian. Son principal objectif est d'identifier la tendance, ce qui signifie qu'il s'agit d'un indicateur de suivi de tendance, avec du retard, puisqu'il suit les directions de la tendance et les mouvements de prix. La ligne supérieure du canal représente le prix le plus élevé enregistré au cours d'une période donnée, la ligne inférieure du canal représente le prix le plus bas au cours d'une période donnée et la ligne médiane représente la moitié de la distance entre la ligne supérieure et la ligne inférieure.

Le graphique suivant est un exemple de graphique du Canal de Donchian :

Comme nous pouvons le voir dans le graphique précédent, il y a une ligne au-dessus des prix, une autre en dessous, et une troisième entre les deux. L'indicateur contient ou entoure les prix par des lignes supérieure et inférieure, en plus d'une autre ligne médiane qui peut également être utile. La forme de l'indicateur peut être utile dans vos stratégies de trading : identification des tendances, des ruptures et des niveaux de support et de résistance par exemple.

Le concept principal de l'utilisation de cet indicateur est d'observer les hauts et les bas des prix sur une période spécifique afin d'identifier les tendances ou la direction pour laquelle nous pouvons être biaisés. Si le prix est supérieur au plus haut d'une période donnée, cela indique qu'il y a une puissance haussière et cela peut être un signal d'achat. Si le prix est inférieur au plus bas d'une période donnée, cela indique une tendance baissière et peut constituer un signal de vente. Ainsi, une fois que nous avons spécifié une période de temps spécifique et déterminé les prix les plus hauts et les plus bas, nous les observons jusqu'à ce que les prix évoluent dans une direction spécifique vers le haut ou vers le bas. Le signal ici est la rupture du plus haut ou du plus bas déterminé.

Cet indicateur peut être utilisé pour déterminer et améliorer les niveaux de stop-loss et de take-profit. Les niveaux de l'indicateur sont très clairs et représentent des niveaux importants surtout si nous utilisons des paramètres corrects. Ainsi, par exemple, le bas du canal peut être utilisé comme niveau de stop-loss d'une position d'achat ou comme niveau de take-profit d'une position courte. Et le sommet du canal peut être utilisé comme stop-loss d'une position courte ou comme objectif de profit d'une position d'achat.

Comme nous l’avons mentionné, voici la manière de calculer cet indicateur :

• Channel High (CH) = Le plus haut des N dernières périodes
• Channel Low (CL) = Le plus bas des N dernières périodes
• Ligne médiane (ML) = (CH + CL) / 2

Il faut donc déterminer la période de temps souhaitée pour détecter la direction pendant cette période, détecter le prix le plus élevé et le prix le plus bas, tracer une ligne à côté d'eux pour observation, et obtenir la ligne médiane en calculant la demi-distance entre les niveaux les plus élevés et les plus bas. Il est bon de mentionner également qu'il existe une différence entre les Canaux de Donchian et les Bandes de Bollinger, parce que les Canaux de Donchian tracent le plus haut et le plus bas pendant une période de temps spécifique, alors que les Bandes de Bollinger tracent une moyenne d'une période de temps après avoir ajouté et soustrait deux écarts-types. Si vous avez besoin de plus d'informations, vous pouvez lire mon article précédent sur les Bandes de Bollinger pour savoir comment créer un système de trading basé sur ces bandes.

Comme nous l'avons identifié, le concept de cet indicateur est très important, en particulier pour les traders qui suivent les tendances, car il aide à identifier clairement les tendances et les directions. Cela permet de tester différentes stratégies basées sur cet indicateur, qui peut être un très bon outil dans notre système de trading. Il est très important de noter qu'il est préférable d'utiliser cet indicateur avec d'autres indicateurs techniques significatifs afin d'obtenir de meilleures informations et de meilleurs résultats.

Canal Donchian personnalisé

Dans cette rubrique, je vais partager une méthode qui peut être utilisée pour créer un indicateur Canal de Donchian personnalisé en MQL5. Nous allons créer l'indicateur sous la forme de 3 lignes : une ligne supérieure, une ligne inférieure et une ligne médiane, comme nous le verrons dans les étapes suivantes. 

Créez des paramètres supplémentaires avec les identifiants suivants :

• indicator_chart_window : pour afficher l'indicateur dans la fenêtre graphique.
• indicator_buffers : pour déterminer le nombre de buffers de calcul de l'indicateur. La valeur sera 3.
• indicator_plots : pour déterminer le nombre de séries graphiques dans l'indicateur.  La valeur sera 3.

#property indicator_chart_window
#property indicator_buffers 3
#property indicator_plots 3

Créez 2 entrées : l'une pour la période et l'autre pour la couleur des lignes de l'indicateur, comme suit :

• Créez une variable entière « indPeriod » et attribuez 20 comme valeur par défaut (mais elle peut être différente en fonction des données fournies par l'utilisateur).
• Une variable de type color « indColor » et assignez la couleur bleue comme valeur par défaut (mais elle peut également être différente en fonction de l'entrée de l'utilisateur).

input int indPeriod=20; //Period
input color indColor=clrBlue; //Color

Créez des variables globales comme suit :

• des tableaux de type double « upperBuff », « lowerBuff », « middleBuff »
• des variables de type double « upperLine », « lowerLine », « middleLine »
• des variables de type entier « start » et « bar »

double upperBuff[];
double lowerBuff[];
double middleBuff[];
double upperLine,lowerLine,middleLine;
int start, bar;

Créez une fonction personnalisée de l'indicateur en utilisant void pour ne rien renvoyer, et créez une variable indInit avec 3 paramètres : index, buffer comme tableau dynamique et label comme chaîne de caractères pour chaque ligne de l'indicateur. Dans le corps de la fonction, nous ferons ce qui suit :

• Utilisation de la fonction SetIndexBuffer qui relie un indicateur spécifié au tableau dynamique unidimensionnel. Ses paramètres sont les suivants :
• index : pour spécifier le numéro de la mémoire tampon de l'indicateur. Nous utiliserons la variable index.
• buffer[] : pour déterminer le tableau dynamique créé, qui est buffer[].
• data_type : pour déterminer les données que nous devons stocker, nous utiliserons la valeur par défaut INDICATOR_DATA.
• En utilisant 5 fois la fonction PlotIndexSetInteger avec des paramètres prop_id et prop_value différents, comme nous le verrons dans le code, cette fonction définit la valeur de la ligne d'indicateur correspondante. La propriété de l'indicateur doit être un nombre entier. Tous ses paramètres sont les suivants :
• plot_index : pour déterminer l'index de la représentation graphique. Nous utiliserons la variable index.
• prop_id : pour déterminer la valeur de l'identifiant de la propriété, qui est l'un des valeurs de l’énumération ENUM_PLOT_PROPERT_INTEGER.
• prop_value : pour déterminer la valeur de la propriété identifiée par prop_id.
• Utilisation de la fonction PlotIndexSetString qui définit la valeur de l'indicateur de la propriété string correspondante. Ses paramètres sont les mêmes que ceux de la fonction PlotIndexSetInteger, mais la propriété de l'indicateur doit être une chaîne de caractères.
• Utilisation de la fonction PlotIndexSetDouble pour définir la valeur de l'indicateur de la propriété double correspondante, les paramètres sont les mêmes, mais la propriété de l'indicateur doit être de type double.

void indInit(int index, double &buffer[],string label)
  {
   SetIndexBuffer(index,buffer,INDICATOR_DATA);
   PlotIndexSetInteger(index,PLOT_DRAW_TYPE,DRAW_LINE);
   PlotIndexSetInteger(index,PLOT_LINE_WIDTH,2);
   PlotIndexSetInteger(index,PLOT_DRAW_BEGIN,indPeriod-1);
   PlotIndexSetInteger(index,PLOT_SHIFT,1);
   PlotIndexSetInteger(index,PLOT_LINE_COLOR,indColor);
   PlotIndexSetString(index,PLOT_LABEL,label);
   PlotIndexSetDouble(index,PLOT_EMPTY_VALUE,EMPTY_VALUE);
  }

Ensuite, dans le corps de OnInit(), nous utiliserons notre fonction personnalisée de l'indicateur 3 fois pour les 3 lignes de l'indicateur comme suit :

   indInit(0,upperBuff,"Donchian Channel");
   indInit(1,lowerBuff,"Donchian Channel");
   indInit(2,middleBuff,"Middle Donchian");

La fonction IndicatorSetString permet de définir le texte de l'étiquette de l'indicateur.

IndicatorSetString(INDICATOR_SHORTNAME,"Donchian ("+IntegerToString(indPeriod)+")");

Dans la partie OnCalculate, nous effectuerons les étapes suivantes pour calculer l'indicateur :

Vérifier si rates_total est inférieur à la valeur period+1 saisie par l'utilisateur, si c'est le cas, le programme doit renvoyer 0.

   if(rates_total<indPeriod+1)
     {
      return 0;
     }

Attribuer une valeur à la variable start en utilisant l'opérateur ternaire ? : — si start=prev_calculated==0 est vrai, l'opérateur sera défini par indPeriod, et si c'est faux, l'opérateur sera défini par prev_calculated-1.

start=prev_calculated==0? indPeriod: prev_calculated-1;

En utilisant la fonction for pour créer une boucle afin de calculer l'indicateur, l'expression 1 sera « bar=start », l'expression 2 sera « bar < rate_total », et l'expression 3 sera « bar ++ » pour incrémenter la barre d'une unité. L'opérateur de la boucle for sera comme suit :

• Calcul de la ligne supérieure en détectant la valeur maximale de high à l'aide de la fonction ArrayMaximum qui recherche la valeur la plus élevée dans le tableau.
• Calcul de la ligne inférieure en détectant la valeur minimale de low à l'aide de la fonction ArrayMinimum qui recherche la valeur la plus basse dans le tableau.
• Calcul de la ligne médiane en soustrayant le résultat de la ligne supérieure et de la ligne inférieure par 2
• Attribution de la valeur de upperBuff[bar], lowerBuff[bar] et middleBuff[bar}

   for(bar=start;bar<rates_total;bar++)
   {
      upperLine=high[ArrayMaximum(high,bar-indPeriod+1,indPeriod)];
      lowerLine=low[ArrayMinimum(low,bar-indPeriod+1,indPeriod)];
      middleLine=(upperLine+lowerLine)/2;
      
      upperBuff[bar]=upperLine-(upperLine-lowerLine);
      lowerBuff[bar]=lowerLine+(upperLine-lowerLine);
      middleBuff[bar]=middleLine;

   }

Voici le code complet en un seul bloc :

#property indicator_chart_window
#property indicator_buffers 3
#property indicator_plots 3
input int indPeriod=20; //Period
input color indColor=clrBlue; //Color
double upperBuff[];
double lowerBuff[];
double middleBuff[];
double upperLine,lowerLine,middleLine;
int start, bar;
void indInit(int index, double &buffer[],string label)
  {
   SetIndexBuffer(index,buffer,INDICATOR_DATA);
   PlotIndexSetInteger(index,PLOT_DRAW_TYPE,DRAW_LINE);
   PlotIndexSetInteger(index,PLOT_LINE_WIDTH,2);
   PlotIndexSetInteger(index,PLOT_DRAW_BEGIN,indPeriod-1);
   PlotIndexSetInteger(index,PLOT_SHIFT,1);
   PlotIndexSetInteger(index,PLOT_LINE_COLOR,indColor);
   PlotIndexSetString(index,PLOT_LABEL,label);
   PlotIndexSetDouble(index,PLOT_EMPTY_VALUE,EMPTY_VALUE);
  }
int OnInit()
  {
   indInit(0,upperBuff,"Donchian Channel");
   indInit(1,lowerBuff,"Donchian Channel");
   indInit(2,middleBuff,"Middle Donchian");
   IndicatorSetString(INDICATOR_SHORTNAME,"Donchian ("+IntegerToString(indPeriod)+")");

   return(INIT_SUCCEEDED);
  }
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
   if(rates_total<indPeriod+1)
     {
      return 0;
     }
   start=prev_calculated==0? indPeriod: prev_calculated-1;
   for(bar=start;bar<rates_total;bar++)
   {
      upperLine=high[ArrayMaximum(high,bar-indPeriod+1,indPeriod)];
      lowerLine=low[ArrayMinimum(low,bar-indPeriod+1,indPeriod)];
      middleLine=(upperLine+lowerLine)/2;
      
      upperBuff[bar]=upperLine-(upperLine-lowerLine);
      lowerBuff[bar]=lowerLine+(upperLine-lowerLine);
      middleBuff[bar]=middleLine;
   }
   return(rates_total);
  }

Après avoir compilé ce code (il doit être compilé sans erreurs ou avertissements), l'indicateur sera visible dans la fenêtre du Navigateur dans le terminal de trading, dans le dossier Indicators. En l'exécutant, la fenêtre suivante est ouverte et vous pouvez saisir les mêmes éléments que dans la capture suivante :

Comme nous pouvons le voir dans l'image précédente, nous avons 2 entrées :

• Period : pour déterminer la durée à utiliser dans le calcul de l'indicateur. La valeur par défaut est 20, mais elle peut être mise à jour par l'utilisateur.
• Color : pour déterminer la couleur des lignes de l'indicateur. Sa valeur par défaut est le bleu, mais elle peut également être mise à jour.

Après avoir déterminé ces deux entrées selon nos préférences et avoir appuyé sur OK, nous pouvons trouver l'indicateur attaché au graphique comme suit :

Comme nous pouvons le voir dans le graphique précédent, nous avons 3 lignes de l'indicateur : 2 lignes entourant le prix depuis le haut et le bas formant un canal et une ligne centrale représentant la demi-distance du canal.

EA Canal de Donchian

Dans cette partie, nous devons utiliser cet indicateur Donchian Channel personnalisé dans un système de trading en créant un Expert Advisor qui peut être utilisé pour générer des signaux basés sur le mouvement ou le comportement de l'indicateur. Nous pouvons le faire en utilisant 2 méthodes différentes : la première consiste à écrire le code du concept de l'indicateur dans l'EA et la seconde consiste à utiliser la fonction iCustom pour attacher l'indicateur que vous avez créé à l'EA. Ici, nous allons concevoir des systèmes très simples, juste pour comprendre le concept et pour voir comment améliorer ces systèmes avec la deuxième méthode, comme nous avons appris à le faire pour créer l'indicateur.

Les points suivants concernent ces EA :

Canal de Donchian EA Simple

Nous allons commencer à créer le premier système qui peut être utilisé pour renvoyer un commentaire sur le graphique avec les valeurs de l'indicateur (Channel High, Channel Middle, et Channel Low). Nous avons donc besoin que le programme vérifie et contrôle en permanence ces valeurs et les affiche sur le graphique sous forme de commentaire.

Les étapes suivantes permettent de créer ce type d'EA :

Créez une variable d'entrée de l'indicateur période avec une valeur par défaut (20) — mais l'utilisateur peut la modifier depuis l’écran de paramétrage des entrées de l'EA. 

input int indPeriod=20; //Period

Créez une variable globale de type entier donChianChannel.

int donchianChannel;

Dans la partie OnInit(), nous mettrons à jour donchianChannel en lui assignant la fonction iCustom qui renvoie le handle de l'indicateur Donchian Channel personnalisé créé. Ses paramètres sont :

• symbol : pour spécifier le nom du symbole, nous utiliserons _Symbol pour le symbole actuel.
• period : pour spécifier la période, nous utiliserons le PERIOD_CURRENT qui applique la période actuelle.
• name : pour spécifier le nom de la chaîne de caractères de l'indicateur et son chemin d'accès.
• Ensuite, spécifiez les données de l'indicateur, c'est-à-dire la période de l'indicateur.

donchianChannel=iCustom(_Symbol,PERIOD_CURRENT,"My Files\\Donchian_Channel\\Donchian_Channel",indPeriod);

Dans la partie OnDeinit(), nous utiliserons la fonction Print pour renvoyer un message dans l’Expert Advisor avec "Donchian Channel EA Removed" lors de la suppression de l'EA.

Print("Donchian Channel EA Removed");

Dans la partie OnTick(), nous allons créer 3 tableaux : channelBuff, channelBuff1, middleBuff

double channelBuff[],channelBuff1[], middleBuff[];

Utilisez la fonction CopyBuffer pour obtenir les données de chaque tampon de l'indicateur personnalisé Donchian Channel. Ses paramètres sont :

• indicator_handle : pour spécifier le handle de l'indicateur, nous utiliserons le handle donchianChannel créé pour les 3 buffers.
• buffer_num : pour spécifier le numéro du tampon, nous utiliserons 0 pour channelBuff, 1 pour channelBuff1, et 2 pour middleBuff.
• start_pos : pour spécifier la position du premier élément à copier, nous utiliserons 0 pour les 3 buffers.
• count : pour spécifier le nombre de données à copier, nous utiliserons 3 pour les trois buffers.
• buffer[] : pour spécifier le tableau cible à copier, nous spécifierons les 3 buffers (channelBuff, channelBuff1, et middleBuff).

   CopyBuffer(donchianChannel,0,0,3,channelBuff);
   CopyBuffer(donchianChannel,1,0,3,channelBuff1);
   CopyBuffer(donchianChannel,2,0,3,middleBuff);

Définissez les valeurs actuelles de chaque ligne après avoir créé une variable double pour tout le monde :

   double channelHigh=channelBuff1[0];
   double channelMiddle=middleBuff[0];
   double channelLow=channelBuff[0];

Utilisez la fonction Comment pour afficher un commentaire sur le graphique avec 3 valeurs, chacune sur une ligne distincte :

Comment("Channel High: ",channelHigh,"\nChannel Middle: ",channelMiddle,"\nChannel Low: ",channelLow);

Voici le code complet en un seul bloc

input int indPeriod=20; //Period
int donchianChannel;
int OnInit()
  {
   donchianChannel=iCustom(_Symbol,PERIOD_CURRENT,"My Files\\Donchian_Channel\\Donchian_Channel",indPeriod);
   return(INIT_SUCCEEDED);
  }
void OnDeinit(const int reason)
  {
   Print("Donchian Channel EA Removed");
  }
void OnTick()
  {
   double channelBuff[],channelBuff1[], middleBuff[];
   CopyBuffer(donchianChannel,0,0,3,channelBuff);
   CopyBuffer(donchianChannel,1,0,3,channelBuff1);
   CopyBuffer(donchianChannel,2,0,3,middleBuff);
   double channelHigh=channelBuff1[0];
   double channelMiddle=middleBuff[0];
   double channelLow=channelBuff[0];
   Comment("Channel High: ",channelHigh,"\nChannel Middle: ",channelMiddle,"\nChannel Low: ",channelLow);
  }

Après avoir compilé ce code sans erreur ni avertissement, il sera visible dans la fenêtre du Navigateur sous le dossier Expert Advisors. En l'exécutant sur le graphique désiré, la fenêtre de paramétrage des entrées est affichée comme suit :

Après l'exécution, l'EA est attaché au graphique en plus des niveaux de l'indicateur du Canal de Donchian. Les commentaires affichés sont identiques à ce qui suit :

Comme nous pouvons le voir, le signal désiré est bien affiché sur le graphique : les 3 valeurs de l'indicateur (Channel High, Channel Middle, et Channel Low), chaque valeur étant sur une ligne séparée.

Pour confirmation, nous pouvons comparer les valeurs des signaux de l'EA et les valeurs de l'indicateur. L'indicateur est inséré et ses valeurs dans la fenêtre de données sont les mêmes que celles des signaux de l'EA, comme le montre l'image suivante :

Nous voulons maintenant améliorer cet EA pour trouver des signaux basés sur les mouvements et les niveaux de l'indicateur. Nous allons le faire à travers les systèmes de trading (EA) suivants, en essayant de mettre en place des conditions basées sur le concept de l'indicateur pour recevoir des signaux d'achat et de vente.

Donchian Channel Breakout EA

Dans cette version de l'EA, nous avons besoin que le programme vérifie continuellement les 3 valeurs des indicateurs. Si le prix (ask) casse le haut du canal, nous devons recevoir un signal d'achat sous forme de commentaire sur le graphique. Dans l'autre scénario, si le prix (bid) casse le bas du canal, nous devons recevoir un signal de vente sous forme de commentaire sur le graphique. S'il y a autre chose, nous ne devons rien recevoir.

Voici le code complet pour créer ce type de système de trading (EA) :

input int indPeriod=20; //Period
int donchianChannel;
int OnInit()
  {
   donchianChannel=iCustom(_Symbol,PERIOD_CURRENT,"My Files\\Donchian_Channel\\Donchian_Channel",indPeriod);
   return(INIT_SUCCEEDED);
  }
void OnDeinit(const int reason)
  {
   Print("Donchian Channel EA Removed");
  }
void OnTick()
  {
   double channelBuff[],channelBuff1[], middleBuff[];
   CopyBuffer(donchianChannel,0,0,3,channelBuff);
   CopyBuffer(donchianChannel,1,0,3,channelBuff1);
   CopyBuffer(donchianChannel,2,0,3,middleBuff);
   double channelHigh=channelBuff1[0];
   double channelMiddle=middleBuff[0];
   double channelLow=channelBuff[0];
   double ask=SymbolInfoDouble(_Symbol,SYMBOL_ASK);
   double bid=SymbolInfoDouble(_Symbol,SYMBOL_BID);
   if(ask>channelHigh)
     {
      Comment("Buy Signal");
     }
     else if(bid<channelLow)
     {
      Comment("Sell Signal");
     }
     else Comment(" ");
  }

Les différences dans ce code sont les suivantes :

Définition de la demande et de l'offre en utilisant la fonction SymbolInfoDouble pour renvoyer les valeurs de la propriété (ask, bid) après avoir créé des variables doubles pour celles-ci.

   double ask=SymbolInfoDouble(_Symbol,SYMBOL_ASK);
   double bid=SymbolInfoDouble(_Symbol,SYMBOL_BID);

Conditions de la stratégie :

En cas d'achat

Nous avons besoin que le programme vérifie le prix ask et le haut du canal pour déterminer leurs positions. Si le prix ask est supérieur au sommet du canal, il s'agit d'une condition d'achat. L'EA doit renvoyer un signal d'achat sous forme de commentaire sur le graphique une fois que cette condition est remplie.

   if(ask>channelHigh)
     {
      Comment("Buy Signal");
     }

En cas de vente

Nous avons besoin que le programme vérifie l'offre et le bas du canal pour déterminer leurs positions. Si le prix d'achat est inférieur au niveau bas du canal, il s'agit d'une condition de vente. L'EA doit renvoyer un signal de vente sous forme de commentaire sur le graphique une fois que cette condition est remplie.

     else if(bid<channelLow)
     {
      Comment("Sell Signal");
     }

Si rien ne se passe

L'EA ne doit rien renvoyer s'il y a quelque chose en dehors des conditions d'achat ou de vente.

else Comment(" ");

Après avoir compilé ce code sans erreurs ni avertissements, nous pouvons l'exécuter sur le graphique en le faisant glisser et en le déposant sur le graphique souhaité pour obtenir des signaux basés sur la stratégie, comme dans les exemples suivants :

En cas de signal d'achat

Comme nous pouvons le voir dans le coin supérieur gauche du graphique précédent, nous avons un signal d'achat après avoir cassé le haut du canal à la hausse.

En cas de signal de vente

Comme nous pouvons le voir dans le coin supérieur gauche du graphique précédent, nous avons un signal de vente après avoir cassé le creux du canal à la baisse.

Si rien ne se passe

Comme nous pouvons le voir, il n'y a pas de signal car le prix se déplace à l'intérieur du canal, ce qui signifie que le prix est en dessous du haut du canal et au-dessus du bas du canal.

Canal de Donchian et rupture de Moyenne (MA Breakout)

Maintenant, nous devons améliorer un peu l'EA en filtrant les signaux par l'ajout d’une moyenne mobile aux conditions de la stratégie. C’est ce que nous allons faire dans ce système de trading. Nous devons donc recevoir un signal d'achat lorsque le prix Ask dépasse le haut du canal et si la moyenne mobile exponentielle (EMA) à 200 périodes est inférieure au prix Ask. Dans le cas d'un signal de vente, nous devons nous assurer que le prix Bid se situe en dessous du bas du canal et que, dans le même temps, l'EMA à 200 périodes se situe au-dessus du prix Bid. Dans tous les autres cas, nous ne devons rien recevoir.

Vous trouverez ci-dessous le code complet pour créer ce système de trading :

input int indPeriod=20; //Period
input int maPeriod=200; //Moving Average Period
int donchianChannel;
int EMA;
double emaArray[];
int OnInit()
  {
   donchianChannel=iCustom(_Symbol,PERIOD_CURRENT,"My Files\\Donchian_Channel\\Donchian_Channel",indPeriod);
   EMA = iMA(_Symbol,_Period,maPeriod,0,MODE_EMA,PRICE_CLOSE);
   return(INIT_SUCCEEDED);
  }
void OnDeinit(const int reason)
  {
   Print("Donchian Channel EA Removed");
  }
void OnTick()
  {
   double channelBuff[],channelBuff1[], middleBuff[];
   CopyBuffer(donchianChannel,0,0,3,channelBuff);
   CopyBuffer(donchianChannel,1,0,3,channelBuff1);
   CopyBuffer(donchianChannel,2,0,3,middleBuff);
   ArraySetAsSeries(emaArray,true);
   CopyBuffer(EMA,0,0,3,emaArray);
   double channelHigh=channelBuff1[0];
   double channelMiddle=middleBuff[0];
   double channelLow=channelBuff[0];
   double EMAValue=NormalizeDouble(emaArray[0],_Digits);
   double ask=SymbolInfoDouble(_Symbol,SYMBOL_ASK);
   double bid=SymbolInfoDouble(_Symbol,SYMBOL_BID);
   if(ask>channelHigh&&ask>EMAValue)
     {
      Comment("Buy Signal","\nAsk above Channel High","\nAsk above (",maPeriod,") EMA");
     }
     else if(bid<channelLow&&bid<EMAValue)
     {
      Comment("Sell Signal","\nBid below Channel Low","\nBid Below (",maPeriod,") EMA");
     }
     else Comment(" ");
  }

Les différences dans ce code sont les suivantes :

Créez une autre variable maPeriod de type entier avec une valeur par défaut (200), que l'utilisateur peut mettre à jour selon ses préférences :

input int maPeriod=200; //Moving Average Period

Créez une variable globale entière EMA :

int EMA;

Créez un tableau emaArray[] :

double emaArray[];

Mettez à jour la variable EMA en utilisant la fonction iMA pour renvoyer le handle de l'indicateur de moyenne mobile, dont les paramètres sont :

• symbol : pour spécifier le symbole, nous utiliserons _Symbol pour l'appliquer au symbole actuel.
• period : pour spécifier la période, nous utiliserons _period pour utiliser la période actuelle.
• ma_period : pour spécifier la période de calcul de la moyenne, nous utiliserons les données de l'utilisateur (maPeriod).
• ma_shift : pour spécifier s'il y a un décalage, nous utiliserons 0 car nous n'avons pas besoin de décalage.
• ma_method : pour spécifier le type de lissage de la moyenne mobile, nous utiliserons MODE_EMA car nous avons besoin de la moyenne mobile exponentielle.
• applied_price : pour spécifier le type de prix, nous utiliserons PRICE_CLOSE.

EMA = iMA(_Symbol,_Period,maPeriod,0,MODE_EMA,PRICE_CLOSE);

Puis nous utilisons la fonction ArraySetAsSeries pour définir le flag AS_SERIES, ses paramètres sont les suivants :

• array[] : pour spécifier le tableau, nous utiliserons emaArray.
• flag : pour spécifier le sens d'indexation du tableau, nous utiliserons true.

ArraySetAsSeries(emaArray,true);

Utilisez la fonction CopyBuffer pour récupérer les données de la mémoire tampon de la moyenne mobile :

CopyBuffer(EMA,0,0,3,emaArray);

Définissez la valeur de l’EMA et normalisez-la :

double EMAValue=NormalizeDouble(emaArray[0],_Digits);

Conditions de la stratégie :

En cas d'achat

Si le prix > haut du canal, nous avons besoin du commentaire suivant sur le graphique :

• Buy signal (Signal d'achat)
• Ask above Channel High (Ask au-dessus de la limite supérieure du canal)
• Ask above (period) EMA (Ask au-dessus de l’EMA (période))

   if(ask>channelHigh&&ask>EMAValue)
     {
      Comment("Buy Signal","\nAsk above Channel High","\nAsk above (",maPeriod,") EMA");
     }

En cas de vente

Si le prix < bas du canal, nous avons besoin du commentaire suivant sur le graphique :

• Signal de vente
• Bid below Channel Low (Bid en-dessous de la limite inférieure du canal)
• Bid below (period) EMA (Bid en dessous de l’EMA (période))

     else if(bid<channelLow&&bid<EMAValue)
     {
      Comment("Sell Signal","\nBid below Channel Low","\nBid Below (",maPeriod,") EMA");
     }

En cas d'absence de signal

else Comment(" ");

Après avoir compilé ce code sans erreurs ni avertissements, nous pouvons trouver les signaux de ce système de trading comme suit :

En cas de signal d'achat

Comme nous pouvons le voir dans l'exemple précédent, nous avons un signal d'achat. Les conditions de ce signal sont que le prix est au-dessus du haut du canal et de l'EMA 200, comme le commentaire sur le graphique l’indique.

En cas de signal de vente

Comme nous pouvons le voir dans l'exemple précédent, nous avons un signal de vente. Les conditions de ce signal sont que le prix est en dessous du bas du canal et de l’EMA 200, comme le commentaire sur le graphique l’indique.

En cas d'absence de signal

Comme nous pouvons le voir, il n'y a pas de signal sur le graphique indiquant que les conditions ne sont pas remplies, parce que le prix est au-dessus du bas du canal ou en dessous du haut du canal, même si nous avons une configuration de vente parce que le prix est en dessous de l'EMA 200.

Conclusion

Comme nous l'avons appris à travers le sujet de cet article, nous avons identifié à quel point l'indicateur du canal de Donchian peut être un outil utile et précieux, surtout après l'avoir créé nous-mêmes en tant qu'indicateur personnalisé en plus de créer des systèmes de trading basés sur le concept de l'indicateur. Vous pouvez également créer un système de trading en utilisant la fonction iCustom pour trader, ou obtenir des signaux basés sur l'interprétation de l'indicateur. De plus, vous pouvez améliorer ce système de trading (EA) en fonction des résultats obtenus en ajoutant des conditions spécifiques et en utilisant un autre outil technique pour obtenir de meilleures informations.

J'espère que vous avez trouvé cet article utile pour votre parcours de trading en termes d'amélioration des résultats et des connaissances, ou qu'il vous aura donné de bonnes idées sur d’autres concepts connexes. Je n'oublierai pas non plus de vous confirmer que vous ne devez pas utiliser pas le contenu de cet article dans votre compte réel avant de l'avoir testé pour vous assurer qu'il vous sera profitable, car il n'y a pas d'outil adapté à tout le monde. 

Si vous avez trouvé cet article utile et que vous voulez lire mes autres articles, vous les trouverez à partir de ce lien de publication. Vous trouverez une série d'articles sur la façon de créer des systèmes de trading basés sur les indicateurs techniques les plus populaires et d'autres. J'espère que vous les trouverez utiles aussi.