Programación de robots Forex: cómo crear tu propio robot

Hay muchísimas cosas que puedes hacer con un robot de trading en el mercado Forex. El uso más común es la automatización de estrategias de trading. En este artículo, examinaremos los conceptos básicos para programar un robot de trading para Forex. Comenzaremos respondiendo a la pregunta: “¿Qué tipos de código se pueden programar en el lenguaje MQL4/MQL5?”. 

¿Qué tipos de código se pueden programar en el lenguaje MQL4/MQL5?

Los ejemplos que analizaremos aquí se basan en el lenguaje de programación MQL4/MQL5. En MQL4/MQL5 se pueden escribir tres tipos de código:

• Expert Advisors (robots de Forex)
• Indicadores personalizados
• Scripts

1. El Expert Advisor (EA)

Representa la automatización de un sistema de trading manual que se vincula al gráfico de un activo financiero específico. En otras palabras, cualquier código que escribas para un EA debe desarrollarse teniendo en cuenta el gráfico de ese activo.

Algunos de estos eventos se ejecutan una sola vez, mientras que otros lo hacen de forma continua hasta recibir la instrucción de detenerse. Por lo tanto, un EA comenzará a operar una vez que se activen los eventos que forman la secuencia de inicialización (init) del código. 

Estos eventos incluyen un nuevo nivel de precio o tick, un evento en el gráfico o eventos personalizados. En cuanto se activan, el EA envía una orden al servidor del broker para abrir o cerrar una operación. Los archivos de los EA se guardan en la carpeta MQL4/Experts del terminal de MT4. 

2. El script

Es un código diseñado para ejecutar funciones una sola vez, como el evento Start. Los archivos de script se guardan en la carpeta MQL4/scripts del terminal de MT4. 

3. El indicador personalizado

Se trata de un indicador técnico a medida que no viene incluido de forma nativa en MT4. No se utiliza para ejecutar operaciones directamente, sino para identificar eventos en el gráfico que pueden desencadenar actividad de trading manual o mediante un EA. Los archivos de indicadores personalizados se guardan en la carpeta MQL4/indicators del terminal de MT4. 

Cómo crear un robot de Forex con código MQL4/MQL5

El código desarrollado para un robot de trading para Forex, indicador o script en MQL4/MQL5 incluye sintaxis, variables, expresiones y sentencias condicionales. Veamos cómo construir tu robot a partir de estos cuatro elementos: 

En lo que resta de este artículo, nos referiremos principalmente a MQL4, pero todo lo explicado aplica de igual forma a MQL5.

1. Familiarízate con la sintaxis

La sintaxis de programación es el conjunto de reglas que definen la escritura y la estructura del código dentro de un lenguaje determinado.

La correcta compilación y ejecución del código de un robot de Forex dependen de que escribas una sintaxis sin errores y adecuada para el lenguaje con el que vas a desarrollar el Expert Advisor, script o indicador. 

Estos son algunos componentes clave de la sintaxis de MQL4:

• Comentarios: líneas de texto dentro del programa que el compilador o intérprete pasa por alto. Los desarrolladores los usan para documentar el código y facilitar su comprensión. Los comentarios de varias líneas van entre /* y */, mientras que los de una sola línea comienzan con //.
• Variables: espacios con nombre en la memoria de la computadora que almacenan datos. El valor guardado en una variable puede cambiar durante la ejecución del programa.
• Tipos de datos: clasificaciones que definen qué clase de valor puede almacenar una variable. Algunos ejemplos son int (enteros), double (números decimales de punto flotante para precios), bool (verdadero/falso), string (texto), datetime (fecha y hora) y color.
• Identificadores: nombres que se asignan a elementos dentro del programa, como variables, funciones, clases o módulos. Deben comenzar con una letra o un guion bajo, pueden contener letras, dígitos y guiones bajos, y tienen un límite de 63 caracteres. Además, no pueden coincidir con palabras reservadas de MQL4.
• Operadores: símbolos que actúan sobre uno o más operandos (valores o variables). Se emplean en operaciones aritméticas, de comparación, lógicas o de asignación. Algunos ejemplos son +, -, =, !=, || y &&.
• Sentencias condicionales: controlan el flujo del programa ejecutando diferentes bloques de código según si una condición resulta verdadera o falsa. Por ejemplo: sentencias “if”, “else if” y “else”.
• Bucles: controlan el flujo de ejecución permitiendo repetir un bloque de código mientras se cumpla una condición. Resultan útiles para recorrer colecciones de datos o realizar tareas repetitivas. Algunos ejemplos de bucles son “for”, “while” y “do-while”.
• Funciones: bloques de código diseñados para realizar una tarea específica. Dividen el programa en partes más pequeñas, haciéndolo más legible y evitando la redundancia.

