Comment créer un indicateur personnalisé Heiken Ashi en utilisant MQL5
381
0
Introduction
Nous avons tous besoin de lire des graphiques et tout outil pouvant nous aider dans cette tâche sera le bienvenu. Parmi les outils qui peuvent être utiles à la lecture des graphiques, il y a les indicateurs qui sont calculés sur la base des prix, du volume, d'un autre indicateur technique ou d'une combinaison de ceux-ci, alors qu'il existe de nombreuses idées dans le monde du trading. Nous disposons d'un grand nombre d'indicateurs prêts à l'emploi intégrés dans le terminal de trading. Si nous avons besoin d'ajouter certaines caractéristiques pour les adapter à notre style de trading, nous pouvons rencontrer des difficultés parce qu'ils ne sont pas toujours modifiables et que nous ne trouvons pas toujours cet indicateur intégré dans le terminal de trading.
Dans cet article, je vais partager avec vous une méthode pour surmonter ce défi en bénéficiant de la fonction iCustom et en créant votre indicateur personnalisé selon vos préférences. Nous verrons également un exemple, nous créerons un indicateur technique Heiken Ashi personnalisé et nous utiliserons cet indicateur personnalisé dans des exemples de systèmes de trading. Nous aborderons ce sujet à travers les thèmes suivants :
- Indicateur personnalisé et définition du Heiken Ashi
- Indicateur Heiken Ashi simple
- EA basé sur l'indicateur Heiken Ashi personnalisé
- Système Heiken Ashi - EMA
- Conclusion
Après avoir compris ce que je partage dans les sujets précédents, vous devriez être en mesure de créer votre propre indicateur personnalisé qui vous aidera à lire les graphiques et que vous pourrez utiliser dans votre système de trading. Nous utiliserons MQL5 (MetaQuotes Language) qui est intégré à la plateforme de trading MetaTrader 5 pour écrire les codes des indicateurs qui seront créés et des EAs. Si vous ne savez pas comment les télécharger et les utiliser, vous pouvez lire la rubrique Écrire du code MQL5 dans MetaEditor d'un article précédent, cela peut être utile.
Indicateur personnalisé et définition du Heiken Ashi
Dans cette partie, nous allons découvrir plus en détail l'indicateur personnalisé et l'indicateur Heiken Ashi. Comme je l'ai mentionné dans l'introduction de la section précédente, l'indicateur personnalisé est l'outil d'analyse technique qui peut être créé par l'utilisateur à l'aide du langage de programmation MQL5. Il peut être utilisé dans MetaTrader 5 pour analyser et comprendre les mouvements du marché et peut aider à prendre des décisions d'investissement éclairées. Il existe de nombreux indicateurs techniques intégrés utiles. Mais nous avons parfois besoin d'analyser et de comprendre le comportement du marché sur la base de concepts mathématiques, statistiques ou techniques supplémentaires et spécifiques, et ces concepts n'existent pas dans l'indicateur intégré ou il n'y a pas d'indicateur capable de réaliser cette tâche. Dans ce cas, nous devons créer l'indicateur nous-mêmes - et c'est l'une des caractéristiques de la plateforme MetaTrader 5 qui nous aide à créer nos propres outils d'analyse ou de trading pour répondre à nos préférences et objectifs spécifiques.
Examinons les étapes nécessaires pour commencer à créer votre indicateur personnalisé :
Ouvrez l'IDE MetaEditor et choisissez le dossier 'Indicators' dans le Navigateur.
Cliquez sur le bouton "Nouveau" pour créer un nouveau programme, comme indiqué dans l'image ci-dessous.
Ensuite, la fenêtre suivante s'ouvre, dans laquelle vous devez choisir le type de programme à créer. Nous choisissons ici "Indicateur personnalisé» :
Après avoir cliqué sur "Suivant", la fenêtre suivante contenant les détails de l'indicateur s'ouvre. Spécifiez ici le nom de l'indicateur personnalisé et cliquez sur "Suivant".
Dans les fenêtres suivantes, nous déterminerons les détails de l'indicateur.
Après avoir défini les préférences et cliqué sur 'Suivant' puis sur 'Terminer', la fenêtre de l'éditeur s'ouvrira, dans laquelle nous écrirons le code de l'indicateur.
Nous allons voir comment développer un indicateur personnalisé en utilisant le Heiken Ashi comme exemple. Nous devons donc en apprendre davantage sur l'indicateur technique Heiken Ashi. Il s'agit d'une méthode graphique de type chandelier qui peut être utilisée pour présenter et analyser les mouvements du marché. Elle peut être utilisée en conjonction avec d'autres outils pour obtenir des informations efficaces et de meilleure qualité, sur la base desquelles nous pouvons prendre des décisions de trading informées après avoir trouvé de bonnes idées et opportunités de trading potentielles.
Les graphiques Heiken Ashi sont similaires aux graphiques techniques à bougies normaux, mais le calcul pour tracer ces bougies est différent. Il existe en effet 2 méthodes différentes. Comme nous le savons, le graphique en chandeliers normal calcule les prix sur la base des cours d'ouverture, de clôture et de clôture au cours d'une période donnée, mais le Heiken Ashi prend en considération les cours similaires précédents (cours d'ouverture, de clôture, de clôture et de clôture) lorsqu'il calcule ses chandelles.
Voici comment sont calculées les valeurs pertinentes pour le Heiken Ashi :
- Ouverture = (ouverture de la bougie précédente + fermeture de la bougie précédente) / 2
- Close = (open + close + high + low de la bougie actuelle) / 4
- Haut = la valeur la plus élevée du haut, de l'ouverture ou de la fermeture de la période en cours
- Bas = la valeur la plus basse du bas, de l'ouverture ou de la clôture de la période en cours
Selon sa formule de calcul, l'indicateur construit des chandeliers haussiers et baissiers, et les couleurs de ces chandeliers indiquent la direction du marché : si elle est haussière ou baissière. L'exemple ci-dessous montre les chandeliers japonais traditionnels et le Heiken Ashi, ce qui permet de voir la différence d'un point de vue visuel.
Dans la capture d'écran du graphique précédent, la partie supérieure montre les chandeliers traditionnels, tandis que dans la partie inférieure se trouve l'indicateur Heiken Ashi qui apparaît sous la forme de chandeliers bleus et rouges qui définissent la direction du marché. L'objectif de cet indicateur est de filtrer et d'éliminer une partie du bruit dans les mouvements du marché en lissant les données pour éviter les faux signaux.
Indicateur Heiken Ashi Simple
Dans cette partie, nous allons créer un indicateur Heiken Ashi Simple à utiliser dans MetaTrader 5. L'indicateur doit continuellement vérifier les prix (ouverture, haut, bas et clôture) et effectuer les calculs mathématiques pour générer les valeurs haOpen, haHigh, haLow et haClose. Sur la base des calculs, l'indicateur doit représenter les valeurs sur le graphique sous forme de chandeliers de différentes couleurs : bleu si la direction du chandelier est haussier et rouge si elle est baissière. Les chandeliers doivent être affichés dans une fenêtre séparée, sous le graphique traditionnel, en tant que sous-fenêtre.
Voyons toutes les étapes à suivre pour créer cet indicateur personnalisé.
Détermination des paramètres de l'indicateur en spécifiant des paramètres supplémentaires via les valeurs #property et identifier, comme suit :
- indicator_separate_window pour afficher l'indicateur dans une fenêtre séparée.
- indicator_buffers pour déterminer le nombre de buffers pour le calcul de l'indicateur.
- indicator_plots pour déterminer le nombre de séries graphiques dans l'indicateur. Les séries graphiques sont des styles de dessin qui peuvent être utilisés lors de la création d'un indicateur personnalisé.
- indicator_typeN pour déterminer le type de tracé graphique à partir des valeurs de ENUM_DRAW_TYPE, N est le nombre de séries graphiques que nous avons déterminé dans le dernier paramètre et commence à 1.
- indicator_colorN pour déterminer la couleur de N, N est également le nombre de séries graphiques que nous avons déterminé précédemment et il commence à 1.
- indicator_widthN pour déterminer l'épaisseur des séries N ou graphiques.
- indicator_labelN pour définir une étiquette pour N des séries graphiques déterminées.
#property indicator_separate_window #property indicator_buffers 5 #property indicator_plots 1 #property indicator_type1 DRAW_COLOR_CANDLES #property indicator_color1 clrBlue, clrRed #property indicator_width1 2 #property indicator_label1 "Heiken Ashi Open;Heiken Ashi High;Heiken Ashi Low;Heiken Ashi Close"
Créer 5 tableaux pour les 5 buffers de l'indicateur haOpen, haHigh, haLow, haClose et haColor, de type double.
double haOpen[]; double haHigh[]; double haLow[]; double haClose[]; double haColor[];
Dans la fonction OnInit(), cette fonction est utilisée pour initialiser un indicateur en cours d'exécution.
int OnInit()
Tri des buffers d'indicateurs avec un tableau dynamique unidimensionnel de type double en utilisant la fonction SetIndexBuffer. Ses paramètres sont :
- index : le numéro du buffer de l'indicateur à partir de 0. Ce numéro doit être inférieur à la valeur déclarée dans le paramètre indicator_buffers.
- buffer[] : le tableau déclaré dans notre indicateur personnalisé.
- data_type : le type de données que nous devons stocker dans le tableau d'indicateurs.
SetIndexBuffer(0,haOpen,INDICATOR_DATA); SetIndexBuffer(1,haHigh,INDICATOR_DATA); SetIndexBuffer(2,haLow,INDICATOR_DATA); SetIndexBuffer(3,haClose,INDICATOR_DATA); SetIndexBuffer(4,haColor,INDICATOR_COLOR_INDEX);
Définition de la valeur de la propriété d'indicateur correspondante en utilisant la fonction IndicatorSetInteger avec la variante d'appel dans laquelle nous spécifions l'identifiant de la propriété. Ses paramètres sont :
- prop_id : l'identifiant de la propriété qui peut être l'une des valeurs de ENUM_CUSTOMIND_PROPERTY_INTEGER, nous préciserons INDICATOR_DIGITS.
- prop_value : la valeur de la propriété que nous allons spécifier _Digits.
IndicatorSetInteger(INDICATOR_DIGITS,_Digits);
Définition de la valeur de la propriété de type chaîne correspondante avec la variante d'appel dans laquelle nous spécifions également l'identifiant de la propriété. Ses paramètres sont :
- prop_id : l'identifiant de la propriété qui peut être l'une des valeurs de ENUM_CUSTOMIND_PROPERTY_STRING, nous spécifierons INDICATOR_SHORTNAME pour utiliser un nom court pour l'indicateur.
- prop_value : la valeur de la propriété que nous allons spécifier ("Simple Heiken Ashi").
IndicatorSetString(INDICATOR_SHORTNAME,"Simple Heiken Ashi");
Définition de la valeur de la propriété de type double de l'indicateur correspondant à l'aide de la fonction PlotIndexSetDouble. Ses paramètres sont :
- plot_index : l'index de la représentation graphique, nous spécifierons 0.
- prop_id : une des valeurs de ENUM_PLOT_PROPERTY_DOUBLE, nous utiliserons PLOT_EMPTY_VALUE s'il n'y a pas de dessin.
- prop_value : la valeur de la propriété.
PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0);
Renvoyez ensuite INIT_SUCCEEDED dans le cadre de la fonction OnInit() pour y mettre fin en renvoyant une initialisation réussie.
return(INIT_SUCCEEDED);
La fonction OnCalculate qui est appelée dans l'indicateur pour traiter les données de prix change avec le type de calculs basés sur la série temporelle actuelle.
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[])
Création d'une variable entière "start", à laquelle nous assignerons une valeur ultérieurement :
int start; Utilisation de l'instruction "if" pour renvoyer les valeurs des indices (bas, haut, ouvert et fermé) et la valeur de départ=1 si prev_calculated est égal à 0, ou pour renvoyer la valeur de départ assignée à prev_calculated-1 :
if(prev_calculated==0) { haLow[0]=low[0]; haHigh[0]=high[0]; haOpen[0]=open[0]; haClose[0]=close[0]; start=1; } else start=prev_calculated-1;
Utilisons l’opérateur "for" pour la boucle principale du calcul. Il se compose de 3 expressions et opérateurs exécutables.
Les trois expressions seront :
- i=start : pour la position de départ.
- i<rates_total && !IsStopped() : pour les conditions permettant de terminer la boucle. IsStopped() pour vérifier l'arrêt forcé de l'indicateur.
- i++ : ajoute 1 à l’index i actuel.
Les opérations que nous devons exécuter à chaque fois pendant la boucle :
Calcul pour les 4 variables doubles
- haOpenVal : pour la valeur d’ouverture du Heiken Ashi.
- haCloseVal : pour la valeur de clôture du Heiken Ashi.
- haHighVal : pour la valeur haute du Heiken Ashi.
- haLowVal : pour la valeur basse du Heiken Ashi.
L'attribution de valeurs calculées à l'étape précédente est identique à ce qui suit :
- haLow[i] = haLowVal
- haHigh[i] = haHighVal
- haOpen[i] = haOpenVal
- haClose[i] = haCloseVal
Si l'ouverture de la valeur Heiken Ashi est inférieure à la valeur de clôture, l'indicateur doit dessiner une bougie de couleur bleue ou, si ce n'est pas le cas, une bougie de couleur rouge.
for(int i=start; i<rates_total && !IsStopped(); i++) { double haOpenVal =(haOpen[i-1]+haClose[i-1])/2; double haCloseVal=(open[i]+high[i]+low[i]+close[i])/4; double haHighVal =MathMax(high[i],MathMax(haOpenVal,haCloseVal)); double haLowVal =MathMin(low[i],MathMin(haOpenVal,haCloseVal)); haLow[i]=haLowVal; haHigh[i]=haHighVal; haOpen[i]=haOpenVal; haClose[i]=haCloseVal; //--- set candle color if(haOpenVal<haCloseVal) haColor[i]=0.0; else haColor[i]=1.0; }
Terminer la fonction en renvoyant rates_total comme prev_calculated pour le prochain appel.
return(rates_total); Ensuite, nous compilons le code pour nous assurer qu'il n'y a pas d'erreurs. Voici le code complet en un seul bloc :
//+------------------------------------------------------------------+ //| simpleHeikenAshi.mq5 | //| Copyright 2023, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2023, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" #property indicator_separate_window #property indicator_buffers 5 #property indicator_plots 1 #property indicator_type1 DRAW_COLOR_CANDLES #property indicator_color1 clrBlue, clrRed #property indicator_width1 2 #property indicator_label1 "Heiken Ashi Open;Heiken Ashi High;Heiken Ashi Low;Heiken Ashi Close" double haOpen[]; double haHigh[]; double haLow[]; double haClose[]; double haColor[]; int OnInit() { SetIndexBuffer(0,haOpen,INDICATOR_DATA); SetIndexBuffer(1,haHigh,INDICATOR_DATA); SetIndexBuffer(2,haLow,INDICATOR_DATA); SetIndexBuffer(3,haClose,INDICATOR_DATA); SetIndexBuffer(4,haColor,INDICATOR_COLOR_INDEX); IndicatorSetInteger(INDICATOR_DIGITS,_Digits); IndicatorSetString(INDICATOR_SHORTNAME,"Simple Heiken Ashi"); PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0); return(INIT_SUCCEEDED); } int OnCalculate(const int rates_total, const int prev_calculated, const datetime &time[], const double &open[], const double &high[], const double &low[], const double &close[], const long &tick_volume[], const long &volume[], const int &spread[]) { int start; if(prev_calculated==0) { haLow[0]=low[0]; haHigh[0]=high[0]; haOpen[0]=open[0]; haClose[0]=close[0]; start=1; } else start=prev_calculated-1; for(int i=start; i<rates_total && !IsStopped(); i++) { double haOpenVal =(haOpen[i-1]+haClose[i-1])/2; double haCloseVal=(open[i]+high[i]+low[i]+close[i])/4; double haHighVal =MathMax(high[i],MathMax(haOpenVal,haCloseVal)); double haLowVal =MathMin(low[i],MathMin(haOpenVal,haCloseVal)); haLow[i]=haLowVal; haHigh[i]=haHighVal; haOpen[i]=haOpenVal; haClose[i]=haCloseVal; if(haOpenVal<haCloseVal) haColor[i]=0.0; else haColor[i]=1.0; } return(rates_total); }
Après avoir été compilé sans erreur, l'indicateur devrait être disponible dans le dossier "Indicateurs" de la fenêtre du Navigateur, comme dans l'image suivante.
Double-cliquez ensuite pour l'exécuter sur le graphique désiré, la fenêtre commune d'information sur l'indicateur apparaîtra ensuite :
L'onglet Couleurs présente les paramètres par défaut : la couleur bleue pour le mouvement vers le haut et la couleur rouge pour le mouvement vers le bas. Si nécessaire, vous pouvez modifier ces valeurs pour définir vos couleurs préférées. Cet onglet se présente comme suit :
Après avoir appuyé sur OK, l'indicateur sera attaché au graphique et apparaîtra comme dans l'image ci-dessous :
Comme vous pouvez le voir dans le graphique précédent, l'indicateur Heiken Ashi simple est inséré dans le graphique dans une sous-fenêtre séparée. Il contient des chandeliers bleus et rouges en fonction de la direction de ces bougies (haussières et baissières). Maintenant, nous avons un indicateur personnalisé que nous avons créé dans MetaTrader 5 et nous pouvons utiliser cet indicateur personnalisé dans n'importe quel système de trading. Nous verrons dans les prochaines rubriques comment nous pouvons le faire facilement.
EA basé sur l'indicateur Heiken Ashi personnalisé
Dans cette partie, nous allons apprendre comment utiliser un indicateur personnalisé dans l’EA de notre système de trading. Nous allons créer un système Heiken Ashi Simple qui peut nous montrer les prix de l'indicateur (Open, High, Low et Close) puisque nous savons déjà qu'ils diffèrent des prix réels selon le calcul de l'indicateur.
Pour ce faire, choisissez de créer un nouvel Expert Advisor. Voici donc le code complet suivant :
//+------------------------------------------------------------------+ //| heikenAshiSystem.mq5 | //| Copyright 2023, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2023, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" int heikenAshi; int OnInit() { heikenAshi=iCustom(_Symbol,_Period,"My Files\\Heiken Ashi\\simpleHeikenAshi"); return(INIT_SUCCEEDED); } void OnDeinit(const int reason) { Print("Heiken Ashi System Removed"); } void OnTick() { double heikenAshiOpen[], heikenAshiHigh[], heikenAshiLow[], heikenAshiClose[]; CopyBuffer(heikenAshi,0,0,1,heikenAshiOpen); CopyBuffer(heikenAshi,1,0,1,heikenAshiHigh); CopyBuffer(heikenAshi,2,0,1,heikenAshiLow); CopyBuffer(heikenAshi,3,0,1,heikenAshiClose); Comment("heikenAshiOpen ",DoubleToString(heikenAshiOpen[0],_Digits), "\n heikenAshiHigh ",DoubleToString(heikenAshiHigh[0],_Digits), "\n heikenAshiLow ",DoubleToString(heikenAshiLow[0],_Digits), "\n heikenAshiClose ",DoubleToString(heikenAshiClose[0],_Digits)); }
Voici les différences dans ce code :
Le programme est de type Expert Advisor. La construction de ce programme sera donc différente puisqu'elle se compose des 3 parties suivantes :
- int OnInit() : cette fonction est utilisée pour initialiser une exécution de l'EA avec le type recommandé qui renvoie une valeur entière.
- void OnDeinit : elle est utilisée pour dé-initialiser une exécution de l'EA qui ne renvoie aucune valeur.
- void OnTick() : elle est utilisée pour gérer une nouvelle cotation à chaque tick et ne renvoie aucune valeur.
En dehors du champ d'application des fonctions précédentes et avant celles-ci, nous avons créé une variable entière heikenAshi.
int heikenAshi; Dans le cadre de la fonction OnInit(), nous avons attribué la valeur de la fonction iCustom à la variable "heikenAshi". La fonction iCustom renvoie le handle de l'indicateur personnalisé qui sera ici le Heiken Ashi Simple. Mais vous pouvez utiliser n'importe quel indicateur personnalisé dans votre dossier Indicators. Ses paramètres sont :
- symbol : le nom du symbole, nous avons utilisé _Symbol pour le symbole actuel.
- period : la période, nous avons utilisé _Period pour la période actuelle.
- name : le nom de l'indicateur personnalisé avec son chemin dans le dossier Indicators de votre MetaTrader 5. Ici nous avons utilisé "My Files\\Heiken Ashi\\simpleHeikenAshi".
Nous avons ensuite terminé la fonction en renvoyant INIT_SUCCEEDED si l'initialisation a réussi.
int OnInit() { heikenAshi=iCustom(_Symbol,_Period,"My Files\\Heiken Ashi\\simpleHeikenAshi"); return(INIT_SUCCEEDED); }
Dans le cadre de la fonction OnDeinit(), nous avons utilisé la fonction print pour informer que l'EA a été supprimé.
void OnDeinit(const int reason) { Print("Heiken Ashi System Removed"); }
Dans la portée de la fonction OnTick(), nous avons utilisé ce qui suit pour compléter notre code :
Création de 4 variables de type double pour les prix du Heiken Ashi (Open, High, Low et Close)
double heikenAshiOpen[], heikenAshiHigh[], heikenAshiLow[], heikenAshiClose[]; Récupérer les données des buffers de l'indicateur personnalisé en utilisant la fonction CopyBuffer. Ses paramètres sont :
- indicator_handle : le handle de l'indicateur que nous avons utilisé (heikenAshi).
- buffer_num : le numéro du buffer de l'indicateur utilisé (0 pour open, 1 pour high, 2 pour low, et 3 pour close).
- start_pos : la position du premier élément à copier, nous avons utilisé 0 pour l'élément actuel.
- count : la quantité de données à copier, nous avons utilisé 1, nous n'avons pas besoin de plus.
- buffer[] : le tableau à copier, nous avons utilisé (heikenAshiOpen pour Open, heikenAshiHigh pour high, heikenAshiLow pour low, et heikenAshiClose pour close).
Afficher un commentaire sur le graphique avec les prix Heiken Ashi actuels (Open, High, Low et Close) en utilisant la fonction comment :
Comment("heikenAshiOpen ",DoubleToString(heikenAshiOpen[0],_Digits), "\n heikenAshiHigh ",DoubleToString(heikenAshiHigh[0],_Digits), "\n heikenAshiLow ",DoubleToString(heikenAshiLow[0],_Digits), "\n heikenAshiClose ",DoubleToString(heikenAshiClose[0],_Digits));
Après avoir compilé ce code sans erreur et l'avoir exécuté, nous pouvons trouver l'EA attaché au graphique. Nous pouvons recevoir le même signal dans l'exemple de test suivant :
Comme nous pouvons le voir dans le graphique précédent, les prix de l'indicateur apparaissent sous forme de commentaire dans le coin supérieur gauche du graphique.
Système Heiken Ashi - EMA
Dans ce sujet, nous allons combiner un autre outil technique pour voir si le résultat sera meilleur ou non. L'idée que nous devons appliquer est de filtrer les signaux de l'indicateur personnalisé en utilisant la moyenne mobile exponentielle avec les prix. Il y a plusieurs méthodes pour le faire. Nous pouvons créer un autre indicateur personnalisé pour l'EMA, si nous voulons ajouter plus de fonctionnalités à l'EMA. Nous pouvons l'utiliser dans l'EA avec iCustom comme nous l'avons fait pour prendre les signaux désirés. Nous pouvons également créer un indicateur lissé en lissant les valeurs de l'indicateur et en prenant ensuite nos signaux. Nous pouvons utiliser la fonction iMA intégrée dans notre EA pour obtenir nos signaux. Nous utiliserons cette méthode ici par souci de simplicité.
Ce qu'il faut faire, c'est laisser l'EA vérifier continuellement les valeurs des 2 EMA actuelles (rapides et lentes), de l'EMA rapide précédente et de la clôture du Heiken Ash pour déterminer les positions de chaque valeur. Si heikenAshiClose précédent est supérieur au fastEMA précédent et que le fastEMA actuel est supérieur à la valeur slowEMA actuelle, l'EA devrait renvoyer un signal d'achat et ces valeurs en tant que commentaire sur le graphique. Si le heikenAshiClose précédent est inférieur au fastEMA précédent et que le fastEMA actuel est inférieur à la valeur slowEMA actuelle, l'EA devrait renvoyer un signal de vente et ces valeurs en tant que commentaire sur le graphique.
Voici le code complet de la création de l'EA :
//+------------------------------------------------------------------+ //| heikenAsh-EMASystem.mq5 | //| Copyright 2023, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2023, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" input int fastEMASmoothing=9; // Fast EMA Period input int slowEMASmoothing=18; // Slow EMA Period int heikenAshi; double fastEMAarray[], slowEMAarray[]; int OnInit() { heikenAshi=iCustom(_Symbol,_Period,"My Files\\Heiken Ashi\\simpleHeikenAshi"); return(INIT_SUCCEEDED); } void OnDeinit(const int reason) { Print("Heiken Ashi-EMA System Removed"); } void OnTick() { double heikenAshiOpen[], heikenAshiHigh[], heikenAshiLow[], heikenAshiClose[]; CopyBuffer(heikenAshi,0,0,3,heikenAshiOpen); CopyBuffer(heikenAshi,1,0,3,heikenAshiHigh); CopyBuffer(heikenAshi,2,0,3,heikenAshiLow); CopyBuffer(heikenAshi,3,0,3,heikenAshiClose); int fastEMA = iMA(_Symbol,_Period,fastEMASmoothing,0,MODE_SMA,PRICE_CLOSE); int slowEMA = iMA(_Symbol,_Period,slowEMASmoothing,0,MODE_SMA,PRICE_CLOSE); ArraySetAsSeries(fastEMAarray,true); ArraySetAsSeries(slowEMAarray,true); CopyBuffer(fastEMA,0,0,3,fastEMAarray); CopyBuffer(slowEMA,0,0,3,slowEMAarray); if(heikenAshiClose[1]>fastEMAarray[1]) { if(fastEMAarray[0]>slowEMAarray[0]) { Comment("Buy Signal", "\nfastEMA ",DoubleToString(fastEMAarray[0],_Digits), "\nslowEMA ",DoubleToString(slowEMAarray[0],_Digits), "\nprevFastEMA ",DoubleToString(fastEMAarray[1],_Digits), "\nprevHeikenAshiClose ",DoubleToString(heikenAshiClose[0],_Digits)); } } if(heikenAshiClose[1]<fastEMAarray[1]) { if(fastEMAarray[0]<slowEMAarray[0]) { Comment("Sell Signal", "\nfastEMA ",DoubleToString(fastEMAarray[0],_Digits), "\nslowEMA ",DoubleToString(slowEMAarray[0],_Digits), "\nprevFastEMA ",DoubleToString(fastEMAarray[1],_Digits), "\nheikenAshiClose ",DoubleToString(heikenAshiClose[0],_Digits)); } } }
Les différences dans ce code sont les suivantes :
Création d'entrées utilisateur pour définir la période EMA rapide et la période EMA lente selon les préférences de l'utilisateur.
input int fastEMASmoothing=9; // Fast EMA Period input int slowEMASmoothing=18; // Slow EMA Period
Création de 2 tableaux pour fastEMA et slowEMA.
double fastEMAarray[], slowEMAarray[]; Réglage de la quantité de données à copier à 3 dans CopyBuffer pour obtenir les valeurs de clôture précédentes de l'indicateur Heiken Ashi.
CopyBuffer(heikenAshi,0,0,3,heikenAshiOpen); CopyBuffer(heikenAshi,1,0,3,heikenAshiHigh); CopyBuffer(heikenAshi,2,0,3,heikenAshiLow); CopyBuffer(heikenAshi,3,0,3,heikenAshiClose);
Définition de l'EMA rapide et de l'EMA lente à l'aide de la fonction intégrée iMA qui renvoie le handle de l'indicateur de moyenne mobile. Ses paramètres sont :
- symbol : le nom du symbole, nous avons utilisé _Symbol pour le symbole actuel.
- period : la période, nous avons utilisé _Period pour la période en cours.
- ma_period : la période nécessaire pour lisser la moyenne, nous avons utilisé les entrées fastEMASmoothing et slowEMASmoothing.
- ma_shift : le décalage de l'indicateur, nous avons utilisé 0.
- ma_method : le type de moyenne mobile, nous avons utilisé MODE_SMA pour la moyenne mobile simple.
- applied_price : le type de prix à utiliser dans le calcul, nous avons utilisé PRICE_CLOSE.
int fastEMA = iMA(_Symbol,_Period,fastEMASmoothing,0,MODE_SMA,PRICE_CLOSE); int slowEMA = iMA(_Symbol,_Period,slowEMASmoothing,0,MODE_SMA,PRICE_CLOSE);
Utilisation de la fonction ArraySetAsSeries pour activer l'indicateur AS_SERIES. Ses paramètres sont :
- array[] : le tableau utilisé (fastEMAarray et slowEMA).
- flag : le sens d'indexation du tableau, nous avons utilisé true.
ArraySetAsSeries(fastEMAarray,true); ArraySetAsSeries(slowEMAarray,true);
Obtenir les données du buffer de l'indicateur EMA en utilisant la fonction CopyBuffer.
CopyBuffer(fastEMA,0,0,3,fastEMAarray); CopyBuffer(slowEMA,0,0,3,slowEMAarray);
Conditions pour renvoyer des signaux à l'aide de l'instruction "if" :
En cas de signal d'achat :
Si heikenAshiClose précédent > fastEMAarray précédent et fastEMAarray actuel > slowEMAarray actuel, l'EA doit renvoyer un signal d'achat et les valeurs suivantes :
- fastEMA
- slowEMA
- prevFastEMA
- prevHeikenAshiClose
if(heikenAshiClose[1]>fastEMAarray[1]) { if(fastEMAarray[0]>slowEMAarray[0]) { Comment("Buy Signal", "\nfastEMA ",DoubleToString(fastEMAarray[0],_Digits), "\nslowEMA ",DoubleToString(slowEMAarray[0],_Digits), "\nprevFastEMA ",DoubleToString(fastEMAarray[1],_Digits), "\nprevHeikenAshiClose ",DoubleToString(heikenAshiClose[0],_Digits)); }
En cas de signal de vente :
Si heikenAshiClose précédent < fastEMAarray précédent et fastEMAarray actuel < slowEMAarray actuel, l'EA doit renvoyer un signal de vente et des valeurs de prix de :
- fastEMA
- slowEMA
- prevFastEMA
- prevHeikenAshiClose
if(heikenAshiClose[1]<fastEMAarray[1]) { if(fastEMAarray[0]<slowEMAarray[0]) { Comment("Sell Signal", "\nfastEMA ",DoubleToString(fastEMAarray[0],_Digits), "\nslowEMA ",DoubleToString(slowEMAarray[0],_Digits), "\nprevFastEMA ",DoubleToString(fastEMAarray[1],_Digits), "\nheikenAshiClose ",DoubleToString(heikenAshiClose[0],_Digits)); } }
Après avoir compilé ce code avec les erreurs et l'avoir exécuté, nous pouvons obtenir nos signaux comme le montrent les exemples de test suivants.
Dans le cas d'un signal d'achat :
Comme nous pouvons le voir dans le graphique précédent, le signal suivant est affiché sous forme de commentaire dans le coin supérieur gauche :
- Signal d’Achat
- fastEMA
- prevFastEMA
- prevHeikenAshiClose
Dans le cas d'un signal de vente :
Nous avons les valeurs suivantes comme signal sur le graphique :
- Signal de Vente
- fastEMA
- prevFastEMA
- prevHeikenAshiClose
Conclusion
Si vous avez compris tout ce dont nous avons parlé dans cet article, vous êtes supposé pouvoir créer votre propre indicateur Heiken Ashi personnalisé ou même ajouter quelques fonctionnalités supplémentaires selon vos préférences. Cela vous sera très utile pour lire les graphiques et prendre des décisions efficaces basées sur votre compréhension. Vous pourrez également utiliser cet indicateur personnalisé créé dans vos systèmes de trading comme Expert Advisors car nous l'avons mentionné et utilisé dans deux systèmes de trading à titre d'exemple.
- Système Heiken Ashi
- Système Heiken Ashi-EMA
J'espère que cet article vous a été utile et qu'il vous a apporté de bonnes informations sur le sujet traité ou sur tout autre sujet connexe. J'espère également que vous avez essayé d'appliquer ce que vous avez appris dans cet article, car cela vous sera très utile dans votre apprentissage de la programmation, la pratique étant un facteur très important dans les processus éducatifs efficaces. Veuillez noter que vous devez tester tout ce que vous avez appris dans cet article ou dans d'autres ressources avant de l'utiliser dans votre compte réel, car cela peut être dangereux si cela ne vous convient pas. L'objectif principal de cet article est uniquement éducatif, il convient donc d'être prudent.
Si vous avez trouvé cet article utile et que vous souhaitez en lire d'autres, vous pouvez consulter mes autres articles. J'espère que vous les trouverez également utiles.
Traduit de l’anglais par MetaQuotes Ltd.
Article original : https://www.mql5.com/en/articles/12510
Algorithmes d'optimisation de la population : Monkey Algorithm, Algorithme du Singe (MA)
Algorithmes d'optimisation de la population : Harmony Search (HS)
Alan Andrews et ses méthodes d'analyse des séries temporelles (timeseries)
Comment détecter les tendances et les modèles graphiques à l'aide de MQL5
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Vous acceptez la politique du site Web et les conditions d'utilisation