MQL5 Wizard: crear asesores expertos sin programar

MetaQuotes Software Corp. | 23 enero, 2014

Introducción
Cuando creamos sistemas de trading automatizados es necesario escribir algoritmos para analizar la situación
del mercado y generar señales de trading, algoritmos de arrastre de nuestras posiciones abiertas y sistemas
para gestionar el dinero y el riesgo.

Una vez que se ha escrito el código de los módulos, la tarea más difícil es ensamblar todas las partes y
depurar el código fuente del robot de trading. Aquí, el papel principal lo juega la arquitectura de la
interacción de los módulos: si su construcción es deficiente, la mayor parte del tiempo se empleará en
encontrar y corregir errores, y si sustituimos el algoritmo de cualquier módulo nos llevará a reescribir todo el
código fuente.

El uso del enfoque orientado a objeto en MQL5 elimina considerablemente la tarea de escribir y probar los
sistemas de trading automatizados.

MetaQuotes Software Corp. ha desarrollado clases para implementar estrategias de trading. Ahora puede
generar código de asesores expertos de forma automática directamente en MetaEditor seleccionando las
señales de trading necesarias (actualmente hay 20 de ellas), los módulos Trailing (4) y Money Management (5).
Combinando estos módulos podemos obtener muchas variantes de sistemas de trading listos para ser usados.

Puede usar también sus propias clases con la implementación de estos módulos. Créelos por sí mismos o
pídalos a través del servicio Trabajos.

En este artículo vamos a ver la generación automática de código fuente de asesores expertos usando el MQL5
Wizard. ¡Y no habrá que programar nada!

1. Crear un robot de trading usando MQL5 Wizard

El código fuente de los asesores expertos se genera usando el MQL5 Wizard en MetaEditor.

Las clases básicas de estrategias de trading se encuentran en la carpeta '\

<client_terminal_directory>\MQL5\Include\Expert\'. Los algoritmos de clases de señales de trading listos para
su uso, las clases de posiciones abiertas de arrastre y las clases de gestión de dinero y riesgo se encuentran en
las subcarpetas Signal, Trailing y Money. El MQL5 Wizard analiza los archivos en estas carpetas y los utiliza
para generar código del asesor experto.

Para ejecutar el MQL5 Wizard necesita hacer clic en el botón "Nuevo" en la barra de herramientas o
seleccionar "Nuevo" en el menú "Archivo" (o simplemente pulsar Ctrl+N):

Fig. 1. Ejecutar el MQL5 Wizard

A continuación seleccione el tipo de programa que quiere crear. En nuestro caso seleccionamos la opción
(generar) "Asesor experto":
 Fig. 2. Seleccionar el tipo de programa

Paso 1. Propiedades generales del asesor experto

A continuación se abre el cuadro de diálogo donde podemos establecer las propiedades generales del asesor
experto:

Fig. 3. Propiedades generales del Expert Advisor

Especificamos el nombre de nuestro asesor experto, el nombre del autor y el enlace a nuestro sitio web en los
campos "Nombre", "Autor" y "Enlace" (respectivamente).

El asesor experto tiene también los siguientes parámetros de entrada.

Símbolo (el tipo de string) - símbolo de trabajo para el asesor experto.

 Periodo de tiempo (el tipo de periodo de tiempo) - periodo de tiempo de trabajo para el asesor experto.

En el siguiente paso seleccionamos el tipo de señales de trading sobre las que operará el experto.

Paso 2. Seleccionar el módulo de señales de trading

El algoritmo de apertura y cierre de posiciones viene determinado por el módulo de las señales de trading. Los
módulos de las señales de trading contienen reglas para la apertura/cierre/inversión de posiciones.
La librería estándar tiene módulos de señales de trading listas para usar:

1. CSignalAC - el módulo de señales basado en los modelos de mercado del indicador oscilador acelerador.
2. CSignalAMA - el módulo de señales basado en los modelos de mercado del indicador media móvil
adaptativa.
3. CSignalAO - el módulo de señales basado en los modelos de mercado del indicador oscilador
impresionante.
4. CSignalBearsPower - el módulo de señales basado en los modelos de mercado del oscilador poder de
osos.
5. CSignalBullsPower - el módulo de señales basado en los modelos de mercado del oscilador poder de
toros.
6. CSignalCCI - el módulo de señales basado en los modelos de mercado del oscilador índice de canal de
producto.
7. CSignalDeM - el módulo de señales basado en los modelos de mercado del oscilador DeMarker.
8. CSignalDEMA - el módulo de señales basado en los modelos de mercado del indicador media móvil doble
exponencial.
9. CSignalEnvelopes - el módulo de señales basado en los modelos de mercado del indicador Envelopes.
10. CSignalFrAMA - el módulo de señales basado en los modelos de mercado del indicador media móvil
adaptativa fractal.
11. CSignalITF - módulo de filtración de señales por tiempo.
12. CSignalMACD - el módulo de señales basado en los modelos de mercado del oscilador MACD.
13. CSignalMA - el módulo de señales basado en los modelos de mercado del indicador media móvil.
14. CSignalSAR - el módulo de señales basado en los modelos de mercado del indicador SAR parabólico.
15. CSignalRSI - el módulo de señales basado en los modelos de mercado del oscilador índice de resistencia
relativa.
16. CSignalRVI - el módulo de señales basado en los modelos de mercado del oscilador índice de vigor
relativo.
17. CSignalStoch - el módulo de señales basado en los modelos de mercado del oscilador estocástico.
18. CSignalTRIX - el módulo de señales basado en los modelos de mercado del oscilador media exponencial
triple.
19. CSignalTEMA - el módulo de señales basado en los modelos de mercado del indicador media móvil
exponencial triple.
20. CSignalWPR - el módulo de señales basado en los modelos de mercado del oscilador rango porcentual de
Williams.

El tipo de señales de trading se selecciona de la lista desplegable "Nombre".

Después de pulsar el botón "Siguiente" verá una ventana:
 Fig. 4. Selección de señales de trading del Expert Advisor

Para añadir un módulo de señales de trading presione el botón "Añadir".

Vamos a añadir señales de trading basadas en el indicador de media móvil.

Fig. 5. Seleccionar el algoritmo de señales de trading

Cada módulo de señales de trading tiene sus propios parámetros. Puede usar los valores por defecto.

Hay dos formas de crear los parámetros. Puede cambiar entre ellas haciendo doble clic con el botón
izquierdo del ratón en el icono del parámetro. Si el parámetro tiene el icono resaltado éste estará
disponible como la variable de entrada del asesor experto. Dichos parámetros pueden usarse
 posteriormente para la optimización del experto en el probador de estrategias. Si el parámetro tiene el
icono gris tendrá un valor fijo que no podrá modificarse en las propiedades del asesor experto.

El módulo de señales de trading aparecerá en la lista:

Fig. 6. Se ha añadido el módulo de señales de trading

Paso 3. Seleccionar el módulo de rastreo de posiciones abiertas

El siguiente paso es seleccionar el algoritmo de rastreo de posiciones abiertas (Trailing Stop). El uso del
arrastre nos permite ahorrar el beneficio obtenido.
La librería estándar proporciona varias formas de rastrear posiciones abiertas:

1. CTrailingNone - Trailing Stop no se usa.

2. CTrailingFixedPips - Trailing Stop basada en una Stop Level fija.
3. CTrailingMA - Trailing Stop basada en la MA.
4. CTrailingPSAR - Trailing Stop basada en el SAR parabólico.  

En nuestro asesor experto seleccionamos "Trailing Stop basada en Stop Level":

 Fig. 7. Seleccionar el algoritmo de posiciones abiertas de arrastre

Este tipo de arrastre tiene dos parámetros: StopLevel y ProfitLevel (en puntos para cotizaciones con 2 y 4
dígitos después de la coma) que serán usados para rastrear posiciones abiertas:

Fig. 9. Establecer los parámetros del algoritmo seleccionado de rastreo de posiciones abiertas

Paso 4. Seleccionar el módulo de gestión de dinero y riesgo

En el último paso necesitamos seleccionar el sistema de gestión de dinero y riesgo que será usado en nuestro
asesor experto.
El propósito de este algoritmo es determinar el volumen de transacciones (en lotes) para las operaciones de
trading y también la gestión del riesgo. Cuando el valor de pérdida excede el límite permitido (por ejemplo,
10% de las acciones) el módulo de gestión de dinero y riesgo cerrará forzosamente la posición no rentable.
La librería estándar proporciona varias implementaciones de los algoritmos de gestión de dinero y riesgos
listas para ser usadas:

1. CMoneyFixedLot - Operar con un volumen de transacciones fijo

2. CMoneyFixedMargin - Operar con un margen fijo.
3. CMoneyFixedRisk - Operar con un riesgo fijo.
4. CMoneyNone - Operar con el volumen de transacciones mínimo permitido.
5. CMoneySizeOptimized - Operar con el volumen de transacción optimizado.

Fig. 9. Seleccionar el algoritmo de gestión de dinero y riesgo

Seleccionar el algoritmo "Operar con volumen de transacciones fijo".

El módulo que hemos seleccionado tiene dos parámetros:

Lotes - volumen de transacciones en lotes.

Porcentaje - porcentaje de riesgo máximo permitido.
 Fig. 10. Establecer los parámetros del algoritmo seleccionado de gestión de dinero y riesgo

Después de hacer clic en "Finalizar" aparecerá el archivo TestExpert.mq5 en la carpeta

\teminal_data_filder\MQL5\Experts\. El nombre del archivo es el nombre del asesor experto especificado.

2. Estructura del asesor experto creado usando el MQL5 Wizard

El código fuente generado por el MQL5 Wizard es el siguiente:

//+------------------------------------------------------------------+
//| TestExpert.mq5 |
//| Copyright 2012, MetaQuotes Software Corp. |
//| https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2012, MetaQuotes Software Corp."
#property link "https://www.mql5.com"
#property version "1.00"
//+------------------------------------------------------------------+
//| Include |
//+------------------------------------------------------------------+
#include <Expert\Expert.mqh>
//--- available signals
#include <Expert\Signal\SignalMA.mqh>
//--- available trailing
#include <Expert\Trailing\TrailingFixedPips.mqh>
//--- available money management
#include <Expert\Money\MoneyFixedLot.mqh>
//+------------------------------------------------------------------+
//| Inputs |
//+------------------------------------------------------------------+
//--- inputs for expert
input string Expert_Title ="TestExpert"; // Document name
ulong Expert_MagicNumber =23689; //
bool Expert_EveryTick =false; //
//--- inputs for main signal
input int Signal_ThresholdOpen =10; // Signal thresho
input int Signal_ThresholdClose =10; // Signal thresho
input double Signal_PriceLevel =0.0; // Price level to
input double Signal_StopLevel =50.0; // Stop Loss leve
input double Signal_TakeLevel =50.0; // Take Profit le
input int Signal_Expiration =4; // Expiration of
input int Signal_MA_PeriodMA =85; // Moving Average
input int Signal_MA_Shift =0; // Moving Average
input ENUM_MA_METHOD Signal_MA_Method =MODE_SMA; // Moving Avera
input ENUM_APPLIED_PRICE Signal_MA_Applied =PRICE_CLOSE; // Moving Aver
input double Signal_MA_Weight =1.0; // Moving Average
//--- inputs for trailing
input int Trailing_FixedPips_StopLevel =30; // Stop Loss trai
input int Trailing_FixedPips_ProfitLevel=50; // Take Profit tr
//--- inputs for money
input double Money_FixLot_Percent =10.0; // Percent
input double Money_FixLot_Lots =0.1; // Fixed volume
//+------------------------------------------------------------------+
//| Global expert object |
//+------------------------------------------------------------------+
CExpert ExtExpert;
//+------------------------------------------------------------------+
//| Initialization function of the expert |
//+------------------------------------------------------------------+
int OnInit()
{
//--- Initializing expert
if(!ExtExpert.Init(Symbol(),Period(),Expert_EveryTick,Expert_MagicNumber))
{
//--- failed
printf(__FUNCTION__+": error initializing expert");
ExtExpert.Deinit();
return(-1);
}
//--- Creating signal
CExpertSignal *signal=new CExpertSignal;
if(signal==NULL)
{
//--- failed
printf(__FUNCTION__+": error creating signal");
ExtExpert.Deinit();
return(-2);
}
//---
ExtExpert.InitSignal(signal);
signal.ThresholdOpen(Signal_ThresholdOpen);
signal.ThresholdClose(Signal_ThresholdClose);
signal.PriceLevel(Signal_PriceLevel);
signal.StopLevel(Signal_StopLevel);
signal.TakeLevel(Signal_TakeLevel);
signal.Expiration(Signal_Expiration);
//--- Creating filter CSignalMA
CSignalMA *filter0=new CSignalMA;
if(filter0==NULL)
{
//--- failed
printf(__FUNCTION__+": error creating filter0");
ExtExpert.Deinit();
return(-3);
}
signal.AddFilter(filter0);
//--- Set filter parameters
filter0.PeriodMA(Signal_MA_PeriodMA);
filter0.Shift(Signal_MA_Shift);
filter0.Method(Signal_MA_Method);
filter0.Applied(Signal_MA_Applied);
filter0.Weight(Signal_MA_Weight);
//--- Creation of trailing object
CTrailingFixedPips *trailing=new CTrailingFixedPips;
if(trailing==NULL)
{
//--- failed
printf(__FUNCTION__+": error creating trailing");
ExtExpert.Deinit();
return(-4);
 }
//--- Add trailing to expert (will be deleted automatically))
if(!ExtExpert.InitTrailing(trailing))
{
//--- failed
printf(__FUNCTION__+": error initializing trailing");
ExtExpert.Deinit();
return(-5);
}
//--- Set trailing parameters
trailing.StopLevel(Trailing_FixedPips_StopLevel);
trailing.ProfitLevel(Trailing_FixedPips_ProfitLevel);
//--- Creation of money object
CMoneyFixedLot *money=new CMoneyFixedLot;
if(money==NULL)
{
//--- failed
printf(__FUNCTION__+": error creating money");
ExtExpert.Deinit();
return(-6);
}
//--- Add money to expert (will be deleted automatically))
if(!ExtExpert.InitMoney(money))
{
//--- failed
printf(__FUNCTION__+": error initializing money");
ExtExpert.Deinit();
return(-7);
}
//--- Set money parameters
money.Percent(Money_FixLot_Percent);
money.Lots(Money_FixLot_Lots);
//--- Check all trading objects parameters
if(!ExtExpert.ValidationSettings())
{
//--- failed
ExtExpert.Deinit();
return(-8);
}
//--- Tuning of all necessary indicators
if(!ExtExpert.InitIndicators())
{
//--- failed
printf(__FUNCTION__+": error initializing indicators");
ExtExpert.Deinit();
return(-9);
}
//--- ok
return(0);
}
//+------------------------------------------------------------------+
//| Deinitialization function of the expert |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
ExtExpert.Deinit();
}
//+------------------------------------------------------------------+
//| "Tick" event handler function |
//+------------------------------------------------------------------+
void OnTick()
{
ExtExpert.OnTick();
}
//+------------------------------------------------------------------+
//| "Trade" event handler function |
//+------------------------------------------------------------------+
void OnTrade()
{
 ExtExpert.OnTrade();
}
//+------------------------------------------------------------------+
//| "Timer" event handler function |
//+------------------------------------------------------------------+
void OnTimer()
{
ExtExpert.OnTimer();
}
//+------------------------------------------------------------------+