Como puedes ver, el entorno de programación de MQL4 está preparado para admitir diversas funciones de sintaxis, lo que brinda un entorno ideal para desarrollar indicadores y robots de trading para Forex sólidos.

2. Comienza con la declaración e inicialización

Las variables son la base de tu código. Pero antes de usarlas, debes crearlas. Esta acción de crear una variable se conoce como declaración, por lo que a menudo se usan los términos “crear” o “declarar” de forma indistinta, aunque en el desarrollo de software se prefiere “declaración”. Al declarar una variable, le indicas al programa que la cree asignándole un tipo de datos. 

Para declarar una variable: 

• escribe el tipo de datos, seguido de un espacio; 
• escribe el nombre de la variable; 
• finaliza la línea con un punto y coma (;). 

Observa cómo se declara una variable con el tipo de datos entero (int):

• Aquí, el tipo de datos es int (entero).
• El nombre de la variable es hi.
• La línea termina con un punto y coma.

Las variables se definen especificando un tipo de datos (como int para enteros o double para números de punto flotante), seguido de un nombre para la variable (identificador). Para crearla, primero debes definir su tipo. Entre los tipos de datos más comunes están:

1. Entero (int): representa cualquier número entero comprendido entre -2,000 millones y +2,000 millones. No puede almacenar decimales.
2. Double: representa números que van desde -1.79 x 10³⁰⁸ hasta +1.79 x 10³⁰⁸. Permite almacenar valores con punto decimal.
3. Booleano (bool): representa datos lógicos con valor verdadero (true) o falso (false).
4. Color: almacena valores de color.
5. String: representa una cadena o línea de texto.
6. DateTime: almacena fecha y hora. 

Por ejemplo, imagina que tienes las variables x, y y z con los números enteros 10, 7 y 5. Si decides definir una nueva información para una variable a, puedes establecer que a = y + z. Dado que los valores de y y z ya están definidos, el resultado para a será 12.

Por ejemplo, para declarar una variable entera llamada “myVar”, utilizarías la siguiente sintaxis:

int myVar

También puedes asignar un valor a una variable al momento de declararla. Supongamos que queremos que el valor asignado sea 12. Usaremos la siguiente sintaxis para declarar este valor asignado a la variable entera myVar. 

int myVar = 10;

Una vez declarada la variable, puedes usarla en el código MQL para realizar diversas operaciones o cumplir con su función habitual de almacenar datos. Por lo tanto, si vas a definir la nueva variable a como la suma de los enteros y + z, puedes ingresarlo en este formato: 

int var1 = 10;
int var2 = 7;
Int var3 = 5

int result = var2 + var3; // result = 12

En este ejemplo, has declarado tres variables enteras denominadas var1, var2 y var3 (o x, y y z), asignándoles los valores 10, 7 y 5, respectivamente. Solo te interesa sumar var2 y var3 para obtener un nuevo entero para la variable a. Usas el signo + como operador y int result funciona como la nueva variable para a. El valor resultante será 12, que surge de sumar var2 y var3.

