Tu primer expert advisor en MQL5: un robot listo para copiar y lanzar hoy

El ejemplo desarrollado usa una estrategia de tendencia clásica: el cruce de dos medias móviles exponenciales, EMA 9 y EMA 21. La lógica es lo bastante simple como para no estorbar, lo que deja sitio para entender la estructura que comparten todos los expert advisors, desde el archivo que genera el MQL Wizard hasta el robot compilado colocando su primera operación de prueba.

El entorno de trabajo: cómo abrir MetaEditor 5

Construir un robot de trading no exige software de terceros. MetaTrader 5 ya incluye MetaEditor 5, el entorno de desarrollo para escribir y editar programas en MQL5.

MetaEditor reúne el editor de código, el compilador, el depurador, la documentación de referencia de MQL5 y el MQL Wizard integrado, que genera plantillas listas de expert advisors, indicadores y scripts.

Dos maneras de abrirlo desde el terminal de trading:

• Pulsa F4.
• Elige Tools → MetaQuotes Language Editor en el menú superior.

Crear el archivo del robot con el MQL Wizard

Con MetaEditor abierto, el MQL Wizard construye por ti el esqueleto del programa. Empieza por File → New. El asistente ofrece varios tipos de programa, y el que corresponde a este ejemplo es Expert Advisor (template).

Después viene la descripción del programa. El campo Name recoge la ruta y el nombre del archivo, por ejemplo Experts\MyFirstRobot. Author y Link son opcionales y pueden quedarse vacíos.

El asistente ofrece a continuación manejadores de eventos adicionales, entre ellos OnTimer y OnTrade. Este robot no usa ninguno de los dos, así que los valores por defecto se quedan como están.

La última pantalla cubre los eventos de prueba OnTester. Aquí tampoco se usan, así que los parámetros quedan intactos y el asistente termina.

MetaEditor contiene ahora un archivo .mq5 nuevo con la estructura básica de un expert advisor. Ese esqueleto es el punto de partida de la lógica de trading.

El código listo del robot en MQL5

Abajo está el expert advisor completo construido sobre el cruce de la EMA 9 y la EMA 21. Selecciona todo el contenido de la plantilla generada, bórralo y pega esto en su lugar, de modo que el archivo .mq5 contenga solo el código del robot. Después ya está listo para compilar.

//+------------------------------------------------------------------+
//|                                                 MyFirstRobot.mq5 |
//|                          EMA 9 / EMA 21 crossover Expert Advisor |
//+------------------------------------------------------------------+
#property copyright "MyFirstRobot"
#property version   "1.00"
#property description "Simple EMA 9/21 crossover Expert Advisor"

#include <Trade/Trade.mqh>
CTrade trade;

//--- Trading parameters
input double InpLotSize    = 0.10;    // Lot size
input int    InpFastEMA    = 9;       // Fast EMA period
input int    InpSlowEMA    = 21;      // Slow EMA period
input int    InpStopLoss   = 200;     // Stop Loss in points
input int    InpTakeProfit = 400;     // Take Profit in points
input ulong  InpMagic      = 123456;  // Magic number

//--- Indicator handles
int fastEMAHandle;
int slowEMAHandle;