El código del asesor experto comprende varias secciones.

Sección que describe las propiedades del programa:

#property copyright "Copyright 2012, MetaQuotes Software Corp."

#property link "https://www.mql5.com"
#property version "1.00"

Archivos incluidos:

#include <Expert\Expert.mqh>
//--- available signals
#include <Expert\Signal\SignalMA.mqh>
//--- available trailing
#include <Expert\Trailing\TrailingFixedPips.mqh>
//--- available money management
#include <Expert\Money\MoneyFixedLot.mqh>

El código de la clase CExpert (su instancia se usa en el asesor experto) se encuentra en el archivo Expert.mqh.
 
El archivo SignalMA.mqh contiene el código fuente de la clase de señales de trading seleccionada -
CSignalMA. El archivo TrailingFixedPips.mqh contiene el código fuente de la clase del algoritmo del rastreo de
posiciones abiertas - CTrailingFixedPips. La gestión de dinero y riesgo será implementada por la clase
CMoneyFixedLot contenida en el archivo MoneyFixedLot.mqh.
A continuación vienen los parámetros de entrada del asesor experto:

//--- inputs for expert

input string Expert_Title ="TestExpert"; // Document name
ulong Expert_MagicNumber =23689; //
bool Expert_EveryTick =false; //
//--- inputs for main signal
input int Signal_ThresholdOpen =10; // Signal thresho
input int Signal_ThresholdClose =10; // Signal thresho
input double Signal_PriceLevel =0.0; // Price level to
input double Signal_StopLevel =50.0; // Stop Loss leve
input double Signal_TakeLevel =50.0; // Take Profit le
input int Signal_Expiration =4; // Expiration of
input int Signal_MA_PeriodMA =85; // Moving Average
input int Signal_MA_Shift =0; // Moving Average
input ENUM_MA_METHOD Signal_MA_Method =MODE_SMA; // Moving Averag
input ENUM_APPLIED_PRICE Signal_MA_Applied =PRICE_CLOSE; // Moving Avera
input double Signal_MA_Weight =1.0; // Moving Average
//--- inputs for trailing
input int Trailing_FixedPips_StopLevel =30; // Stop Loss trai
input int Trailing_FixedPips_ProfitLevel=50; // Take Profit tr
//--- inputs for money
input double Money_FixLot_Percent =10.0; // Percent
input double Money_FixLot_Lots =0.1; // Fixed volume
Los primeros tres parámetros (Expert_Title, Expert_MagicNumber son Expert_EveryTick) son generales. Están
siempre presentes con independencia de los algoritmos trading signals, trailing, y money and risk management
seleccionados.
El parámetro Expert_Title especifica el nombre del asesor experto, Expert_MagicNumber especifica su ID (este
valor se usará en los parámetros de las solicitudes de operaciones) y el parámetro Expert_EveryTick se usa
para establecer el modo de funcionamiento del asesor experto. Si Expert_EveryTick se establece en el valor
verdadero, el asesor experto llamará a las funciones del controlador (comprobar las condiciones de
operatividad, comprometer operaciones, rastrear posiciones abiertas) cada vez que llegue un nuevo tick para
el símbolo en funcionamiento.
Después de los parámetros generales del asesor experto vienen los parámetros de entrada para el algoritmo
de señales de transacciones elegido (en nuestro caso son los parámetros usados en la clase CSignalMA).
Hemos elegido la clase CTrailingStopFixedPips del rastreo de posiciones abiertas. Esta clase rastrea las
posiciones abiertas a una distancia fija determinada por los niveles de Stop Loss y Take Profit, cuyos valores se
definen en puntos digitales 2/4 "normales". Cuando el precio se mueve hacia la posición abierta a una
distancia que excede el número de puntos establecido por el nivel de Trailing_FixedPips_StopLevel, el asesor
experto modifica los valores de los niveles de Stop Loss y Take Profit (si Trailing_FixedPips_StopLevel > 0).  
Los parámetros de entrada Money_FixLot_Percent y Money_FixLot_Lots corresponden a los parámetros del
algoritmo con el lote de transacciones fijo implementado en la clase CMoneyFixedLot. En nuestro caso, la
transacción se realizará con un volumen fijo igual al valor de Money_FixLot_Lots.
La clase Money_FixLot_Lots también implementa el algoritmo de gestión de riesgo: si hay una pérdida (como
un porcentaje de la acción actual) especificada en el parámetro Inp_Money_FixLot_Percent, la clase
CMoneyFixedLot recomendará al asesor experto el cierre forzado de la posición no rentable y esto se llevará a
cabo.
A continuación, se declaran los parámetros de entrada del asesor experto del objeto ExtExpert de la clase
CExpert:

CExpert ExtExpert;

Esta es la instancia de la clase de la estrategia de trading.

Al ser una instancia de la clase CExpert, el objeto ExtExpert contiene referencias a los objetos hijos de la
clase CExpertSignal (la clase básica de señales de trading), la clase CExpertMoney (la clase básica de la
gestión de de dinero y riesgo) y la clase CExpertTrailing (la clase básica del rastreo de posiciones abiertas).
Además, la clase CExpert contiene las instancias de las clases CExpertTrade, SSymbolInfo, CAccountInfo,
CPositionInfo, COrderInfo y el contenedor CIndicators.
Para establecer los parámetros del asesor experto tenemos que crear instancias de las clases correspondientes
y especificar las referencias a los objetos creados en la clase ExtExpert.
Vamos a ver la función OnInit de inicialización del asesor experto. Aquí inicializamos y configuramos las
propiedades de la clase ExtExpert.

1. Inicialización de la clase ExtExpert:

//--- Initializing expert

if(!ExtExpert.Init(Symbol(),Period(),Expert_EveryTick,Expert_MagicNumber))
{
//--- failed
printf(__FUNCTION__+": error initializing expert");
ExtExpert.Deinit();
return(-1);
}

El objeto ExtExpert es inicializado usando el método Init. Aquí establecemos el símbolo, el periodo de tiempo,
el flag del método que llama en cada tick, el ID del asesor experto y también creamos e inicializamos los
objetos privados de las clases (en esta etapa las clases CExpertSignal, CExpertMoney y CExpertTrailing como
las señales, rastreo y objetos de gestión de dinero).
Si el objeto ExtExpert no se inicializa con éxito, el asesor experto finalizará devolviendo el código -1.
2. Crear y configurar las propiedades del objeto Señal

