Programación en MQL5 (II)

¡Bienvenido al Tutorial de MQL5!
Este material está diseñado para traders y desarrolladores que ya tienen nociones básicas de programación (variables, bucles, condicionales, etc.). Aunque repasaremos los comandos y estructuras principales de MQL5, el enfoque está en aplicar conceptos prácticos para desarrollar Expert Advisors (EAs), indicadores y scripts.

Si eres completamente nuevo en programación, te recomendamos:

1. Consultar la documentación oficial de MQL5 para comprender los fundamentos del lenguaje.
2. Practicar con los 60+ ejercicios y ejemplos resueltos de este tutorial, que van desde lo básico hasta lo avanzado.
3. Empezar con proyectos simples (como indicadores básicos o scripts de alertas) antes de abordar EAs complejos.

Este tutorial no solo te enseñará a codificar, sino que también te guiará en la implementación de estrategias reales, gestión de riesgos y optimización. ¡Manos a la obra!

¡Importante!
Si en algún momento te sientes perdido, recuerda que la práctica constante y la experimentación son clave en el aprendizaje de MQL5. No dudes en revisar los ejemplos paso a paso y adaptarlos a tus propias estrategias.

¡Esperamos que disfrutes este tutorial y que te conviertas en un experto en MQL5! 🚀

Sumario:

• Sección 1: Introducción a MQL5
  • ¿Qué es MQL5?
  • Configuración del Entorno de Desarrollo
  • Conceptos Fundamentales de Programación
• Sección 2: Fundamentos de Programación en MQL5
  • Estructura Básica de un Script en MQL5
  • Trabajando con Datos del Mercado
  • Gestión de Posiciones y Órdenes
  • Manipulación de Símbolos y Cuentas
• Sección 3: Construcción de Estrategias Automatizadas
  • Creación de un Expert Advisor Básico
  • Optimización de Código
  • Pruebas y Backtesting
• Sección 4: Temas Intermedios
  • Indicadores Personalizados
  • Gestión Avanzada de Riesgos
  • Notificaciones y Logs
  • Trabajo con Arrays y Matrices
• Sección 5: Mejoras y Herramientas Adicionales
  • Uso de Bibliotecas y Scripts Externos
  • Integración con Servicios Externos
  • Depuración y Mantenimiento
• Sección 6: Caso Práctico Completo
  • Desarrollo de un EA Completo
  • Publicación y Comercialización
• Anexos
  • Recursos Adicionales
  • Referencia de Funciones
  • Glosario de Términos

Sección 2: Fundamentos de Programación en MQL5

Capítulo 4: Estructura Básica de un Script en MQL5

En este capítulo, exploraremos la estructura básica de un script en MQL5 y cómo funcionan las funciones principales que definen el ciclo de vida de un programa: OnInit(), OnDeinit() y OnTick(). Estas funciones son esenciales para cualquier tipo de aplicación en MQL5, ya sea un script, un indicador personalizado o un Expert Advisor.

4.1. Función OnInit() (Inicialización)

La función OnInit() se ejecuta una sola vez cuando el script, indicador o EA se inicia. Es ideal para realizar tareas de configuración inicial, como cargar datos, verificar condiciones o inicializar variables.

Ciclo de Vida:

• Se llama automáticamente al iniciar el programa.
• Si ocurre un error durante la inicialización, el programa no continuará su ejecución.

Ejemplo práctico: Verificamos si el símbolo actual está disponible antes de continuar.

//+------------------------------------------------------------------+
//| Inicialización del programa                                      |
//+------------------------------------------------------------------+
int OnInit() {
   if (!SymbolExists(_Symbol)) {
      Print("El símbolo ", _Symbol, " no está disponible.");
      return(INIT_FAILED); // Devolvemos un código de error
   }

   Print("Programa iniciado correctamente con el símbolo: ", _Symbol);
   return(INIT_SUCCEEDED); // Indicamos que la inicialización fue exitosa
}

Explicación del Código:

• Usamos SymbolExists() para verificar si el símbolo está disponible.
• Si no está disponible, devolvemos INIT_FAILED para detener la ejecución.
• En caso contrario, mostramos un mensaje de éxito y retornamos INIT_SUCCEEDED.

4.2. Función OnDeinit() (Finalización)

La función OnDeinit() se ejecuta cuando el programa termina su ejecución. Es útil para liberar recursos, cerrar archivos o guardar datos antes de finalizar.

Ciclo de Vida:

• Se llama automáticamente al cerrar el programa.
• Puede ser utilizado para limpiar recursos o realizar acciones finales.