//--- Opening time of the last processed bar
datetime lastBarTime = 0;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   //--- Create the Fast EMA indicator handle
   fastEMAHandle = iMA(_Symbol, _Period, InpFastEMA, 0, MODE_EMA, PRICE_CLOSE);

   //--- Create the Slow EMA indicator handle
   slowEMAHandle = iMA(_Symbol, _Period, InpSlowEMA, 0, MODE_EMA, PRICE_CLOSE);

   //--- Stop the robot if either handle failed
   if(fastEMAHandle == INVALID_HANDLE || slowEMAHandle == INVALID_HANDLE)
   {
      Print("Failed to create EMA indicators");
      return(INIT_FAILED);
   }

   //--- Tag every order, so the robot only ever manages its own positions
   trade.SetExpertMagicNumber(InpMagic);

   Print("MyFirstRobot started successfully");
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   //--- Opening time of the current bar
   datetime currentBarTime = iTime(_Symbol, _Period, 0);

   //--- Work once per bar, on the first tick after a new bar opens
   if(currentBarTime == lastBarTime)
      return;
   lastBarTime = currentBarTime;

   //--- Dynamic arrays: the timeseries flag needs them
   double fastEMA[];
   double slowEMA[];

   //--- Index 0 is the forming bar, 1 the last closed bar, 2 the one before it
   ArraySetAsSeries(fastEMA, true);
   ArraySetAsSeries(slowEMA, true);

   //--- Copy the last three EMA values of each average
   if(CopyBuffer(fastEMAHandle, 0, 0, 3, fastEMA) < 3)
      return;
   if(CopyBuffer(slowEMAHandle, 0, 0, 3, slowEMA) < 3)
      return;

   //--- Both checks read closed bars only, never the forming bar
   bool buySignal  = fastEMA[2] <= slowEMA[2] && fastEMA[1] > slowEMA[1];
   bool sellSignal = fastEMA[2] >= slowEMA[2] && fastEMA[1] < slowEMA[1];

   //+--------------------------------------------------------------+
   //| Buy signal                                                    |
   //+--------------------------------------------------------------+
   if(buySignal)
   {
      //--- Look only at a position this robot opened itself
      if(PositionSelect(_Symbol) &&
         PositionGetInteger(POSITION_MAGIC) == (long)InpMagic)
      {
         long positionType = PositionGetInteger(POSITION_TYPE);

         //--- A buy is already running, nothing to do
         if(positionType == POSITION_TYPE_BUY)
            return;

         //--- Close the opposite position before reversing
         if(positionType == POSITION_TYPE_SELL)
            trade.PositionClose(_Symbol);
      }

      double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
      double sl  = NormalizeDouble(ask - InpStopLoss   * _Point, _Digits);
      double tp  = NormalizeDouble(ask + InpTakeProfit * _Point, _Digits);

      trade.Buy(InpLotSize, _Symbol, 0, sl, tp, "EMA 9/21 Buy");
   }

   //+--------------------------------------------------------------+
   //| Sell signal                                                   |
   //+--------------------------------------------------------------+
   if(sellSignal)
   {
      if(PositionSelect(_Symbol) &&
         PositionGetInteger(POSITION_MAGIC) == (long)InpMagic)
      {
         long positionType = PositionGetInteger(POSITION_TYPE);

         if(positionType == POSITION_TYPE_SELL)
            return;

         if(positionType == POSITION_TYPE_BUY)
            trade.PositionClose(_Symbol);
      }

      double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
      double sl  = NormalizeDouble(bid + InpStopLoss   * _Point, _Digits);
      double tp  = NormalizeDouble(bid - InpTakeProfit * _Point, _Digits);

      trade.Sell(InpLotSize, _Symbol, 0, sl, tp, "EMA 9/21 Sell");
   }
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   //--- Release the indicator handles
   if(fastEMAHandle != INVALID_HANDLE)
      IndicatorRelease(fastEMAHandle);
   if(slowEMAHandle != INVALID_HANDLE)
      IndicatorRelease(slowEMAHandle);
}
//+------------------------------------------------------------------+

Anatomía del código: qué hace cada bloque

El robot se divide en cinco partes funcionales, cada una responsable de una etapa de su trabajo, desde leer sus ajustes hasta enviar una orden. Este es el mapa, seguido del detalle de las partes que conviene entender antes de ponerlo en marcha.

Parámetros de entrada

Los ajustes de la parte superior del archivo llevan el modificador input, que los expone en la ventana de parámetros del robot dentro de MetaTrader 5. En este ejemplo son los periodos de la EMA rápida y la lenta, InpFastEMA e InpSlowEMA, junto con InpLotSize, InpStopLoss, InpTakeProfit e InpMagic.

