Trading algorithmique
Apprendre MQL5 : coder son premier Expert Advisor
Le MQL5 est le langage des robots MetaTrader 5. Dans ce tutoriel, vous construisez un Expert Advisor complet : signal, filtre de bougie, ordres et taille de position calculée selon votre risque.
Le MQL5 (MetaQuotes Language 5) est un langage proche du C++, conçu pour écrire des indicateurs, des scripts et des robots de trading appelés Expert Advisors (EA). Si vous avez déjà manipulé un langage de programmation, vous pouvez écrire un premier EA fonctionnel en quelques heures.
Ce tutoriel construit un robot volontairement simple : un croisement de moyennes mobiles exponentielles. L’intérêt n’est pas la stratégie, mais la structure, réutilisable pour n’importe quelle idée.
Prérequis et environnement
- MetaTrader 5 installé, avec un compte démo.
- MetaEditor, l’éditeur fourni avec MT5 (touche F4 depuis le terminal).
- Des notions de base en programmation : variables, conditions, fonctions.
Dans MetaEditor, choisissez Nouveau, puis Expert Advisor (modèle). Le fichier .mq5 est créé dans le dossier MQL5/Experts de votre terminal.
La structure d’un Expert Advisor
Un EA repose sur trois fonctions événementielles appelées automatiquement par le terminal :
| Fonction | Quand est-elle appelée ? | Usage |
|---|---|---|
| OnInit() | Au chargement de l’EA sur un graphique | Créer les indicateurs, vérifier les paramètres |
| OnTick() | À chaque nouveau tick reçu | Logique de trading |
| OnDeinit() | Au retrait de l’EA ou à la fermeture | Libérer les ressources |
En MQL5, les indicateurs fonctionnent par handles : on crée l’indicateur une fois dans OnInit(), puis on lit ses valeurs avec CopyBuffer() dans OnTick(). C’est la principale différence avec le MQL4, où l’on appelait directement iMA() à chaque tick.
Les paramètres et les variables globales
Les variables déclarées avec le mot-clé input apparaissent dans la fenêtre de paramètres de l’EA et peuvent être optimisées dans le Strategy Tester.
#include <Trade\Trade.mqh>
input int InpFastPeriod = 20; // Période de la moyenne rapide
input int InpSlowPeriod = 50; // Période de la moyenne lente
input double InpRiskPercent = 0.5; // Risque par trade (% des fonds propres)
input int InpStopPoints = 300; // Stop-loss (en points)
input int InpTakePoints = 600; // Take-profit (en points)
input ulong InpMagic = 260101; // Identifiant unique du robot
CTrade trade;
int fastHandle = INVALID_HANDLE;
int slowHandle = INVALID_HANDLE;
datetime lastBar = 0;
La classe CTrade, fournie par la bibliothèque standard, simplifie l’envoi des ordres. Le magic number permet au robot de reconnaître ses propres positions parmi celles du compte.
Initialisation et libération des indicateurs
int OnInit()
{
if(InpFastPeriod >= InpSlowPeriod)
return(INIT_PARAMETERS_INCORRECT);
fastHandle = iMA(_Symbol, _Period, InpFastPeriod, 0, MODE_EMA, PRICE_CLOSE);
slowHandle = iMA(_Symbol, _Period, InpSlowPeriod, 0, MODE_EMA, PRICE_CLOSE);
if(fastHandle == INVALID_HANDLE || slowHandle == INVALID_HANDLE)
return(INIT_FAILED);
trade.SetExpertMagicNumber(InpMagic);
return(INIT_SUCCEEDED);
}
void OnDeinit(const int reason)
{
IndicatorRelease(fastHandle);
IndicatorRelease(slowHandle);
}
Retourner INIT_PARAMETERS_INCORRECT quand la moyenne rapide est plus lente que la lente évite de gaspiller des passes lors des optimisations.
Calculer la taille de position selon le risque
C’est la fonction la plus importante du robot. Elle convertit un pourcentage de risque en nombre de lots, à partir de la distance du stop-loss et de la valeur du tick de l’instrument. La logique est détaillée dans notre guide de la gestion du risque.
double LotsForRisk(const int stopPoints)
{
double riskMoney = AccountInfoDouble(ACCOUNT_EQUITY) * InpRiskPercent / 100.0;
double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
if(tickValue <= 0.0 || tickSize <= 0.0)
return(0.0);
double lossPerLot = (stopPoints * _Point / tickSize) * tickValue;
double lots = riskMoney / lossPerLot;
double step = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
double minL = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
double maxL = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
lots = MathFloor(lots / step) * step;
if(lots < minL)
return(0.0); // trop petit : on ne trade pas plutôt que de sur-risquer
return(MathMin(lots, maxL));
}
Vérifier si le robot a déjà une position
bool HasPosition()
{
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
ulong ticket = PositionGetTicket(i); // sélectionne aussi la position
if(ticket > 0
&& PositionGetString(POSITION_SYMBOL) == _Symbol
&& PositionGetInteger(POSITION_MAGIC) == (long)InpMagic)
return(true);
}
return(false);
}
La logique de trading dans OnTick()
Le robot ne prend une décision qu’une fois par bougie, sur les valeurs des bougies clôturées. Cela évite les signaux qui apparaissent puis disparaissent au cours de la bougie, et rend le backtest cohérent avec le comportement réel.
void OnTick()
{
datetime barTime = iTime(_Symbol, _Period, 0);
if(barTime == lastBar)
return; // une seule décision par bougie
lastBar = barTime;
double fast[], slow[];
ArraySetAsSeries(fast, true);
ArraySetAsSeries(slow, true);
// valeurs des bougies 1 (dernière clôturée) et 2
if(CopyBuffer(fastHandle, 0, 1, 2, fast) < 2) return;
if(CopyBuffer(slowHandle, 0, 1, 2, slow) < 2) return;
bool crossUp = fast[1] <= slow[1] && fast[0] > slow[0];
bool crossDown = fast[1] >= slow[1] && fast[0] < slow[0];
if(!crossUp && !crossDown) return;
if(HasPosition()) return;
double lots = LotsForRisk(InpStopPoints);
if(lots <= 0.0) return;
double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
if(crossUp)
trade.Buy(lots, _Symbol, ask,
NormalizeDouble(ask - InpStopPoints * _Point, _Digits),
NormalizeDouble(ask + InpTakePoints * _Point, _Digits), "EMA cross");
else
trade.Sell(lots, _Symbol, bid,
NormalizeDouble(bid + InpStopPoints * _Point, _Digits),
NormalizeDouble(bid - InpTakePoints * _Point, _Digits), "EMA cross");
}
Compiler et tester
- Appuyez sur F7 dans MetaEditor pour compiler. Corrigez les éventuelles erreurs signalées dans l’onglet Erreurs.
- Dans MetaTrader 5, ouvrez le Strategy Tester (Ctrl+R), sélectionnez votre EA, le symbole et l’unité de temps.
- Lancez un premier test en « OHLC 1 minute » pour vérifier que le robot ouvre et ferme des positions comme prévu.
- Passez ensuite à la méthode complète décrite dans notre guide pour backtester une stratégie.
Aller plus loin
Ce squelette couvre l’essentiel, mais un robot destiné au réel doit aussi :
- vérifier le retour des ordres (trade.ResultRetcode()) et gérer les refus du broker ;
- filtrer le spread au moment de l’entrée ;
- intégrer des limites globales : perte journalière maximale, drawdown maximal, horaires autorisés ;
- journaliser ses décisions pour pouvoir comparer réel et backtest.
Questions fréquentes
Le MQL5 est-il difficile à apprendre ?
Pour quelqu’un qui connaît déjà un langage comme Python, JavaScript ou C, la syntaxe se prend en main rapidement. La vraie difficulté est ailleurs : comprendre le fonctionnement des ordres, des positions et des données de marché sur MetaTrader 5.
Un EA MQL4 fonctionne-t-il sur MT5 ?
Non. Les deux langages sont proches mais incompatibles : la gestion des ordres et des indicateurs diffère. Un EA MQL4 doit être réécrit pour MetaTrader 5.
Faut-il utiliser la bibliothèque standard ou OrderSend() ?
Pour débuter, la classe CTrade de la bibliothèque standard est plus simple et moins source d’erreurs. OrderSend() donne un contrôle plus fin mais demande de remplir soi-même la structure de requête.
