Aprenda por qué y cómo diseñar su sistema de trading algorítmico
2 334
0
Introducción
Podemos decir sin ninguna duda que la importancia de la programación o codificación aumenta cada día en todas las esferas del mundo moderno. Así, podemos observar cómo la programación o la codificación pueden contribuir a facilitar nuestra vida y, no solo hacerla más fácil, sino también garantizar resultados precisos según nuestros deseos y lo que hemos decidido antes.
Cuando hablamos del mundo del trading, podemos decir que la programación o codificación hace que nuestro comercio sea fácil y sistemático gracias al uso de programas que contribuyen a la automatización de tareas tras crear un programa preciso y adecuado con lo que esperamos y queremos obtener. De esta forma, el mundo de la codificación puede ofrecernos muchos beneficios, pero en mi opinión, el beneficio más importante de la codificación es que nos ayuda a ser disciplinados, ya que, como todos sabemos, para el tráder siempre supone un desafío ser disciplinado con las decisiones adoptadas en el comercio. La disciplina es un rasgo importantísimo que influye en nuestros resultados comerciales y de inversión, así que ser disciplinado en nuestras acciones comerciales no es una opción, sino una obligación. Como siempre me gusta decir, la disciplina es la clave de su éxito en el comercio y en toda la vida. Personalmente, considero que la disciplina consiste en hacer lo que tenemos que hacer en el momento adecuado, independientemente de las circunstancias que nos rodeen. Entonces, cuando encontramos una herramienta que nos ayuda a lograr esto, deberemos estar atentos e intentar conocer su funcionamiento al cien por cien. En este caso, la herramienta adecuada es la codificación.
Como todos sabemos, el factor más común que nos impide ser disciplinados al comerciar son las emociones, por lo que debemos excluir dichas emociones o sus efectos negativos de nuestras decisiones comerciales. Ahora, quiero que piense en si tiene un sistema que funciona para usted, con sus propios parámetros por defecto y sin interferencia humana. En este caso, podrá evitar el efecto negativo de las emociones en sus decisiones comerciales. La buena noticia es que tenemos una herramienta que nos ayuda a hacer eso. Aquí, vamos a hablar en concreto sobre MQL (MetaQuotes Language) para la plataforma MetaTrader. Este gran lenguaje de programación nos ayudará a diseñar nuestro propio sistema comercial con parámetros específicos que garantizarán la implementación de acciones o decisiones comerciales concretas.
Si quiere entender mejor este concepto, podemos ver este ejemplo. Imaginemos que tenemos dos inversores (A y B) y su estrategia comercial es la misma (comprar y mantener la posición durante una tendencia alcista, y vender cuando se invierta la tendencia), pero cada uno de ellos se comporta de manera diferente (el inversor A es disciplinado pero el inversor B no lo es). Echemos un vistazo a las siguientes cifras:
Según las cifras anteriores, resulta obvio que la disciplina es esencial para obtener un buen resultado, mientras que la falta de disciplina provocará malos resultados.
En este artículo, compartiremos un sencillo cruce de medias móviles simples con el que aprenderemos a diseñar uno propio compartiendo algunos de los conceptos básicos de la codificación MQL5, con ejemplos para practicar estos conceptos básicos y comprenderlos en profundidad. Nuestro propósito es ofrecer una descripción general de lo que podemos hacer con esta magnífica herramienta.
El objetivo principal de este artículo es guiar a los principiantes para que aprendan a diseñar su propio sistema comercial algorítmico en MQL5, valiéndose para ello de algunos de los conceptos básicos de MQL5 que permitirán desarrollar un sistema comercial simple que se codificará paso a paso en este artículo después de aprender algunos de los conceptos básicos de MQL5. Así, codificaremos estos usando scripts, y luego presentaremos el resultado tras ejecutar el código. Para mejorar la comprensión del lector, le recomendamos que aplique y codifique por sí mismo lo que leerá aquí, ya que esto le ayudará a comprender en profundidad los conceptos de los códigos mencionados. Tenga igualmente en cuenta que todos los códigos, programas y estrategias comerciales creados en este artículo han sido diseñados solo con fines ilustrativos, nada más. Asimismo, no olvide que usaremos MQL5 para escribir los códigos.
Qué necesitamos para diseñar nuestro sistema de trading algorítmico
En esta parte, hablaremos de lo que queremos tener como herramientas y de lo que queremos saber sobre estas herramientas:
- La plataforma MetaTrader 5, también conocida como Terminal Meta Trader 5. Para ejecutar las órdenes y poner a prueba nuestros códigos a través del terminal. MetaTrader es la plataforma comercial más popular.
Una cuenta demo. Puede abrir una cuenta demo con su bróker para disponer de fondos virtuales y probar sus estrategias comerciales sin riesgos en el mismo entorno de mercado. Asegúrese de usar esta cuenta demo y no su cuenta real a la hora de realizar la codificación, ya que necesitará crear y ejecutar programas que efectuarán transacciones en su cuenta.
El Editor de Lenguaje MetaQuotes, donde escribiremos nuestros códigos o programas. Las siguientes capturas de pantalla muestran cómo abrirlo, ya que se instala con MetaTrader. Hay tres formas de abrirlo.
- Clicando en el menú Herramientas y, a continuación, en el Editor de lenguaje de MetaQuotes:
O cliсando en el icono del Editor de MetaQuotes:
O presionando el botón F4 desde el teclado mientras está en el terminal abierto.
La siguiente captura de pantalla muestra el aspecto de esto: aquí se encontrará la mayor parte del trabajo para escribir y diseñar nuestros programas y sistemas comerciales.
Ahora necesitamos usar este editor para escribir nuestro primer código, así que vamos a seguir los pasos que veremos a continuación para saber cómo hacerlo.
Clique en Nuevo y encontrará más de un tipo de programas para seleccionar:
En este artículo, hablaremos de asesores expertos, indicadores personalizados y scripts.
- Asesores Expertos: son programas en el terminal que se desarrollan y utilizan para automatizar los procesos de análisis y comercio según los parámetros establecidos.
- Indicadores Personalizados: son programas codificados; básicamente están destinados a la visualización gráfica de las dependencias calculadas preliminarmente.
- Scripts: programas destinados a la realización de una sola acción, que pueden cumplir tanto funciones analíticas como comerciales. A diferencia de los Asesores Expertos, se ejecutan a demanda, no según los ticks.
El programa ¡Hola Mundo!
En esta parte, aprenderemos a escribir nuestro primer programa y nuestro primer código en MQL5. Cualquier principiante en programación o codificación comienza su viaje codificando el código "Hola Mundo". Así que empezaremos escribiendo un programa que imprima en la pantalla del terminal "Hola Mundo". Vamos a ello...
Abrimos el MetaEditor como se muestra arriba, luego clicamos en nuevo, y seleccionamos entre las opciones (Script); luego clicamos en siguiente.
Después de clicar en siguiente, aparecerá la siguiente ventana. Rellenamos los datos del script según nuestras necesidades:
- Nombre: nombre del script
- Autor: creador del script
- Enlace: nuestro enlace
- Parámetros: parámetros que necesitamos establecer para el script. Sin embargo, no estableceremos ningún parámetro para este script, así que lo omitiremos.
Después de clicar en Finalizar, se abrirá la siguiente ventana. En esta ventana se codificará nuestro programa. Aquí como hemos mencionado, necesitaremos diseñar un programa que muestre "¡Hola Mundo!" en el terminal. Así que vamos a empezar a escribir nuestro código entre dos llaves.
Aquí utilizaremos:
- Alerta: imprime lo que nosotros determinemos o muestra un mensaje por defecto en el programa, que en nuestro ejemplo será "¡Hola Mundo!"
- ( “ ”): para escribir entre ellas lo que queramos o el mensaje predeterminado "¡Hola Mundo!".
- ; - para separar frases.
Nuestro código será lo mismo que:
//+----------------------------------------------------------+ //| Hello World!.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+----------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+----------------------------------------------------------+ //| Script program start function | //+----------------------------------------------------------+ void OnStart() { Alert("Hello World!"); } //+----------------------------------------------------------+
Después de escribir nuestro código, clicamos en Compilar, y luego nos aseguramos de que no haya errores ni advertencias. La pestaña Errores no deberá contener errores después de compilar nuestro código, para así asegurarnos de que nuestro programa se ejecute igual que lo mencionado en la siguiente imagen. Luego iremos al terminal presionando F4 para probar nuestro código.
Idea de estrategia comercial (cruce de dos medias móviles simples)
En esta parte, presentaremos una idea de estrategia comercial solo con fines ilustrativos. Su objetivo es ayudar al lector a aprender los conceptos básicos de MQL5 y a programar en MQL5.
Descargo de responsabilidad
Toda la información se ofrece "tal cual", únicamente con fines informativos, y no está destinada a fines comerciales o de asesoramiento. El rendimiento pasado no supone una garantía de resultados futuros. Si usted elige usar estos materiales en cualquier cuenta comercial, lo hará bajo su propio riesgo.
Aquí, la idea de la estrategia consiste en tratar de comerciar con la tendencia usando la confirmación de la señal de dos indicadores simples de media móvil:
- La media móvil simple es un indicador técnico rezagado que calcula el precio medio de cierre de un periodo específico, y es rezagado ya que su señal llega después de la señal de acción del precio.
- La estrategia es la siguiente:
- Si la media móvil simple más corta (su periodo es 20) cruza la media móvil simple más larga (su periodo es 50) para estar por encima de esta, la señal será de Compra.
- Si la media móvil simple más corta (su periodo es 20) cruza la media móvil simple más larga (su periodo es 50) para estar por debajo de esta, la señal será de Venta.
Aquí, necesitaremos diseñar un programa para hacer esto.
Plan de sistema comercial algorítmico
En esta parte, hablaremos sobre un paso muy importante a la hora de codificar nuestro sistema de forma sencilla y sin problemas. Hablamos de la creación de un plan para nuestra estrategia comercial en forma de secuencia de pasos donde tendremos en cuenta lo que queremos que haga exactamente nuestro sistema. Podemos hacerlo, por ejemplo, a través de un diagrama que nos ofrezca un plan claro. Aquí tenemos un ejemplo de nuestro modelo de sistema (cruce de dos medias móviles simples), para ver claramente lo que necesitamos codificar y lo que esperamos obtener.
Ahora, vamos a analizar primero algunos de los conceptos básicos de MQL5; luego usaremos lo que necesitemos para realizar el diseño.
Variables y tipos de variable, y cómo podemos usar estas
En esta parte, identificaremos y entenderemos:
- ¿Qué son las variables?
- Tipos de variables.
- ¿Cómo podemos usarlas?
En términos generales, en un programa, los valores de los datos pueden ser constantes o variables. Si los valores son variables, pueden ser modificados por el programa y el usuario. Una variable es una ubicación de memoria. Tiene un nombre que está asociado con esa ubicación. Así, la ubicación de la memoria se usa para almacenar datos. Un programa en MQL5 puede contener decenas e incluso cientos de variables. Una propiedad muy importante de cada variable es la posibilidad de utilizar su valor en un programa. La limitación de esta posibilidad está relacionada con el alcance de la variable, que supone una ubicación en el programa donde está disponible el valor de la variable. Cada variable tiene su propio alcance.
Entonces, según el alcance, hay dos tipos de variables en MQL5, locales y globales. Una variable local es una variable declarada dentro de una función. El ámbito de las variables locales es el cuerpo de la función en el que se declara la variable. Una variable local puede ser inicializada por una constante o una expresión correspondiente a su tipo. Las variables globales se declaran más allá de todas las funciones. El alcance de las variables globales es todo el programa. Una variable global solo puede ser inicializada por una constante correspondiente a su tipo (y no una expresión). Las variables globales se inicializan solo una vez antes de indicar la ejecución de las funciones especiales.
Independientemente del alcance de las variables, ahora veremos los siguientes tipos de variables:
- int es un tipo numérico; existen diferentes tipos enteros para almacenar valores numéricos de diferente longitud.
- double. Construir un programa que gestione los números usados en el comercio requiere un tipo de datos capaz de manejar números de punto flotante. MetaTrader ofrece los siguientes tipos de datos para manejar estos datos: float y double. La diferencia entre ellos son los bytes asignados en la memoria, 4 para el tipo float y 8 para el tipo double, lo cual ofrece como resultado los siguientes valores mínimo y máximo:
- float - minimum 1.175494351e-38, maximum 3.402823466e+38
- double - minimum 2.2250738585072014e-308, maximum 1.7976931348623158e+308
Para declarar este tipo de datos, utilizaremos palabras clave float y double. - string es un tipo de datos muy importante que también se usa ampliamente en la codificación de MQL5. String permite almacenar y manipular cualquier secuencia alfanumérica de caracteres.
- bool - Booleano es un tipo lógico que puede asumir el valor true o false.
Tomemos un ejemplo para usar variables:
//+------------------------------------------------------------------+ //| Variables.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { int myInteger = 5; double myDouble = 10.56; string myString = "My name is Mohamed"; bool myBoolean = true; Alert(myInteger); Alert(myDouble); Alert(myString); Alert(myBoolean); } //+------------------------------------------------------------------+
Después de compilar el código anterior, si lo escribimos como lo hemos mencionado anteriormente, no encontraremos errores ni advertencias, y deberemos ver la ventana de alerta como se muestra a continuación.
Otro ejemplo de uso de variables.
- El valor equivalente de mensaje1
- El valor equivalente de C
- El valor equivalente del resultado
- El valor equivalente de mensaje2
//+------------------------------------------------------------------+ //| Variables 2.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { int A = 10; int B = 5; int C; double var1 = 2.5; double var2 = 4; double result = var1 / var2; string greeting = "Hello"; string space = " "; string name = "Mohamed"; string message1; string message2; C = A + B; message1 = greeting + space + name; message2 = "Value of A is: " + string(A); Alert(message1); Alert(C); Alert(result); Alert(message2); } //+------------------------------------------------------------------+
Operaciones booleanas
Booleano: simplemente retorna true o false para una operación lógica.
- == significa igual
- != significa no igual
- < significa menor que
- <= significa menor o igual que
- > significa mayor que
- >= significa mayor o igual que
//+------------------------------------------------------------------+ //| Boolean Operations.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { bool result = 4 < 5; Alert (result); //true } //+------------------------------------------------------------------+
Aquí debe retornar true en el mensaje de alerta como 4 < 5.
El ciclo While
El operador while consta de una expresión comprobada y el operador, que debe cumplirse. Si la expresión es true, el operador se ejecutará hasta que la expresión sea false. En el siguiente ejemplo, el programa notifica el inicio y el final del ciclo, y también comprueba el valor del contador y lo muestra si este valor es inferior a tres. Luego añadirá uno al resultado anterior hasta que se vuelva false, en este caso = o > 3; después dará la última alerta cuando el ciclo haya terminado. Así, veremos los siguientes mensajes de este código en el mensaje de alerta: Inicio del script, 1, 2, El ciclo ha terminado.//+------------------------------------------------------------------+ //| While Loop.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { //While (Loop) Alert("Start of script"); int counter = 1; while(counter < 3) //true? { Alert(counter); counter = counter + 1; } Alert("Loop has finished"); }
El ciclo For
El operador For consta de tres expresiones y un operador ejecutable:
for(expression1; expression2; expression3)
operator;
Expression1 describe la inicialización del ciclo. Expression2 comprueba las condiciones de finalización del ciclo. Si es true, se ejecutará el cuerpo del ciclo For. El ciclo repite expression2 hasta que se vuelva false. Si es false, el ciclo termina y el control pasa al siguiente operador. Expression3 se calcula después de cada iteración.
Entonces, según el siguiente ejemplo de ciclo For, podemos esperar que la ejecución del código dé como resultado cinco mensajes de Hola (I = 0, I = 2, …………, I = 4), luego = 5, por lo que el ciclo terminará.
//+------------------------------------------------------------------+ //| For Loop.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { for(int i=0; i<5 ; i++) { Alert("Hello"); } } //+------------------------------------------------------------------+
La declaración IF, Else
El operador IF - ELSE se usa cuando debemos hacer una elección. Formalmente, la sintaxis es la siguiente:
if (expression)
operator1
else
operator2
Si la expresión es true, se ejecutará operator1 y se dará el control al operador que siga a operator2 (no se ejecutará operator2). Si la expresión es false, se ejecutará operator2.
Ejemplo: según el siguiente ejemplo, primero deberemos recibir una alerta con el valor Bid, luego determinaremos si el valor de Bid es > 1.146600; después recibiremos una alerta con "El precio está por encima de 1.146600 -> BUY". Si no es así, se nos alertará con "El precio está por debajo de 1.146600 -> SELL". Lo siguiente es el código y el resultado de su ejecución.
//+------------------------------------------------------------------+ //| If-else statement.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { double level = 1.146600; double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits); Alert("Bid Price = " + string(Bid)); if(Bid > level) { Alert ("The price is above " + string(level) + " -> BUY"); } // What if the condition is false and we need to take an action also here we can use else function instead of writing another if code else { Alert ("The price is below " + string(level) + " -> SELL"); } } //+------------------------------------------------------------------+
Entradas del comerciante
En esta parte, aprenderemos cómo determinar nuestras entradas o parámetros preferidos para el programa en lugar de ajustar el código.
Propiedades (#property): Cada programa MQL5 permite indicar parámetros específicos adicionales, denominados #property, que ayudan al terminal de cliente a ofrecer un servicio adecuado a los programas sin necesidad de ejecutarlos explícitamente.
script_show_inputs: muestra una ventana con las propiedades antes de ejecutar el script y deshabilita esta ventana de confirmación
Variables de entrada: la clase de almacenamiento de entradas define la variable externa. Se indica el modificador de entradas antes del tipo de datos.
//+------------------------------------------------------------------+ //| Trader Inputs.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" #property script_show_inputs //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ input int TakeProfit = 10; input int StopLoss = 10; void OnStart() { double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits); double TakeProfitLevel = Bid + TakeProfit * 0.00001; // 0.00001 (5 digits broker, so multiplied by 10) double StopLossLevel = Bid - StopLoss * 0.00001; Alert("Price now = " + string(Bid)); Alert ("TakeProfitLevel = ", TakeProfitLevel); Alert ("StopLossLevel = ", StopLossLevel); } //+------------------------------------------------------------------+
Órdenes de apertura
En esta parte, hablaremos sobre cómo escribir nuestro código para abrir una orden:
//+------------------------------------------------------------------+ //| TEST.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" #property script_show_inputs #include <Trade\Trade.mqh> CTrade trade; //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ input int TakeProfit = 150; input int StopLoss = 100; void OnStart() { double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits); double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits); double Balance = AccountInfoDouble(ACCOUNT_BALANCE); double Equity = AccountInfoDouble(ACCOUNT_EQUITY); double TakeProfitLevel = (Ask+TakeProfit*0.00001); double StopLossLevel = (Ask-StopLoss*0.00001); if(Equity >= Balance) trade.Buy(0.01,NULL,Ask,StopLossLevel,TakeProfitLevel,NULL); for (int i=PositionsTotal()-1; i>=0; i--) { ulong ticket = PositionGetTicket(i); ENUM_POSITION_TYPE position = ENUM_POSITION_TYPE(PositionGetInteger(POSITION_TYPE)); Alert (" Order Ticket # ", ticket); Alert("TakeProfit = ", TakeProfitLevel); Alert("StopLoss = ", StopLossLevel); } } //+------------------------------------------------------------------+
Técnica de gestión de errores
Cuando el programa se ejecuta, cualquiera puede ver si se han dado fallos y algo ha salido mal. Por consiguiente, deberemos incluir esta técnica en nuestro código para verificar cada orden o código ejecutado y advertir si algo ha salido mal. En otras palabras, se trata de una técnica que permite al tráder protejerse a sí mismo y a sus fondos contra cualquier situación inapropiada.
//+------------------------------------------------------------------+ //| TEST.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" #property script_show_inputs #include <Trade\Trade.mqh> CTrade trade; //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ input int TakeProfit = 150; input int StopLoss = 100; void OnStart() { double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits); double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits); double Balance = AccountInfoDouble(ACCOUNT_BALANCE); double Equity = AccountInfoDouble(ACCOUNT_EQUITY); double TakeProfitLevel = (Ask+TakeProfit*0.00001); double StopLossLevel = (Ask-StopLoss*0.00001); if(Equity >= Balance) trade.Buy(0.01,NULL,Ask,StopLossLevel,TakeProfitLevel,NULL); for (int i=PositionsTotal()-1; i>=0; i--) { ulong ticket = PositionGetTicket(i); ENUM_POSITION_TYPE position = ENUM_POSITION_TYPE(PositionGetInteger(POSITION_TYPE)); if (ticket <= 0) { Alert("Error!"); //in Case of error and the order did not open, appears "Error!" } else { Alert("Your ticket # is: " + string(ticket)); Alert("TakeProfit = ", TakeProfitLevel); Alert("StopLoss = ", StopLossLevel); } } } //+------------------------------------------------------------------+
Órdenes de cierre
En esta parte, crearemos el código que permite abrir y cerrar una orden, para aprender a cerrar una orden.//+------------------------------------------------------------------+ //| TEST.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" #property script_show_inputs #include <Trade\Trade.mqh> CTrade trade; //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ input int TakeProfit = 150; input int StopLoss = 100; void OnStart() { double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits); double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits); double Balance = AccountInfoDouble(ACCOUNT_BALANCE); double Equity = AccountInfoDouble(ACCOUNT_EQUITY); double TakeProfitLevel = (Ask+TakeProfit*0.00001); double StopLossLevel = (Ask-StopLoss*0.00001); trade.Buy(0.01,NULL,Ask,StopLossLevel,TakeProfitLevel,NULL); for (int i=PositionsTotal()-1; i>=0; i--) { ulong ticket = PositionGetTicket(i); ENUM_POSITION_TYPE position = ENUM_POSITION_TYPE(PositionGetInteger(POSITION_TYPE)); Alert (" Order Ticket # ", ticket); Alert("TakeProfit = ", TakeProfitLevel); Alert("StopLoss = ", StopLossLevel); Sleep(2000); trade.PositionClose(ticket,-1); Alert("Order Closed..."); } } //+------------------------------------------------------------------+
Ajuste de órdenes usando OrderModify
En esta parte, aprenderemos a crear un código que ayude a modificar órdenes. Este modificará las características de las órdenes previamente abiertas o pendientes.
//+------------------------------------------------------------------+ //| TEST.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" #property script_show_inputs #include <Trade\Trade.mqh> CTrade trade; //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ input int TakeProfit = 150; input int StopLoss = 100; void OnStart() { double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits); double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits); double Balance = AccountInfoDouble(ACCOUNT_BALANCE); double Equity = AccountInfoDouble(ACCOUNT_EQUITY); double TakeProfitLevel = (Ask+TakeProfit*0.00001); double StopLossLevel = (Ask-StopLoss*0.00001); double TakeProfitLevel2 = (TakeProfitLevel+0.00100); double StopLossLevel2 = (StopLossLevel-0.00050); trade.Buy(0.01,NULL,Ask,StopLossLevel,TakeProfitLevel,NULL); for (int i=PositionsTotal()-1; i>=0; i--) { ulong ticket = PositionGetTicket(i); ENUM_POSITION_TYPE position = ENUM_POSITION_TYPE(PositionGetInteger(POSITION_TYPE)); Alert (" Order Ticket # ", ticket); Alert("TakeProfit = ", TakeProfitLevel); Alert("StopLoss = ", StopLossLevel); Sleep(5000); trade.PositionModify(ticket,StopLossLevel2,TakeProfitLevel2); Alert("Order Modified..."); Alert("Modified TakeProfit = ", TakeProfitLevel2); Alert("Modified StopLoss = ", StopLossLevel2); } } //+------------------------------------------------------------------+
El sistema de cruce de dos medias móviles simples
En esta parte, combinaremos todo para codificar el cruce de dos medias móviles simples. Todo cumplirá lo necesario según el plan mencionado anteriormente.
Aquí, al iniciar un nuevo proyecto, elegiremos un asesor experto clicando en nuevo desde el MetaEditor.
Para recordar todo, aquí tenemos un plano detallado de nuestro sistema comercial:
- Si la media móvil simple más corta (su periodo es 20) cruza la media móvil simple más larga (su periodo es 50) para estar por encima de esta, la señal será de Compra.
- Si la media móvil simple más corta (su periodo es 20) cruza la media móvil simple más larga (su periodo es 50) para estar por debajo de esta, la señal será de Venta.
//+------------------------------------------------------------------+ //| SMA crossover.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //create an array for several prices double myMovingAverageArray1[], myMovingAverageArray2[]; //define the properties of MAs - simple MA, 1st 20 / 2nd 50 int movingAverage1 = iMA(_Symbol, _Period, 20, 0, MODE_SMA, PRICE_CLOSE); int movingAverage2 = iMA(_Symbol,_Period,50,0,MODE_SMA,PRICE_CLOSE); //sort the price arrays 1, 2 from current candle ArraySetAsSeries(myMovingAverageArray1,true); ArraySetAsSeries(myMovingAverageArray2,true); //Defined MA1, MA2 - one line - currentcandle, 3 candles - store result CopyBuffer(movingAverage1,0,0,3,myMovingAverageArray1); CopyBuffer(movingAverage2,0,0,3,myMovingAverageArray2); //Check if we have a buy entry signal if ( (myMovingAverageArray1[0]>myMovingAverageArray2[0]) && (myMovingAverageArray1[1]<myMovingAverageArray2[1]) ) { Comment("BUY"); } //check if we have a sell entry signal if ( (myMovingAverageArray1[0]<myMovingAverageArray2[0]) && (myMovingAverageArray1[1]>myMovingAverageArray2[1]) ) { Comment("SELL"); } } //+------------------------------------------------------------------+
Después de ejecutarse el programa, se mostrarán los comentarios en el gráfico con la señal actual (de compra o venta) según esta estrategia. Esto se muestra en la siguiente imagen:
Activamos la opción 'Permitir comercio algorítmico', y luego clicamos en Aceptar. Después de eso, el asesor experto se adjuntará al gráfico y aparecerá un mensaje en la pestaña Diario a medida que se cargue correctamente:
Bien, ya hemos creado y ejecutado nuestro programa de automatización Two Simple Moving Averages Crossover. Querríamos destacar, eso sí, que este es un simple ejemplo de lo que podemos llegar a codificar para nuestro comercio. Y es que podemos codificar y automatizar cualquier otra estrategia comercial utilizando esta magnífica herramienta de MQL5.
Una vez más: el objetivo principal de este artículo no es el uso de esta estrategia en sí, sino el aprendizaje de algunos de los conceptos básicos de MQL5, además de lo que podemos crear para hacer que nuestro comercio sea más fácil y rentable. Por ello, esta estrategia necesita muchas mejoras y, si el lector la usa, será bajo su única responsabilidad.
Conclusión
MQL5 es una magnífica herramienta que hace nuestro comercio más fácil y rentable mediante el diseño de sistemas comerciales algorítmicos buenos y rentables. Por consiguiente, la inversión del lector en el aprendizaje y el uso de esta magnífica herramienta será sin duda altamente gratificante.
Traducción del inglés realizada por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/en/articles/10293
Gráficos en la biblioteca DoEasy (Parte 94): Objetos gráficos compuestos, desplazamiento y eliminación
Gráficos en la biblioteca DoEasy (Parte 93): Preparando la funcionalidad para crear objetos gráficos compuestos
Cómo desarrollar sistemas basados en medias móviles
Gráficos en la biblioteca DoEasy (Parte 92): Clase de memoria de objetos gráficos estándar Historia de cambio de propiedades del objeto
- Aplicaciones de trading gratuitas
- 8 000+ señales para copiar
- Noticias económicas para analizar los mercados financieros
Usted acepta la política del sitio web y las condiciones de uso