La ventaja está en que cambiar un ajuste no exige tocar el código fuente. Los valores se pueden modificar justo antes de lanzar el robot, y el probador de estrategias puede recorrerlos durante una optimización.

Inicialización con OnInit()

OnInit() se ejecuta una vez cuando el robot arranca, lo que ocurre al adjuntarlo a un gráfico o al reiniciar el terminal. Prepara los recursos que el robot necesitará después, creando los handles de indicador que suministran los valores de las EMA.

Cuando esa preparación falla, la función devuelve INIT_FAILED y el terminal detiene el robot en lugar de ejecutarlo a medio configurar. También fija el número mágico, la etiqueta que marca cada orden que envía este robot y le permite distinguir sus propias posiciones de cualquier otra cosa sobre el mismo símbolo.

El evento de tick y el filtro de barra nueva

OnTick() es la función principal. El terminal la llama cada vez que llega un tick nuevo, es decir, cualquier cambio en la cotización. Evaluar la estrategia en cada tick sería trabajo desperdiciado aquí, así que un filtro de barra nueva reduce el procesamiento a una vez por vela.

El robot lee la hora de apertura de la barra actual con iTime() y la compara con la hora que procesó la última vez:

if(currentBarTime == lastBarTime)
   return;

Cuando se abre una vela nueva, esa hora cambia y el robot continúa. La estrategia reacciona por tanto una vez por vela, y deja de seguir cada cambio de precio dentro de ella.

Tras el filtro, el robot copia ambas EMA con CopyBuffer() y comprueba si hubo un cruce. El índice 1 contiene la última barra cerrada y el índice 2 la anterior, de modo que la comparación nunca toca la vela que aún se está formando. La EMA 9 cruzando por encima de la EMA 21 activa buySignal, cruzando por debajo activa sellSignal, y solo entonces toma el relevo el bloque de ejecución.

Ejecución de las operaciones

Las órdenes pasan por CTrade, una clase de la librería estándar de MQL5 que envuelve el trabajo de montar a mano una petición de operación. Según la señal, el robot llama a trade.Buy() o a trade.Sell() y le pasa el volumen de la posición junto con los niveles de stop-loss y take-profit.

Ambos niveles se calculan en puntos desde el precio actual y después se pasan por NormalizeDouble(), que los recorta al número de decimales que el símbolo usa de verdad. Los servidores rechazan precios con más precisión de la que el instrumento admite, y es aquí donde eso aparece.

Antes de abrir nada, el robot comprueba si una posición sobre el símbolo ya le pertenece, comparando POSITION_MAGIC con su propio número mágico. Esa comprobación evita que cierre una operación que abriste a mano o una que pertenece a otro robot sobre el mismo instrumento.

Plantilla lista y código generado por IA

Las herramientas de IA han facilitado mucho el arranque con los expert advisors. Un trader sin experiencia en programación puede describir una idea de trading con palabras corrientes y recibir la base de un robot en MQL5.

Sigue habiendo una diferencia entre partir de una plantilla y generar código desde cero. Un modelo produce rápido una lógica de trading complicada, y ese código todavía hay que leerlo, compilarlo y probarlo. MQL5 es un objetivo más estrecho que los lenguajes de uso general, así que un modelo tiene más probabilidades de inventarse la firma de una función, mezclar hábitos de MQL4 dentro de código MQL5 o dejar fuera una salvaguarda que nadie pidió.

Una plantilla lista es la vía más rápida para ver cómo está montado un expert advisor. La IA se vuelve realmente útil en el paso siguiente, cuando ya tienes código funcionando delante y quieres que te lo expliquen, lo amplíen o lo adapten. La mayoría de principiantes saca partido de las dos cosas: partir de un ejemplo que funciona y después usar un chat de IA para recorrer bloques concretos y añadir condiciones propias.

Cómo compilar y lanzar el robot en MetaTrader 5

Con la lógica de trading en el archivo, tres pasos lo convierten en un robot funcionando sobre un gráfico.

Paso 1. Pon el código en el archivo