En el trading propiamente dicho, una función práctica de declarar o crear variables es almacenar valores que cambian con el tiempo, como el precio de un activo. La cotización de las divisas fluctúa constantemente, por lo que puedes usar una variable para guardar y actualizar esta información cada vez que se produce un nuevo tick. 

double price;

price = SymbolInfoDouble(_Symbol, SYMBOL_BID); // get the current bid price

ol, SYMBOL_BID); // get the current bid price

En un mercado tan dinámico como el de Forex, es indispensable incorporar variables en el código de la estrategia de tu robot de Forex para reflejar esa volatilidad y adaptarte a los cambios del mercado.

3. Expresiones

Las operaciones son similares a los cálculos aritméticos habituales: suma, resta, multiplicación y división. Los símbolos que las representan se denominan operadores. Al combinarse con variables en una misma línea de código, forman expresiones. 

Estos son los operadores más comunes en el código MQL4:

a) Operadores aritméticos: suma, resta, porcentaje, división, multiplicación (+ - % / *)

b) Operadores lógicos: && ||

c) Operadores de asignación: igual, suma e igual, y multiplicación e igual (= += *=)

Una expresión terminada con un punto y coma (;) constituye una sentencia u operación. Entonces, ¿cuáles son las expresiones más útiles para un programador en MQL4?

Los operadores aritméticos se emplean para realizar cálculos matemáticos con valores numéricos. Así es como se ven en el código: 

El operador ++ le indica al código que aumente en 1 el valor de b en la línea 27; por lo tanto, si b = 70, el código asignará un valor de 70 + 1 (o 71) cada vez que aparezca b++. De igual forma, el operador -- le indica al código que reste 1 al valor de b en la línea 28, asignando un valor de 69 cuando se ejecute b--.

Aquí tienes otro ejemplo de expresión con operadores aritméticos:

La directiva “#include <math.mqh>” le indica al código que habilite las funciones de la librería Math para evitar errores al compilar. Las funciones de esta librería que aparecen aquí son MathPow() y MathSqrt().

¿Qué significa cada uno de los operadores aritméticos? 

• Suma (+): suma los valores numéricos situados a la izquierda y a la derecha del operador.
• Resta (-): resta el valor numérico a la derecha del operador del valor numérico a su izquierda.
• Multiplicación (*): multiplica los valores situados a ambos lados del operador.
• División (/): divide el valor numérico a la izquierda del operador entre el valor numérico a su derecha. 
• Módulo (%): devuelve el resto de dividir el valor de la izquierda entre el valor de la derecha.

Así es como se ven en el entorno de desarrollo de MQL4:

Como 10 se puede dividir exactamente entre 5 dos veces sin dejar resto, el resultado de 10 % 5 en la línea 23 será 0.

Los operadores de asignación se utilizan para darle un valor a una variable. Este es el significado de los principales operadores de asignación (= += -= *=):

• Asignación (=): asigna el valor situado a la derecha del operador a la variable ubicada a la izquierda.
• Asignación con suma (+=): suma el valor de la derecha al valor actual de la variable de la izquierda y guarda el resultado en dicha variable para darle un nuevo valor.
• Asignación con resta (-=): resta el valor de la derecha del valor actual de la variable de la izquierda y guarda el resultado en ella para darle un nuevo valor.
• Asignación con multiplicación (*=): multiplica el valor de la derecha por el valor actual de la variable de la izquierda y asigna el resultado a dicha variable.
• Asignación con división (/=): divide el valor de la variable de la izquierda entre el valor de la derecha y guarda el resultado en la variable de la izquierda.
• Asignación con módulo (%=): calcula el módulo entre la variable de la izquierda y el valor de la derecha, y guarda el resultado en la variable de la izquierda.

Aquí tienes algunos ejemplos de cómo se utilizan los operadores de asignación en MQL4:

4. Operadores condicionales (if/else, switch)

Los operadores condicionales se utilizan para ejecutar funciones que dependen de que se cumplan ciertos parámetros o condiciones. En esencia, te permiten realizar una acción siempre que una condición previa resulte verdadera. 