Ejemplo práctico: Guardamos un registro de cuándo se cerró el programa.

//+------------------------------------------------------------------+
//| Finalización del programa                                        |
//+------------------------------------------------------------------+
void OnDeinit(const int reason) {
   Print("Programa finalizado. Razón: ", EnumToString((ENUM_DEINIT_REASON)reason));

   // Ejemplo: Guardar información en un archivo
   CFileText file;
   if (file.Open("log.txt", FILE_WRITE)) {
      file.WriteLine("El programa se cerró el " + TimeToString(TimeCurrent(), TIME_DATE | TIME_SECONDS));
      file.Close();
   }
}

Explicación del Código:

• Usamos EnumToString() para convertir el motivo de la desinicialización (reason) en una cadena legible.
• Creamos un archivo de texto llamado log.txt y registramos la hora de cierre del programa.

4.3. Función OnTick() (Procesamiento de Ticks)

La función OnTick() se ejecuta cada vez que llega un nuevo tick de precio para el símbolo seleccionado. Esta es la función principal en los Expert Advisors y scripts que requieren procesar datos en tiempo real.

Ciclo de Vida:

• Se llama automáticamente cada vez que hay un cambio en los precios.
• Ideal para implementar lógicas de trading basadas en señales de mercado.

Ejemplo práctico: Implementamos un EA simple que abre una posición larga si el precio supera un nivel clave.

//+------------------------------------------------------------------+
//| Procesamiento de ticks                                           |
//+------------------------------------------------------------------+
void OnTick() {
   double precioActual = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double nivelClave = 1.1200;

   // Verificar si el precio supera el nivel clave
   if (precioActual > nivelClave) {
      Print("Precio actual: ", DoubleToString(precioActual, _Digits), ". Superando nivel clave.");

      // Abrir una posición larga
      if (OrderSend(_Symbol, OP_BUY, 0.1, Ask, 0, 0, 0)) {
         Print("Posición larga abierta.");
      } else {
         Print("Error al abrir la posición. Código de error: ", GetLastError());
      }
   }
}

Explicación del Código:

• Obtenemos el precio actual usando SymbolInfoDouble().
• Comparamos el precio con un nivel clave predefinido.
• Si se cumple la condición, intentamos abrir una posición larga utilizando OrderSend().
• Mostramos mensajes informativos en caso de éxito o error.

Ciclo de Vida de un Script en MQL5

A continuación, te presentamos un resumen del ciclo de vida de un script en MQL5:

1. Inicio (OnInit()): Se ejecuta al iniciar el programa. Aquí realizamos tareas de configuración.
2. Procesamiento (OnTick()): Se ejecuta cada vez que llega un nuevo tick de precio. Aquí implementamos la lógica principal del programa.
3. Finalización (OnDeinit()): Se ejecuta al cerrar el programa. Aquí limpiamos recursos o realizamos acciones finales.

//+------------------------------------------------------------------+
//| Script para detectar cambios de precio mayores al 0.1%           |
//|                                                                  |
//| Propósito: Mostrar un mensaje cuando el precio cambie más del    |
//|            0.1% respecto al tick anterior.                       |
//+------------------------------------------------------------------+

// Variable global para almacenar el último precio procesado
double lastPrice = 0.0;

// Función de inicialización
int OnInit() {
   // Verificar si el símbolo actual está disponible
   if (!SymbolExists(_Symbol)) {
      Print("El símbolo ", _Symbol, " no está disponible.");
      return(INIT_FAILED); // Finalizar si el símbolo no existe
   }

   // Inicializar la variable lastPrice con el precio actual
   lastPrice = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   Print("Programa iniciado. Precio inicial: ", DoubleToString(lastPrice, _Digits));
   return(INIT_SUCCEEDED);
}

// Función principal que se ejecuta en cada tick
void OnTick() {
   // Obtener el precio actual del Ask
   double currentPrice = SymbolInfoDouble(_Symbol, SYMBOL_ASK);

   // Calcular el porcentaje de cambio entre el precio actual y el último precio
   double priceChangePercent = MathAbs((currentPrice - lastPrice) / lastPrice * 100);

   // Verificar si el cambio es mayor al 0.1%
   if (priceChangePercent > 0.1) {
      // Mostrar un mensaje con los detalles del cambio
      Print("Cambio de precio detectado! Porcentaje: ", 
            DoubleToString(priceChangePercent, 2), 
            "% (Último precio: ", DoubleToString(lastPrice, _Digits), 
            ", Precio actual: ", DoubleToString(currentPrice, _Digits), ")");
   }

   // Actualizar el último precio procesado
   lastPrice = currentPrice;
}