Aquí se usa el archivo .mq5 que creó antes el MQL Wizard. La plantilla generada contiene código de relleno, y todo él se sustituye por el listado de arriba, de modo que el archivo contenga el robot y nada más.

Paso 2. Compila

Compilar convierte el código fuente MQL5 en el formato ejecutable que corre el terminal, y produce un archivo .ex5. Lánzalo con el botón Compile de la barra de MetaEditor o con F7.

El resultado aparece en la parte inferior de la ventana. Sin errores de sintaxis, el mensaje dice:

0 error(s), 0 warning(s)

Una compilación limpia confirma que el código es válido para el compilador. No dice nada sobre si la estrategia gana dinero ni sobre si la lógica hace lo que pretendías, que es para lo que está el probador de estrategias.

Paso 3. Adjunta el robot a un gráfico

El robot compilado aparece ya en MetaTrader 5. Abre la ventana Navigator, entra en Expert Advisors y localiza MyFirstRobot. Arrástralo sobre el gráfico del instrumento con el que quieras que opere.

Se abre la ventana de parámetros. Revisa aquí los ajustes de entrada, incluidos el volumen de trading, los periodos de las EMA y los niveles de stop-loss y take-profit. En la pestaña Common, confirma que Allow Algo Trading está marcado y acepta el diálogo.

Cuando el botón Algo Trading de la barra del terminal también está activo, el robot puede enviar órdenes según su lógica y empieza a seguir el mercado con los parámetros que le has puesto.

Pruebas en el probador de estrategias

Antes de que un robot se acerque siquiera a una cuenta real, su sitio está en el probador de estrategias integrado en MetaTrader 5. Una prueba sobre datos históricos muestra cómo habría ejecutado el robot sus reglas en condiciones de mercado distintas, y saca a la luz fallos técnicos mucho antes de que haya dinero de por medio.

Cómo lanzar la prueba

Abre el probador con Ctrl + R. En sus ajustes, selecciona el expert advisor MyFirstRobot, el instrumento, por ejemplo GBPUSD, y el marco temporal H1 para el que está escrito este ejemplo. Para la simulación más realista, elige el modo de modelado Every tick based on real ticks y fija el periodo histórico.

MetaTrader 5 reproduce entonces el movimiento histórico del precio y simula el robot: las señales apareciendo, las posiciones abriéndose y cerrándose, y el resultado financiero acumulado. Vigila que las posiciones se abran y se cierren como esperas y que el stop-loss y el take-profit caigan donde deben.

Un backtest muestra cómo se comportaron las reglas sobre un historial de precios que ya se conoce. Es una comprobación de que el robot ejecuta su lógica correctamente, y no lleva ningún pronóstico de ingresos futuros. Cuanto más compleja sea una estrategia y más ajustada esté a los datos históricos, más tienden sus resultados en real a quedarse por debajo de la prueba.

Para la configuración completa de pruebas con ticks, consulta Un backtest de 15 minutos: cómo probar un robot de trading en MetaTrader 5.

Qué cifras leer en el informe

MetaTrader 5 produce un informe detallado. Cuatro cifras bastan para una primera valoración.

Qué muestra el informe más allá de la línea de beneficio

Leer solo el beneficio final es el atajo más común entre los algo traders nuevos. Una estrategia puede exhibir una rentabilidad llamativa mientras carga con un drawdown profundo o se apoya en un puñado de operaciones. Pondera el factor de beneficio y el beneficio final junto con el drawdown máximo, el número de operaciones, la forma de la curva de equity y cómo se reparten los resultados en el tiempo.

Hay algo más que merece atención: hasta qué punto el resultado sobrevive a un cambio del periodo de prueba o a un cambio pequeño de parámetros. Cuando un ajuste menor convierte una estrategia rentable en una perdedora, lo más probable es que esté amoldada a su historial.

La lista de comprobación previa al lanzamiento

Una compilación correcta no significa que el robot esté listo para una cuenta real. Repasa estos puntos antes de activar el trading automatizado.