En MT4, las estructuras condicionales principales son “if-else” y “switch”. Ambas sirven para controlar la ejecución del código en función de determinadas condiciones. 

Sentencia if-else

La sentencia “if-else” se usa normalmente cuando es necesario evaluar múltiples condiciones dentro del código:

Si compilas y ejecutas este script, imprimirá 10 porque la condición es verdadera. Si necesitas ejecutar varias sentencias bajo esta condición, puedes agruparlas entre llaves.

En el contexto del mercado, la sentencia if-else se emplea con frecuencia para determinar cómo procesa el código las variables de precio.

Aquí tienes un ejemplo de cómo funciona la condición if-else. En este caso, la variable “price” toma por defecto el valor del precio ask del mercado. La parte “if” verifica si el precio es superior a 1.0. Si lo es, solo se ejecutará el código dentro del primer bloque de llaves. De lo contrario (es decir, si el precio es menor o igual a 1.0), el flujo evaluará las siguientes condiciones. 

//+--------------------------------------------------------+
//| Script program start function                          |
//+--------------------------------------------------------+
void OnStart(){
    double price = Bid;
    if (price > 1.0) {
        // Execute this code if price is greater than 1.0
        Alert("Price is above 1.0");
    }else if (price < 0.5) {
        // Execute this code if price is less than 0.5
        Alert("Price is below 0.5");
    }else {
        // Execute this code if price is between 0.5 and 1.0
        Alert("Price is between 0.5 and 1.0");
    }
}

También puedes crear una sentencia “if-else” dentro de otra ya existente, es decir, dentro de las llaves del bloque “if” o “else”. A esto se le conoce como sentencia if-else anidada. A continuación puedes ver un ejemplo:

La sentencia if-else anidada le pide al código comprobar si el precio es menor que 0.8 o si se encuentra entre 0.8 y el objetivo. Si el precio está por debajo de 0.8, se ejecuta el código dentro del if anidado; si no, se ejecuta el bloque else correspondiente. 

Las sentencias condicionales se pueden aplicar al trading para gestionar órdenes pendientes de entrada y de salida. Nos referimos a órdenes como Buy Limit, Sell Limit, Buy Stop, Sell Stop, así como a los niveles de take profit y stop loss. Como ves, son órdenes que solo se ejecutan cuando se cumplen parámetros de precio específicos (una condición). Si esa condición no se cumple, no se ejecutan. Así es como se escribiría en MQL4 el código para las condiciones de entrada al mercado:

Buy Stop

Para colocar una orden Buy Stop en un nivel de precio específico, puedes usar el siguiente código. La instrucción le pide al robot de trading para Forex lo siguiente:

– Ejecutar una orden BUY STOP a una distancia de stop de 10 pips respecto al precio actual, con una distancia de límite de 20 pips.

– Usar un lote estándar (1.0 lote) como tamaño de la operación. 

– Trazar una línea verde en el gráfico sobre el precio de entrada de la orden para visualizarla fácilmente.

– Asignar un número identificador único a esta operación. 

//+------------------------------------------------------------------+
//| Expert tick function                                           |
//+------------------------------------------------------------------+
void OnTick()
{
    //---
    double StopDistance = 10.0;     // Stop distance in pips
    double LimitDistance = 20.0;    // Limit distance in pips
    double Lots = 1.0;              // Lot size
    int Slippage = 3;               // Maximum price deviation
    int MagicNumber = 12345;        // Unique identifier
    color Green = Lime;             // Order line color

    // Get the current ask price
    double price = Ask;

    // Calculate the stop and limit prices
    double stopPrice = NormalizeDouble(price + StopDistance * Point, Digits);
    double limitPrice = NormalizeDouble(price + LimitDistance * Point, Digits);

    // Place the buy stop order
    int ticket = OrderSend(Symbol(), OP_BUYSTOP, Lots, stopPrice, Slippage, limitPrice, 0, "", MagicNumber, 0, Green);

    if(ticket > 0)
    {
        Print("Buy stop order placed successfully with ticket #", ticket);
    }
    else
    {
        Print("Error placing buy stop order. Error code:", GetLastError());
    }
}