//--- Creating signal

CExpertSignal *signal=new CExpertSignal;
if(signal==NULL)
{
//--- failed
printf(__FUNCTION__+": error creating signal");
ExtExpert.Deinit();
return(-2);
}
//---
ExtExpert.InitSignal(signal);
signal.ThresholdOpen(Signal_ThresholdOpen);
signal.ThresholdClose(Signal_ThresholdClose);
signal.PriceLevel(Signal_PriceLevel);
signal.StopLevel(Signal_StopLevel);
signal.TakeLevel(Signal_TakeLevel);
signal.Expiration(Signal_Expiration);
//--- Creating filter CSignalMA
CSignalMA *filter0=new CSignalMA;
if(filter0==NULL)
{
//--- failed
printf(__FUNCTION__+": error creating filter0");
ExtExpert.Deinit();
return(-3);
}
signal.AddFilter(filter0);
//--- Set filter parameters
filter0.PeriodMA(Signal_MA_PeriodMA);
filter0.Shift(Signal_MA_Shift);
filter0.Method(Signal_MA_Method);
filter0.Applied(Signal_MA_Applied);
filter0.Weight(Signal_MA_Weight);

La configuración de las señales de trading comprende varias etapas:

Creación del objeto de la señal y establecimiento de sus parámetros

Creación del módulo de señales de trading y su adición a la instancia de clase CExpertSignal.

Si el objeto ExtExpert no se inicializa con éxito, el asesor experto finalizará devolviendo un código (entre -2 y
-3) que depende del paso en el que haya ocurrido el error.

Dependiendo de la forma en que se especifiquen los parámetros en el MQL5 Wizard, se genera el código
apropiado.

//--- Set signal parameters

filter0.PeriodMA(85); //--- Parameter was set as fixed in
//--- (gray icon - fixed value eq
filter0.SlowPeriod(Signal_MA_Shift); //--- Parameter was set as input variab
//--- (blue icon - input paramete

Si el parámetro es fijo y su valor no difiere del valor por defecto, no se escribirá en el código generado. En
tal caso se usará el valor por defecto del parámetro (especificado en la clase correspondiente).

3. Crear y configurar las propiedades del objeto de rastreo

//--- Creation of trailing object

CTrailingFixedPips *trailing=new CTrailingFixedPips;
if(trailing==NULL)
 {
//--- failed
printf(__FUNCTION__+": error creating trailing");
ExtExpert.Deinit();
return(-4);
}
//--- Add trailing to expert (will be deleted automatically))
if(!ExtExpert.InitTrailing(trailing))
{
//--- failed
printf(__FUNCTION__+": error initializing trailing");
ExtExpert.Deinit();
return(-5);
}
//--- Set trailing parameters
trailing.StopLevel(Trailing_FixedPips_StopLevel);
trailing.ProfitLevel(Trailing_FixedPips_ProfitLevel);

La configuración del objeto de rastreo también comprende varias etapas:

Creación del objeto de rastreo;

Adición del rastreo al experto;
Establecer los parámetros de rastreo;