Dedica las primeras semanas a observar cómo se comporta el robot en condiciones reales: que recibe cotizaciones, que abre posiciones solo cuando se cumplen sus condiciones, que adjunta sus órdenes de protección y que no toma operaciones con las que no contabas.

Dos situaciones que resolver en el primer lanzamiento

Un primer lanzamiento puede sacar a la luz problemas que ni el compilador ni la primera prueba mostraron. El código compila, el robot está sobre el gráfico, Algo Trading está activo, y aun así no pasa nada. En la práctica la causa suele estar en las condiciones de la cuenta, en los ajustes del instrumento o en la manera en que corre el terminal. Dos casos aparecen con más frecuencia que el resto.

El robot se queda callado por culpa del margen

Imagina un robot sobre GBPUSD H1. La EMA 9 cruza la EMA 21 y no aparece ninguna posición. El primer sitio donde mirar es la pestaña Journal y los mensajes bajo Experts. Una línea que diga Not enough money apunta al margen libre.

Abrir una posición hace que el bróker reserve parte de la cuenta como garantía de margen. La cantidad depende del volumen de la operación, del precio del instrumento, del tipo de contrato, del apalancamiento y de las condiciones de la cuenta. Un InpLotSize = 0.1 fijo puede resultar demasiado grande para un depósito pequeño en algunos instrumentos, así que el tamaño del lote solo cobra sentido leído frente al balance y al margen disponible.

Comprueba que la cuenta tiene fondos libres suficientes para el volumen que has configurado. El margen requerido por lote figura en la especificación del instrumento en MetaTrader 5. En una cuenta pequeña, el volumen mínimo permitido es el punto de partida sensato. Tener margen suficiente y tener un tamaño de posición prudente son cuestiones separadas: que te llegue el margen para abrir una operación no dice nada sobre lo que esa operación puede costarte.

El robot solo funciona mientras funciona el terminal

El segundo caso es dar por supuesto que un robot sobre un gráfico sigue trabajando pase lo que pase con el ordenador. En una instalación local, no. Un expert advisor de MQL5 corre dentro de una copia de MetaTrader 5 en marcha. Cierra el terminal o apaga la máquina, y el robot local deja de recibir ticks y deja de ejecutar su lógica.

Si la EMA 9 y la EMA 21 se cruzan durante ese tiempo, la señal queda sin procesar hasta que el terminal vuelva a estar en marcha. Lo mismo vale para gestionar una posición ya abierta, siempre que esa lógica viva dentro del robot.

Para un robot pensado para trabajar las 24 horas, la respuesta es un servidor privado virtual. MetaTrader 5 incluye un servicio de alojamiento virtual que traslada el entorno de trading del robot a una infraestructura remota, y RoboForex ofrece un VPS para el mismo trabajo. Una vez trasladado, el robot sigue funcionando esté o no encendido tu propio ordenador.

Un VPS resuelve la continuidad del entorno de trading. No hace más fiable ninguna estrategia ni corrige ningún fallo del código.

Conclusión

Construir un primer expert advisor en MQL5 cubre el ciclo de desarrollo entero de una sentada: la lógica de trading, la compilación, la prueba y el lanzamiento. El cruce de la EMA 9 y la EMA 21 es deliberadamente sencillo, y eso es lo que hace visible la estructura que hay debajo, una estructura que es la misma en robots mucho más complejos que este.

El paso siguiente es práctico. Abre MetaEditor, pega el código, compílalo, pásalo por el probador de estrategias y después ponlo en una cuenta demo y observa cómo se comporta sin capital en juego. Después de eso, el sistema que funciona se puede refinar o sustituir por el tuyo propio, llevar a una cuenta cent de RoboForex con el lote mínimo y conectar a un VPS para que trabaje las 24 horas.

Mantén el foco en si el robot hace lo que dicen las reglas, en lo estable que es el algoritmo y en cómo se controla el dimensionamiento de las posiciones. Ese es el cimiento sobre el que se construye el resto de un sistema de trading automatizado.

FAQ