El código define las siguientes variables: 

• StopDistance
• LimitDistance
• Lots
• Slippage
• MagicNumber
• Green 

Una vez enviada la orden, el código verifica que se haya ejecutado con éxito utilizando el valor devuelto por la función OrderSend() (el ticket). Si la orden Buy Stop se ejecuta correctamente, el código imprimirá un mensaje en la pestaña Diario de MT4. Si no, imprimirá un mensaje con el código de error correspondiente.

Sell Limit

Para colocar una orden Sell Limit en un nivel de precio específico, puedes usar el siguiente código:

// Define order parameters

double lotSize = 0.1;  // Lot size
double limitPrice = 1.2000;  // Limit price
double stopLoss = 1.2100;  // Stop loss
double takeProfit = 1.1900;  // Take profit
int slippage = 3;  // Maximum deviation in pips from the requested price

// Place sell limit order
bool sellLimitOrderPlaced = false;
int ticket = 0;

while (!sellLimitOrderPlaced) {    
      ticket = OrderSend(Symbol(), OP_SELLLIMIT, lotSize, limitPrice, slippage, stopLoss, takeProfit, "Sell Limit", MagicNumber, 0, Red);    
      if (ticket > 0) {        
         sellLimitOrderPlaced = true;    
      } else {
         Print("Sell limit order failed with error code ", GetLastError());
         Sleep(5000);  // Wait for 5 seconds before retrying
      }
}

// Check if the order is still open
while (OrderSelect(ticket, SELECT_BY_TICKET)){    
      if (OrderCloseTime() > 0) {
         // Order has been closed        
         break;   
      }    

      // Wait for 1 second before checking again    
      Sleep(1000);
}

Stop loss

Así es como se le indica a un robot de trading para Forex que establezca un stop loss para una operación. Configurar el stop loss puede tener sus complejidades. Algunos programadores prefieren que el código defina el stop loss únicamente cuando la orden ya está activa; en ese caso, la instrucción debe modificar el stop loss existente.

En este código, se le pide al EA que cree una orden pendiente y luego modifique el stop loss una vez que la orden se haya ejecutado. 

// Define order parameters
double lotSize = 0.1;  // Lot size
double limitPrice = 1.2000;  // Limit price
double stopLoss = 1.2100;  // Stop loss
double takeProfit = 1.1900;  // Take profit

// Place the pending order
int ticket = OrderSend(Symbol(), OP_SELLLIMIT, lotSize, limitPrice, 0, stopLoss, takeProfit, "Sell Limit", MagicNumber, 0, Red);
if (ticket <= 0) {
    Print("Failed to place pending order with error code ", GetLastError());
} else {
    Print("Pending order placed with ticket number ", ticket);
}

// Modify the stop loss for the pending order
if (OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES)) {
    double newStopLoss = 1.2050;  // New stop loss value    
    if (!OrderModify(ticket, OrderOpenPrice(), newStopLoss, OrderTakeProfit(), 0, Green)) {
        Print("Failed to set stop loss for pending order with error code ", GetLastError());
    } else {
        Print("Stop loss set for pending order with ticket number ", ticket);
    }
} else {
    Print("Failed to select pending order with ticket number ", ticket, " with error code ", GetLastError());
}

Las variables del código se identifican con claridad:

• el tamaño de lote es 1 minilote (0.1 lotes)
• el precio límite es 1.2000
• el stop loss es 1.2100
• el take profit es 1.1900

El código también incluye la instrucción de registrar en el diario cualquier código de error si el stop loss no se puede modificar. La orden pendiente se coloca mediante la función OrderSend, utilizando las variables anteriores como parámetros.

Si la orden se coloca con éxito, el código le pide al robot de Forex que utilice la función OrderSelect (que incluye el número de ticket para su identificación). El parámetro MODE_TRADES le indica al robot que seleccione órdenes abiertas y pendientes para esta acción. 