Si el objeto de rastreo no se inicializa con éxito, el asesor experto finalizará devolviendo un código (entre -4 y
-5) que depende del paso en el que haya ocurrido el error.

4. Crear y configurar las propiedades del objeto de dinero

//--- Creation of money object

CMoneyFixedLot *money=new CMoneyFixedLot;
if(money==NULL)
{
//--- failed
printf(__FUNCTION__+": error creating money");
ExtExpert.Deinit();
return(-6);
}
//--- Add money to expert (will be deleted automatically))
if(!ExtExpert.InitMoney(money))
{
//--- failed
printf(__FUNCTION__+": error initializing money");
ExtExpert.Deinit();
return(-7);
}
//--- Set money parameters
money.Percent(Money_FixLot_Percent);
money.Lots(Money_FixLot_Lots);

La configuración del objeto de gestión de dinero y riesgo también comprende varias etapas:

Creación del objeto de dinero;

Adición del dinero al experto;
Establecer los parámetros del dinero;

Si el objeto de dinero no se inicializa con éxito, el asesor experto finalizará devolviendo un código (entre -6 y
-7) que depende del paso en el que haya ocurrido el error.

5. Inicializar todos los indicadores usados en las clases

//--- Check all trading objects parameters

if(!ExtExpert.ValidationSettings())
{
 //--- failed
ExtExpert.Deinit();
return(-8);
}
//--- Tuning of all necessary indicators
if(!ExtExpert.InitIndicators())
{
//--- failed
printf(__FUNCTION__+": error initializing indicators");
ExtExpert.Deinit();
return(-9);
}
//--- ok
return(0);

Después de crear e inicializar objetos de señales de trading, rastreo y gestión de dinero, se llama al método
ValidationSettings() del objeto ExtExpert. Después de esto, se llama al método InitIndicators() del objeto
ExtExpert. Esto inicializa los indicadores usados en los objetos de la señal, rastreo y dinero.
El control de los eventos OnDeinit, OnTick, OnTrade y OnTimer se realiza llamando a los métodos adecuados
de la clase ExtExpert.
Si quiere conocer los detalles de la implementación de los métodos CExpert, puede ver el código fuente del
indicador que se encuentra en '\<client_terminal_directory>\MQL5\Include\Expert\expert.mqh'.

3. Comprobando el asesor experto creado en el probador de estrategias de MetaTrader 5

Si están presentes todos los componentes de la librería estándar, el código del asesor experto se compila con
éxito:
 Figura 10. Compilación con éxito del código fuente del Expert Advisor creado en el MQL5 Wizard

El asesor experto resultante operará de acuerdo con los algoritmos elegidos de las señales de trading, rastreo
de posiciones abiertas y gestión de dinero y riesgo.
Puede comprobar el funcionamiento de su sistema de trading recién creado usando el probador de estrategias
del terminal de cliente de MetaTrader 5. En la figura 11 puede ver los resultados de la prueba sobre los datos
históricos con los ajustes por defecto (EURUSD, H1, 2010.01.01-2011.06.01):
 Figura 11. Resultados de la prueba del Expert Advisor sobre los datos históricos (EURUSD, H1)

El mejor conjunto de parámetros del asesor experto puede obtenerse después de la optimización en el
probador de estrategias de MetaTrader 5.

Conclusión
El uso de las clases de estrategias de trading facilita considerablemente la creación y la prueba de sus ideas
de trading. Ahora puede construirse todo el código fuente del asesor experto directamente en MetaEditor
usando su MQL5 Wizard en base a los módulos de la librería estándar lista para ser usada, empleándolos en sus
propios módulos. 
Si no quiere o no puede escribir sus propios módulos de señales de trading, siempre puede beneficiarse del
servicio trabajos y encargar todo un robot de trading o solo los módulos que necesite. Este enfoque
proporciona beneficios adicionales:

Los costes de desarrollo de módulos separados deben ser inferiores al coste del asesor experto al
completo.
El módulo resultante puede reutilizarse para crear tanto un asesor experto autónomo como una familia
completa de robots de trading (basados en este módulo) usando el MQL5 Wizard.
El módulo adquirido debe cumplir estrictamente los requisitos del MQL5 Wizard, y esto proporciona un
control adicional sobre la calidad del código.