MQL4 · Bases
Structure d’un EA MQL4 : OnInit, OnTick, OnDeinit et paramètres
Directives, paramètres, variables globales et fonctions d’événement : comment s’organise un Expert Advisor MQL4, avec un modèle commenté et les erreurs de structure à éviter.
Un Expert Advisor MQL4 est un fichier .mq4 organisé en quatre zones : les directives (#property, #include), les paramètres d’entrée (input ou extern), les variables globales, puis les fonctions d’événement appelées par le terminal : OnInit() au chargement, OnTick() à chaque nouvelle cotation, OnDeinit() au retrait, et éventuellement OnTimer() ou OnChartEvent(). Tout le reste du code (calcul du signal, envoi d’ordres, gestion du risque) vit dans des fonctions que vous écrivez vous-même et que ces gestionnaires appellent.
Cette page détaille le rôle de chaque zone et propose un modèle commenté. Elle fait partie de la rubrique Les bases du MQL4.
Les quatre zones d’un fichier .mq4
1. Les directives du préprocesseur
En tête de fichier, les directives #property décrivent le programme : copyright, link, version, description, et surtout strict, qui active le mode de compilation recommandé (voir #property strict). On y place aussi les #include de fichiers d’en-tête, comme <stdlib.mqh> qui fournit la fonction ErrorDescription(), et les #define de constantes.
2. Les paramètres d’entrée
Les variables déclarées avec input ou extern au niveau global apparaissent dans l’onglet « Paramètres » de la fenêtre des propriétés de l’EA. Ce sont les réglages que l’utilisateur modifie sans toucher au code : volume, distances de stop, numéro magique, périodes d’indicateurs. Les deux mots-clés n’ont pas le même comportement ; la page extern et input explique lequel choisir.
3. Les variables globales
Déclarées hors de toute fonction, elles conservent leur valeur entre deux appels de OnTick(). On y stocke typiquement l’heure de la dernière bougie traitée, un compteur d’échecs ou des valeurs calculées une fois dans OnInit() (par exemple la taille d’un pip). Il ne faut pas les confondre avec les variables globales du terminal (GlobalVariableSet()), qui sont partagées entre programmes et survivent au redémarrage.
4. Les fonctions d’événement
C’est le cœur du programme. Le terminal les appelle lui-même, vous ne les appelez jamais directement.
| Fonction | Quand elle est appelée | Usage typique |
|---|---|---|
int OnInit() | Chargement de l’EA, changement de symbole ou d’unité de temps, modification des paramètres | Vérifier les paramètres, calculer des constantes, lancer un timer |
void OnTick() | Arrivée d’une nouvelle cotation sur le symbole du graphique | Lire les prix, calculer le signal, gérer les ordres |
void OnDeinit(const int reason) | Retrait de l’EA, fermeture du terminal, recompilation | Arrêter le timer, effacer les objets graphiques et les commentaires |
void OnTimer() | À intervalle régulier après EventSetTimer() | Tâches indépendantes des ticks : surveillance, rapports |
void OnChartEvent(...) | Clic, touche clavier, objet graphique | Interface avec boutons |
double OnTester() | Fin d’un test dans le testeur de stratégie | Critère d’optimisation personnalisé |
Un modèle d’EA commenté
Le code suivant compile en mode strict. Il ne prend aucune position : il montre où placer chaque élément.
//+------------------------------------------------------------------+
//| ModeleEA.mq4 : squelette d'Expert Advisor MQL4 |
//+------------------------------------------------------------------+
#property copyright "OptiBot Trading"
#property version "1.00"
#property strict
//--- paramètres d'entrée (fenêtre des propriétés)
input double InpLots = 0.10; // Volume en lots
input int InpStopPoints = 300; // Stop loss en points
input int InpMagic = 240101; // Numéro magique
//--- variables globales
datetime g_lastBarTime = 0; // heure de la dernière bougie traitée
//+------------------------------------------------------------------+
//| Initialisation |
//+------------------------------------------------------------------+
int OnInit()
{
// contrôle des paramètres : on refuse de démarrer si incohérents
if(InpLots <= 0 || InpStopPoints <= 0)
{
Print("Paramètres invalides, EA arrêté");
return(INIT_PARAMETERS_INCORRECT);
}
EventSetTimer(60); // OnTimer() toutes les 60 secondes
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Désinitialisation |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
EventKillTimer(); // on libère le timer
Comment(""); // on efface le texte du graphique
PrintFormat("EA retiré, raison %d", reason);
}
//+------------------------------------------------------------------+
//| Nouveau tick |
//+------------------------------------------------------------------+
void OnTick()
{
// ne travailler qu'une fois par bougie
if(Time[0] == g_lastBarTime)
return;
g_lastBarTime = Time[0];
int signal = CalculerSignal(); // 1 = achat, -1 = vente, 0 = rien
if(signal != 0)
GererEntree(signal);
}
//+------------------------------------------------------------------+
//| Timer |
//+------------------------------------------------------------------+
void OnTimer()
{
Comment("Dernier contrôle : ", TimeToString(TimeCurrent(), TIME_DATE|TIME_MINUTES));
}
//--- fonctions de l'utilisateur
int CalculerSignal()
{
// exemple : clôture précédente au-dessus de la clôture d'il y a 10 bougies
if(Close[1] > Close[11]) return(1);
if(Close[1] < Close[11]) return(-1);
return(0);
}
void GererEntree(int signal)
{
// ici : vérifications, calcul du lot, OrderSend()
PrintFormat("Signal %d sur %s", signal, Symbol());
}
Ce qu’il faut mettre (ou non) dans chaque fonction
OnInit : vérifier et préparer
OnInit() est le seul endroit où refuser proprement de démarrer. En mode strict, une valeur de retour non nulle arrête l’EA et le décharge du graphique. Les constantes INIT_SUCCEEDED, INIT_FAILED et INIT_PARAMETERS_INCORRECT rendent l’intention lisible. Vérifiez ici la cohérence des paramètres, calculez une fois pour toutes les valeurs qui dépendent du symbole (taille du pip, nombre de décimales) et créez les objets graphiques.
Évitez en revanche d’y envoyer des ordres ou de compter sur des cotations fraîches : OnInit() peut être appelée hors marché, lors d’un simple changement d’unité de temps.
OnTick : court et prévisible
OnTick() est appelée à chaque cotation reçue, mais si un tick arrive pendant que la fonction précédente s’exécute encore, il n’est pas mis en file d’attente pour l’EA. Une fonction longue rate donc des cotations. Gardez-la courte : filtrez d’abord (nouvelle bougie, horaire, ordres déjà ouverts), puis calculez. Le test sur Time[0] du modèle est le moyen le plus simple de ne travailler qu’une fois par bougie.
OnDeinit : nettoyer
Le paramètre reason indique pourquoi l’EA s’arrête (retrait, recompilation, changement de paramètres, fermeture du terminal). Utilisez-le pour distinguer un simple changement d’unité de temps d’un arrêt définitif, par exemple pour ne pas effacer des objets graphiques inutilement. Ne fermez jamais des positions dans OnDeinit() sans l’avoir clairement documenté : un redémarrage du terminal déclencherait la fermeture.
L’ancienne syntaxe : init(), start(), deinit()
Beaucoup d’EA trouvés en ligne utilisent encore init(), start() et deinit(). MetaTrader 4 les accepte toujours pour la compatibilité : start() joue le rôle de OnTick(). Ne mélangez pas les deux styles dans un même fichier et préférez les fonctions On...() pour tout nouveau code : leurs signatures sont fixes, le compilateur les vérifie, et ce sont celles que vous retrouverez en MQL5.
Pièges fréquents
- Oublier que l’EA ne voit que son graphique.
OnTick()n’est déclenchée que par les cotations du symbole sur lequel l’EA est attaché. Un robot multi-paires doit utiliser un timer ou accepter de réagir au rythme d’un seul symbole. - Initialiser des variables globales avec des prix. Une ligne comme
double g_prix = Ask;au niveau global est évaluée au chargement, pas à chaque tick. Lisez les prix dansOnTick(). - Supposer que OnInit ne s’exécute qu’une fois. Changer d’unité de temps ou de paramètres relance
OnDeinit()puisOnInit(), alors que les ordres restent ouverts. Le code doit retrouver ses ordres existants via leur numéro magique plutôt que via des variables mémorisées. - Laisser un timer actif. Chaque
EventSetTimer()doit avoir sonEventKillTimer()dansOnDeinit(). - Tout écrire dans OnTick. Un
OnTick()de trois cents lignes devient vite impossible à relire et à tester. Découpez en fonctions à responsabilité unique : une qui dit s’il faut entrer, une qui calcule le volume, une qui envoie l’ordre, une qui suit les positions ouvertes. Chaque fonction peut alors être testée isolément avec un script.
Organiser un projet qui grandit
Tant que l’EA reste court, un seul fichier suffit. Au-delà de quelques centaines de lignes, déplacez les fonctions réutilisables (calcul du lot, journalisation, contrôle des horaires) dans un fichier .mqh placé dans le dossier MQL4/Include, puis chargez-le avec #include. Vous partagerez ainsi le même code entre plusieurs robots et corrigerez un bug une seule fois. Conservez dans le fichier .mq4 principal uniquement les paramètres, les variables globales propres à l’EA et les fonctions d’événement : la lecture du programme devient immédiate, ce qui compte lorsque vous reviendrez dessus six mois plus tard.
Et en MQL5 ?
La structure est la même : OnInit(), OnTick(), OnDeinit() et OnTimer() existent avec les mêmes signatures. Ce qui change, c’est le contenu : en MQL5, les indicateurs se créent sous forme de handles dans OnInit() et les ordres passent par une structure de requête ou la classe CTrade. La page Convertir un EA MQL4 en MQL5 montre comment porter un squelette comme celui-ci. Pour aller plus loin côté MetaTrader 4, la page Premier EA en MQL4 complète ce modèle avec un vrai signal et l’envoi d’ordres.
FAQ
Quelle est la différence entre OnTick et start ?
start() est l’ancienne fonction principale des EA MQL4 ; OnTick() est son remplaçant, avec une signature vérifiée par le compilateur. Les deux sont appelées à chaque nouvelle cotation. Pour du code neuf, utilisez OnTick().
Pourquoi mon EA s’arrête-t-il juste après le chargement ?
Le plus souvent, OnInit() renvoie une valeur différente de INIT_SUCCEEDED, ce qui, en mode strict, décharge l’EA. Lisez l’onglet Experts du terminal : un message Print() placé avant chaque return d’échec vous indiquera la cause.
Peut-on avoir plusieurs fonctions OnTick dans un EA ?
Non, chaque gestionnaire d’événement est unique dans un programme. Pour organiser le code, appelez depuis OnTick() des fonctions séparées (signal, entrée, sortie, suivi) que vous nommez librement.
Un EA peut-il fonctionner sans OnTick ?
Un EA peut ne contenir que OnTimer() ou OnChartEvent() s’il ne dépend pas des cotations du graphique, mais c’est un cas particulier. Dans la pratique, presque tous les robots de trading reposent sur OnTick().