También puedes usar la función OrderModify para cambiar los parámetros de la orden y la variable newStopLoss para modificar el stop loss. 

Ten en cuenta que al configurar estas variables debes conocer las reglas de tu broker sobre cuántas veces puedes modificar estos parámetros. 

Take profit

También puedes optar por configurar una orden de take profit mediante un código independiente si no la defines junto con el stop loss, como se mostró antes. Para ello, puedes usar el siguiente código:

void OnTick()  {

// Set take profit level
double takeProfit = 1.5; // Take profit level as a multiple of the trade's open price
double stopLoss = 1.0; // Stop loss level as a multiple of the trade's open price

// Place trade with take profit and stop loss levels
int ticket = OrderSend(Symbol(), OP_BUY, 1.0, Ask, 3, Bid - stopLoss * Point, Bid + takeProfit * Point, "My Order", MagicNumber, 0, Blue);
}

Este código utiliza una relación riesgo-beneficio de 1:1.5 para definir los objetivos de precio tanto del stop loss como del take profit. Por lo tanto, aquí el TP es 1.5 veces el precio de entrada. Nuevamente, la función OrderSend coloca la operación y se definen las variables stopLoss y takeProfit.

Switch

Por su parte, la sentencia “switch” se utiliza cuando es necesario comparar una variable frente a múltiples valores posibles. Aquí tienes un ejemplo de cómo usar las sentencias “if-else” y “switch” en MT4:

double price = Bid;
int tradeType = 2; // 0 = buy, 1 = sell, 2 = do nothing

// if-else statement
if (price > 1.0) {
    tradeType = 0;
}else if (price < 0.5) {
    tradeType = 1;
}

// switch statement
switch (tradeType) {
    case 0:
        // Execute this code if tradeType is 0 (buy)
        OrderSend(Symbol(), OP_BUY, 0.1, price, 0, 0, 0, "Buy order", 0, 0, Green);
        break;
    case 1:
        // Execute this code if tradeType is 1 (sell)
        OrderSend(Symbol(), OP_SELL, 0.1, price, 0, 0, 0, "Sell order", 0, 0, Red);
        break;
    default:
        // Execute this code if tradeType is not 0 or 1 (do nothing)
        break;
}

La sentencia if-else hace que el código verifique y ejecute acciones en función del nivel de precio:

• Si el precio es > 1.0, la variable tradeType = 0 -> BUY.
• Si la variable de precio es < 0.5, la variable tradeType = 1 -> SELL. 
• Si el precio se encuentra en el precio bid actual (configuración predeterminada), tradeType = 2 -> NINGUNA ACCIÓN. 

Al usar la sentencia switch, la lógica cambia un poco: el código centra su atención en el valor de la variable tradeType: 

• Si tradeType = 0 -> BUY al nivel de precio definido en el código.
• Si tradeType = 1 -> SELL al nivel de precio. 
• Si tradeType = 2 -> NINGUNA ACCIÓN.

Sigue estas guías para aprender a instalar tu robot de Forex en tus terminales de trading:
Cómo instalar un robot de trading para Forex en MT4
Cómo instalar un robot de trading para Forex en MT5

Conclusión

En conclusión, en este artículo hemos analizado los diferentes elementos que conforman el código habitual de un robot de Forex y el desarrollo de sistemas de trading automatizados. Viste qué tipos de código se pueden crear en MQL4 (robots de trading para Forex, indicadores y scripts) y las distintas estructuras que componen el código de un robot. También examinamos los elementos necesarios para desarrollar un robot de Forex, un indicador y un script en MQL4. Ahora ya tienes una idea clara sobre comentarios e identificadores, piezas fundamentales de la sintaxis de programación. 

Dominar estos conceptos requiere dedicación y práctica constante. Esperamos que esta información te haya servido para entender con claridad todo lo que implica programar un robot de Forex.