// Función de finalización
void OnDeinit(const int reason) {
   Print("Programa finalizado. Razón: ", EnumToString((ENUM_DEINIT_REASON)reason));
}

//+------------------------------------------------------------------+
//| Script para abrir posiciones largas y cortas basadas en niveles  |
//|                                                                  |
//| Propósito: Abrir una posición larga si el precio supera un nivel |
//|            clave y una posición corta si cae por debajo de otro. |
//+------------------------------------------------------------------+

// Niveles clave para tomar decisiones
double nivelClaveCompra = 1.1200; // Nivel para abrir posición larga
double nivelClaveVenta = 1.1150;  // Nivel para abrir posición corta

// Función principal que se ejecuta en cada tick
void OnTick() {
   // Obtener el precio actual del Ask (para compras) y Bid (para ventas)
   double precioActualAsk = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double precioActualBid = SymbolInfoDouble(_Symbol, SYMBOL_BID);

   // Verificar si no hay posiciones abiertas antes de tomar una decisión
   if (PositionsTotal() == 0) {
      // Si el precio supera el nivel clave de compra, abrir posición larga
      if (precioActualAsk > nivelClaveCompra) {
         Print("Precio actual (Ask): ", DoubleToString(precioActualAsk, _Digits), 
               ". Superando nivel clave de compra (", DoubleToString(nivelClaveCompra, _Digits), ").");
         
         // Intentar abrir posición larga
         if (OrderSend(_Symbol, OP_BUY, 0.1, Ask, 0, 0, 0)) {
            Print("Posición larga abierta.");
         } else {
            Print("Error al abrir posición larga. Código de error: ", GetLastError());
         }
      }

      // Si el precio cae por debajo del nivel clave de venta, abrir posición corta
      if (precioActualBid < nivelClaveVenta) {
         Print("Precio actual (Bid): ", DoubleToString(precioActualBid, _Digits), 
               ". Cayendo por debajo del nivel clave de venta (", DoubleToString(nivelClaveVenta, _Digits), ").");
         
         // Intentar abrir posición corta
         if (OrderSend(_Symbol, OP_SELL, 0.1, Bid, 0, 0, 0)) {
            Print("Posición corta abierta.");
         } else {
            Print("Error al abrir posición corta. Código de error: ", GetLastError());
         }
      }
   }
}

//+------------------------------------------------------------------+
//| Script para contar ticks y guardar el total en un archivo        |
//|                                                                  |
//| Propósito: Contar el número total de ticks procesados durante    |
//|            la ejecución del script y guardar este valor en un    |
//|            archivo de texto al finalizar.                        |
//+------------------------------------------------------------------+

// Variable global para contar los ticks procesados
int tickCounter = 0;

// Función principal que se ejecuta en cada tick
void OnTick() {
   // Incrementar el contador de ticks
   tickCounter++;
}

// Función de finalización
void OnDeinit(const int reason) {
   // Mostrar mensaje informativo en la ventana de resultados
   Print("Programa finalizado. Razón: ", EnumToString((ENUM_DEINIT_REASON)reason));
   Print("Número total de ticks procesados: ", tickCounter);

   // Crear o abrir un archivo de texto para guardar el resultado
   CFileText file;
   if (file.Open("tick_counter.txt", FILE_WRITE)) {
      // Escribir el número total de ticks en el archivo
      file.WriteLine("Número total de ticks procesados: " + IntegerToString(tickCounter));
      file.Close(); // Cerrar el archivo después de escribir
      Print("El número de ticks ha sido guardado en 'tick_counter.txt'.");
   } else {
      // Mostrar mensaje de error si no se pudo abrir el archivo
      Print("Error al guardar el número de ticks en el archivo.");
   }
}

Número total de ticks procesados: 12345

Consejos Adicionales

• Optimiza tus Scripts: Evita realizar operaciones costosas dentro de OnTick() para mejorar el rendimiento.
• Usa Logs: Registra eventos importantes en archivos de texto para facilitar el depurado y análisis posterior.
• Prueba en Backtesting: Antes de usar tus scripts en vivo, prueba su comportamiento en el entorno de backtesting.

Resumen: En este capítulo, hemos aprendido sobre las funciones principales que conforman la estructura de un script en MQL5: OnInit(), OnDeinit() y OnTick(). Estas funciones definen el ciclo de vida de un programa y permiten implementar lógicas avanzadas para automatizar estrategias de trading.

En el próximo capítulo, profundizaremos en cómo trabajar con datos del mercado y gestionar órdenes de forma eficiente.

¡Sigue practicando y perfeccionando tus habilidades en MQL5!