Operaciones de trading en MQL5 - Es fácil
6 418
0
Casi todos los operadores llegan al mercado para ganar dinero, pero algunos también disfrutan de ello. Sin embargo, no solo la operativa manual puede proporcionarle una experiencia apasionante. El desarrollo de sistemas de trading automatizados también puede ser fascinante. Crear un robot de trading puede ser tan interesante como leer una buena novela de misterio.
Cuando se desarrolla un algoritmo de trading tenemos que resolver una gran cantidad de aspectos técnicos incluyendo los más importantes:
- ¿Con qué negociar?
- ¿Cuándo negociar?
- ¿Cómo negociar?
Necesitamos responder a la primera pregunta para elegir el símbolo más apropiado. Nuestra elección puede verse afectada por muchos factores, incluyendo la capacidad para automatizar nuestro sistema de trading en el mercado. La segunda pregunta implica la elaboración de normas de trading que indican claramente la dirección de las negociaciones, así como los puntos de entrada y salida. La tercera cuestión parece ser relativamente simple: ¿cómo comprar y vender usando un lenguaje de programación determinado?
En este artículo vamos a ver cómo implementar operaciones de compraventa en el trading algorítmico usando el lenguaje MQL5.
Características de MQL5 para el trading algorítmico
MQL5 es un lenguaje de programación de estrategias de trading con multitud de funciones de trading para el trabajo con órdenes, posiciones y solicitudes de transacciones. De esta forma, el diseño de robots de trading algorítmicos en MQL5 es la tarea que requiere un menor trabajo por parte de un programador.
Las características de MQL5 le permiten realizar una solicitud de transacción y enviarla a un servidor usando las funciones OrderSend() o bien OrderSendAsync(), recibir los resultados de su procesamiento, ver el historial de trading, examinar las especificaciones del contrato para un símbolo, gestionar un evento de trading, así como recibir otros datos necesarios.
Además, MQL5 puede usarse para escribir indicadores técnicos personalizados y aplicar aquellos que ya están implementados, trazar cualquier señal u objeto sobre un gráfico, desarrollar una interfaz de usuario personalizada, etc. Pueden consultarse ejemplos de implementación en numerosos artículos.
Operaciones de trading: ¡tan fácil como ABC!
Hay varios tipos básicos de operaciones que su robot de trading puede necesitar:
- comprar/vender al precio actual,
- cursar una orden pendiente para comprar/vender según una condición determinada,
- modificar/eliminar una orden pendiente,
- cerrar/añadir/reducir/revertir una posición,
Todas estas operaciones se realizan mediante la función OrderSend(). Hay también una versión asíncrona llamada OrderSendAsync(). Todos los tipos de operaciones de trading son descritas por la estructura MqlTradeRequest que contiene la descripción de una solicitud de transacción. Por tanto, solo cumplir con la estructura de MqlTradeRequest y gestionar los resultados de la ejecución de las solicitudes puede ser todo un reto cuando se trabaja con operaciones de trading.
En función de su sistema de trading, puede comprar o vender al precio de mercado (BUY o SELL), así como cursar una orden pendiente de compra/venta a una distancia determinada del precio de mercado actual:
- BUY STOP, SELL STOP - comprar o vender cuando se sobrepasa un nivel determinado (peor que el precio actual);
- BUY LIMIT, SELL LIMIT - comprar o vender cuando se alcanza un nivel determinado (mejor que el precio actual);
- BUY STOP LIMIT, SELL STOP LIMIT - establecer BUY LIMIT o SELL LIMIT cuando se alcanza el precio señalado.
Estos tipos de órdenes estándar se corresponden con la enumeración ENUM_ORDER_TYPE.
Puede necesitar modificar o eliminar alguna orden pendiente. Esto también puede realizarse mediante las funciones OrderSend()/OrderSendAsync(). Modificar una posición es también un proceso muy sencillo, ya que se realiza usando las mismas operaciones de trading.
Si cree que las operaciones de trading son complejas e intrincadas, es el momento de cambiar de opinión. Le mostraremos no solo cómo escribir código para compras y ventas en MQL5 de forma rápida y sencilla, sino también cómo trabajar con cuentas de trading y propiedades de símbolos. Las clases de transacciones nos ayudarán en esta tarea.
Compruebe su cuenta de trading con CAccountInfo
Lo primero que necesita saber al ejecutar su robot de trading es qué cuenta de trading se va a usar para esta operación. Como estamos escribiendo un código de prueba vamos a implementar una verificación por si el asesor experto es iniciado en una cuenta real.
La clase CAccountInfo se utiliza para trabajar con una cuenta. Añadiremos el archivo AccountInfo.mqh y declararemos la variable de la clase - account:
#include <Trade\AccountInfo.mqh> //+------------------------------------------------------------------+ //| Función de inicialización del Experto | //+------------------------------------------------------------------+ int OnInit() { //--- objeto para trabajar con la cuenta CAccountInfo account; //--- al recibir el número de cuenta el Expert Advisor se inicia en long login=account.Login(); Print("Login=",login); //--- determinar el tipo de cuenta ENUM_ACCOUNT_TRADE_MODE account_type=account.TradeMode(); //--- si la cuenta es real ¡el Expert Advisor se para immediatamente! if(account_type==ACCOUNT_TRADE_MODE_REAL) { MessageBox("Se prohibe operar en una cuenta real, deshabilitando ","¡Se ha iniciado el Expert Advisor en una cuenta real!"); return(-1); } //--- mostrar el tipo de cuenta Print("Account type: ",EnumToString(account_type)); //--- determinar si podemos operar en esta cuenta if(account.TradeAllowed()) Print("Se permite operar en esta cuenta"); else Print("Se prohíbe operar en esta cuenta: puede que haya usado la contraseña de inversor"); //--- determinar si podemos usar un Expert Advisor en esta cuenta if(account.TradeExpert()) Print("Se permiten las operaciones automatizadas en esta cuenta"); else Print("Se prohíbe el trading automatizado usando Expert Advisors y scripts"); //--- Determinar si se ha establecido el número de órdenes permitidas int orders_limit=account.LimitOrders(); if(orders_limit!=0)Print("Cantidad máxima admitida de órdenes pendientes activas: ",orders_limit); //--- Mostrar los nombres de la empresa y el servidor Print(account.Company(),": servidor ",account.Server()); //--- mostrar el saldo y beneficio actual en la cuenta al final Print("Saldo=",account.Balance()," Beneficio=",account.Profit()," Valor neto=",account.Equity()); Print(__FUNCTION__," completado"); //--- return(0); } //+------------------------------------------------------------------+ //| Función de deinicialización del Experto | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { //--- } //+------------------------------------------------------------------+ //| Función tick del Experto | //+------------------------------------------------------------------+ void OnTick() { //--- }
Como podemos ver en el código anterior, puede recibirse una gran cantidad de datos usando la variable account en la función OnInit(). Puede añadir este código a su asesor experto para comprobar los registros fácilmente al analizar su operación.
A continuación se muestran los resultados del asesor experto iniciado en el "Campeonato de trading automatizado de 2012".
Recibir ajustes de símbolo con CSymbolInfo
Ya tenemos los datos en la cuenta pero también necesitamos conocer las propiedades del símbolo con el que vamos a negociar antes de realizar las operaciones necesarias. La clase CSymbolInfo, con un gran número de métodos, está diseñada para este propósito. Solo mostraremos una pequeña parte de los métodos en el ejemplo siguiente.
#include<Trade\SymbolInfo.mqh> //+------------------------------------------------------------------+ //| Función de inicialización del Experto | //+------------------------------------------------------------------+ int OnInit() { //--- ajustes en el objeto que recibe los símbolos CSymbolInfo symbol_info; //--- establecer el nombre del símbolo apropiado symbol_info.Name(_Symbol); //--- recibe y muestra los precios actuales symbol_info.RefreshRates(); Print(symbol_info.Name()," (",symbol_info.Description(),")", " Bid=",symbol_info.Bid()," Ask=",symbol_info.Ask()); //--- recibe los niveles mínimos de congelación para las operacioens de trading Print("StopsLevel=",symbol_info.StopsLevel()," pips, FreezeLevel=", symbol_info.FreezeLevel()," pips"); //--- recibe el número de posiciones decimales y el tamaño del entero Print("Digits=",symbol_info.Digits(), ", Point=",DoubleToString(symbol_info.Point(),symbol_info.Digits())); //--- información sobre el margen diferencial Print("SpreadFloat=",symbol_info.SpreadFloat(),", Spread(current)=", symbol_info.Spread()," pips"); //--- solicita el tipo de ejecución de orden para los límites Print("Límites para las operaciones de trading: ",EnumToString(symbol_info.TradeMode()), " (",symbol_info.TradeModeDescription(),")"); //--- determinar el modo de ejecución de operaciones Print("Modo de ejecución de operaciones: ",EnumToString(symbol_info.TradeExecution()), " (",symbol_info.TradeExecutionDescription(),")"); //---determina el método de cálculo del precio de los contratos Print("Cálculo del precio del contrato: ",EnumToString(symbol_info.TradeCalcMode()), " (",symbol_info.TradeCalcModeDescription(),")"); //--- tamaño de los contractos Print("Tamaño estándar de contrato: ",symbol_info.ContractSize(), " (",symbol_info.CurrencyBase(),")"); //--- volúmenes máximos y mínimos en las operaciones de trading Print("Volumen: LotsMin=",symbol_info.LotsMin()," LotsMax=",symbol_info.LotsMax(), " LotsStep=",symbol_info.LotsStep()); //--- Print(__FUNCTION__," completed"); //--- return(0); } //+------------------------------------------------------------------+ //| Función de deinicialización del Experto | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { //--- } //+------------------------------------------------------------------+ //| Función tick del Experto | //+------------------------------------------------------------------+ void OnTick() { //--- }
A continuación se muestran las propiedades de EURUSD en el campeonato de trading automatizado. Ahora estamos en condiciones de realizar operaciones de trading.
CTrade - La clase adecuada para las operaciones de trading
El trading en MQL5 es realizado solo por dos funciones: OrdenSend() y OrderSendAsync(). De hecho, son dos implementaciones de una única función. OrderSend() envía una solicitud de transacción y espera el resultado de su ejecución, mientras que la orden asíncrona OrderSendAsync() envía una solicitud permitiendo que la aplicación continúe operando sin esperar la respuesta del servidor. De esta forma, es realmente sencillo operar en MQL5, ya que solo usamos una única función para todas las operaciones de trading.
Entonces, ¿cuál es el reto? Ambas funciones reciben la estructura MqlTradeRequest con más de una docena de campos como primer parámetro. No todos los campos deben rellenarse necesariamente. El número de campos que es necesario rellenar depende del tipo de operación de trading. Los valores erróneos o los espacios en blanco cuando éstos requieren ser rellenados pueden dar como resultado un error y la solicitud no será enviada a un servidor. 5 de estos campos requieren los valores apropiados de enumeraciones predefinidas.
Es necesaria una cantidad de campos tan grande para poder describir el gran número de propiedades de una orden en una solicitud de transacción. Las órdenes pueden cambiar en función de la política de ejecución, fecha de caducidad y algunos otros parámetros. Pero no tiene por qué aprender todos estas sutilezas. Tan solo use la clase CTrade ya diseñada. Así es como puede usar la clase en su robot de trading:
#include<Trade\Trade.mqh> //--- objeto para realizar operaciones de trading CTrade trade; //+------------------------------------------------------------------+ //| Función de inicialización del Experto | //+------------------------------------------------------------------+ int OnInit() { //--- establece MagicNumber para la identificación de sus órdenes int MagicNumber=123456; trade.SetExpertMagicNumber(MagicNumber); //--- establece el retardo en los puntos cuando se compra/vende int deviation=10; trade.SetDeviationInPoints(deviation); //--- modo de ejecución de una orden, debe usarse el modo permitido por el servidor trade.SetTypeFilling(ORDER_FILLING_RETURN); //--- modo de registro (logging): sería mejor no declarar este método en absoluto ya que la clase establecerá el mejor modo por sí misma trade.LogLevel(1); //--- qué función se va a usar para el trading: true - OrderSendAsync(), false - OrderSend() trade.SetAsyncMode(true); //--- return(0); }
Veamos ahora cómo puede ayudarnos CTrade en las operaciones de trading.
Comprar/vender al precio actual
A menudo, las estrategias de trading ofrecen la posibilidad de comprar o vender al precio del momento. En este caso, CTrade solicita que se indique el volumen de operaciones de trading necesario. Todos los demás parámetros (precio abierto y nombre del símbolo, niveles de Stop Loss y Take Profit, comentarios de la orden) son opcionales.
//--- 1. Ejemplo de compra al símbolo actual if(!trade.Buy(0.1)) { //--- mensaje de error Print("Falló el método Buy() . Return code=",trade.ResultRetcode(), ". Descripción del código: ",trade.ResultRetcodeDescription()); } else { Print("método Buy() ejecutado con éxito. Return code=",trade.ResultRetcode(), " (",trade.ResultRetcodeDescription(),")"); }
Por defecto, CTrade usará el nombre del símbolo del gráfico que ha sido iniciado en caso de que dicho nombre no haya sido especificado. Es aconsejable para estrategias simples. Para estrategias con varias divisas debemos siempre especificar el símbolo en el que la operación de trading va a realizarse.
//--- 2. Ejemplo de compra al símbolo especificado if(!trade.Buy(0.1,"GBPUSD")) { //--- mensaje de error Print("Falló el método Buy(). Return code=",trade.ResultRetcode(), ". Descripción del código: ",trade.ResultRetcodeDescription()); } else { Print("método Buy() ejecutado con éxito. Return code=",trade.ResultRetcode(), " (",trade.ResultRetcodeDescription(),")"); }
Pueden especificarse todos los parámetros de la orden: niveles de Stop Loss/Take Profit, precio abierto y comentarios.
//--- 3. Ejemplo de compra al símbolo especificado con indicación de Stop Limit y Take Profit double volume=0.1; // especifica un volumen de operación string symbol="GBPUSD"; //especifica el símbolo para el que la operación se realiza int digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS); // número de posiciones decimales double point=SymbolInfoDouble(symbol,SYMBOL_POINT); // punto double bid=SymbolInfoDouble(symbol,SYMBOL_BID); // current price for closing LONG double SL=bid-1000*point; //valor Stop Limit no normalizado SL=NormalizeDouble(SL,digits); // normalizing Stop Loss double TP=bid+1000*point; // valor Take Profit no normalizado TP=NormalizeDouble(TP,digits); // normalizing Take Profit //--- recibe el precio abierto actual ara posiciones LARGAS double open_price=SymbolInfoDouble(symbol,SYMBOL_ASK); string comment=StringFormat("Buy %s %G lots at %s, SL=%s TP=%s", symbol,volume, DoubleToString(open_price,digits), DoubleToString(SL,digits), DoubleToString(TP,digits)); if(!trade.Buy(volume,symbol,open_price,SL,TP,comment)) { //--- mensaje de error Print("Falló el método Buy(). Return code=",trade.ResultRetcode(), ". Descripción del código: ",trade.ResultRetcodeDescription()); } else { Print("método Buy() ejecutado con éxito. Return code=",trade.ResultRetcode(), " (",trade.ResultRetcodeDescription(),")"); }
Como ya hemos señalado, el número mágico y los retardos aceptables se establecieron al inicializar la copia de CTrade. Por tanto, no son necesarios. Sin embargo, también pueden establecerse antes de cada operación de trading si es necesario.
Cursar una orden con precio límite
Para enviar una orden con precio límite se utiliza el método de clase adecuado de BuyLimit() o SellLimit(). La versión abreviada (cuando solo se indican un precio abierto y un volumen) será adecuada en la mayoría de casos. El precio abierto para una orden limitada de compra debe ser inferior al precio actual, mientras que debe ser superior para una orden limitada de venta. Estas órdenes se usan para entrar al mercado al mejor precio y normalmente son más adecuadas para las estrategias en las que se espera un alza de precios. En tal caso, se usa el símbolo al que ha sido iniciado el asesor experto:
//--- 1. Ejemplo de cursar una orden limitada de compra pendiente string symbol="GBPUSD"; // especifica el símbolo en el que se sitúa la orden int digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS); // número de posiciones decimales double point=SymbolInfoDouble(symbol,SYMBOL_POINT); // punto double ask=SymbolInfoDouble(symbol,SYMBOL_ASK); // precio de compra de divisa double price=1000*point; // precio abierto no normalizado price=NormalizeDouble(price,digits); // normalizing open price //--- todo está preparado, enviando una orden limitada de compra pendiente if(!trade.BuyLimit(0.1,price)) { //--- mensaje de error Print("Falló el método BuyLimit(). Return code=",trade.ResultRetcode(), ". Descripción del código: ",trade.ResultRetcodeDescription()); } else { Print("Método BuyLimit() ejecutado con éxito. Return code=",trade.ResultRetcode(), " (",trade.ResultRetcodeDescription(),")"); }
También puede utilizarse una versión más detallada especificando todos los parámetros: los niveles de órdenes Stop Limit/Take Profit, período de caducidad, nombre del símbolo y comentarios a la orden.
//--- 2. Ejemplo de cursar una orden con límite de compra pendiente con todos los parámetros double volume=0.1; string symbol="GBPUSD"; // especifica el símbolo en el que se sitúa la orden int digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS); // número de posiciones decimales double point=SymbolInfoDouble(symbol,SYMBOL_POINT); // punto double ask=SymbolInfoDouble(symbol,SYMBOL_ASK); // precio de compra actual double price=1000*point; // precio abierto no normalizado price=NormalizeDouble(price,digits); // normalizando el precio de compra int SL_pips=300; // Stop Loss en puntos int TP_pips=500; // Take Profit en puntos double SL=price-SL_pips*point; // valor SL no normalizado SL=NormalizeDouble(SL,digits); // normalizando Stop Loss double TP=price+TP_pips*point; // valor TP=NormalizeDouble(TP,digits); // normalizando Take Profit datetime expiration=TimeTradeServer()+PeriodSeconds(PERIOD_D1); string comment=StringFormat("Buy Limit %s %G lots at %s, SL=%s TP=%s", symbol,volume, DoubleToString(price,digits), DoubleToString(SL,digits), DoubleToString(TP,digits)); //--- todo está preparado, enviando una orden limitada de compra pendiente al servidor if(!trade.BuyLimit(volume,price,symbol,SL,TP,ORDER_TIME_GTC,expiration,comment)) { //--- mensaje de error Print("Falló el método BuyLimit(). Return code=",trade.ResultRetcode(), ". Descripción del código: ",trade.ResultRetcodeDescription()); } else { Print("Método BuyLimit() ejecutado con éxito. Return code=",trade.ResultRetcode(), " (",trade.ResultRetcodeDescription(),")"); }
Su tarea en la segunda versión es indicar los niveles de SL y TP correctamente. Debe señalarse que el nivel de Take Profit debe ser mayor que el precio abierto durante la compra, mientras que el nivel de Stop Level debe ser menor que el precio abierto. Para las órdenes Sell Limit se produce la situación opuesta. Puede fácilmente obtener información sobre su error al probar un asesor experto sobre datos históricos. En tales casos, la clase CTrade muestra automáticamente los mensajes (al menos que haya llamado a la función LogLevel).
Cursando una orden límite
Para enviar una orden límite, se utilizan los métodos BuyStop() y SellStop(). El precio abierto para la orden Buy Stop debería ser mayor que el precio actual, mientras que debería ser menor para la orden Sell Stop. Las órdenes límite se usan en estrategias que entran al mercado durante una salida del nivel de resistencia, así como para reducir las pérdidas. Versión simple:
//--- 1. ejemplo de cursar una orden Buy Stp pendiente string symbol="USDJPY"; // especifica el símbolo en el que se sitúa la orden int digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS); // número de posiciones decimales double point=SymbolInfoDouble(symbol,SYMBOL_POINT); // punto double ask=SymbolInfoDouble(symbol,SYMBOL_ASK); // precio de compra actual double price=1000*point; // precio abierto no normalizado price=NormalizeDouble(price,digits); // normalizando precio abierto //--- todo está preparado, enviando una orden Buy Stop pendiente al servidor if(!trade.BuyStop(0.1,price)) { //--- mensaje de error Print("BuyStop() method failed. Return code=",trade.ResultRetcode(), ". Descripción del código: ",trade.ResultRetcodeDescription()); } else { Print("método BuyStop() ejecutado con éxito. Return code=",trade.ResultRetcode(), " (",trade.ResultRetcodeDescription(),")"); }
Una versión más detallada cuando la cantidad máxima de parámetros para la orden Buy Stop pendiente debe ser especificada:
//--- 2. ejemplo de cursar una orden Buy Stop pendiente con todos los parámetros double volume=0.1; string symbol="USDJPY"; // especifica el símbolo en el que se sitúa la orden int digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS); // número de posiciones decimales double point=SymbolInfoDouble(symbol,SYMBOL_POINT); // punto double ask=SymbolInfoDouble(symbol,SYMBOL_ASK); // precio actual de compra double price=1000*point; // precio abierto no normalizado price=NormalizeDouble(price,digits); // normalizando precio abierto int SL_pips=300; // Stop Loss en puntos int TP_pips=500; // Take Profit en puntos double SL=price-SL_pips*point; // valor SL no normalizado SL=NormalizeDouble(SL,digits); // normalizando Stop Loss double TP=price+TP_pips*point; // valor TP no normalizado TP=NormalizeDouble(TP,digits); // normalizando Take Profit datetime expiration=TimeTradeServer()+PeriodSeconds(PERIOD_D1); string comment=StringFormat("Buy Stop %s %G lots at %s, SL=%s TP=%s", symbol,volume, DoubleToString(price,digits), DoubleToString(SL,digits), DoubleToString(TP,digits)); //--- todo está preparado, enviando una orden Buy Stop pendiente al servidor if(!trade.BuyStop(volume,price,symbol,SL,TP,ORDER_TIME_GTC,expiration,comment)) { //--- mensaje de error Print("El método BuyStop() ha fallado. Return code=",trade.ResultRetcode(), ". Descripción del código: ",trade.ResultRetcodeDescription()); } else { Print("método BuyStop() ejecutado con éxito. Return code=",trade.ResultRetcode(), " (",trade.ResultRetcodeDescription(),")"); }
Para enviar la orden Sell Stop se utiliza el método de clase apropiado de CTrade. La especificación correcta de los precios tiene aquí una importancia crítica.
Trabajando con posiciones
Puede usar métodos de apertura de posiciones en lugar de los de Buy() y Sell() pero, en este caso, tendrá que especificar más detalles:
//--- número de posiciones decimales int digits=(int)SymbolInfoInteger(_Symbol,SYMBOL_DIGITS); //--- valor del punto double point=SymbolInfoDouble(_Symbol,SYMBOL_POINT); //--- recibir un precio de compra double price=SymbolInfoDouble(_Symbol,SYMBOL_ASK); //--- calcula y normaliza los niveles de SL y TP double SL=NormalizeDouble(price-1000*point,digits); double TP=NormalizeDouble(price+1000*point,digits); //--- comentarios string comment="Buy "+_Symbol+" 0.1 at "+DoubleToString(price,digits); //--- todo está preparado, intentando abrir una posición de compra if(!trade.PositionOpen(_Symbol,ORDER_TYPE_BUY,0.1,price,SL,TP,comment)) { //--- mensaje de error Print("El método PositionOpen() ha fallado. Return code=",trade.ResultRetcode(), ". Descripción del código: ",trade.ResultRetcodeDescription()); } else { Print("El método PositionOpen() se ha ejecutado con éxito. Return code=",trade.ResultRetcode(), " (",trade.ResultRetcodeDescription(),")"); }
Tan solo necesita especificar un nombre de símbolo, el resto lo hará la clase CTrade.
//--- cerrando una posición en el símbolo actual if(!trade.PositionClose(_Symbol)) { //--- mensaje de error Print("El método PositionClose() ha fallado. Return code=",trade.ResultRetcode(), ". Descripción del código: ",trade.ResultRetcodeDescription()); } else { Print("El método PositionClose() se ha ejecutado con éxito. Return code=",trade.ResultRetcode(), " (",trade.ResultRetcodeDescription(),")"); }
Solo los niveles de Stop Loss y Take Profit están disponibles para modificar una posición abierta. Esto se realiza usando el método PositionModify()
//--- número de posiciones decimales int digits=(int)SymbolInfoInteger(_Symbol,SYMBOL_DIGITS); //--- valor del punto double point=SymbolInfoDouble(_Symbol,SYMBOL_POINT); //--- recibiendo el precio de compra actual double price=SymbolInfoDouble(_Symbol,SYMBOL_BID); //--- calcula y normaliza los niveles SL y TP double SL=NormalizeDouble(price-1000*point,digits); double TP=NormalizeDouble(price+1000*point,digits); //--- todo está preparado, intentando modificar la posición de compra if(!trade.PositionModify(_Symbol,SL,TP)) { //--- mensaje de error Print("El método PositionModify() ha fallado. Return code=",trade.ResultRetcode(), ". Descripción del código: ",trade.ResultRetcodeDescription()); } else { Print("El método PositionModify() se ha ejecutado con éxito. Return code=",trade.ResultRetcode(), " (",trade.ResultRetcodeDescription(),")"); }
Modificar y borrar una orden
El método OrderModify() ha sido implementado en la clase CTrade para cambiar los parámetros de la orden pendiente. Todos los parámetros requeridos deberían someterse a este método.
//--- este es un ticket de orden de prueba, debería ser recibido ulong ticket=1234556; //--- este es un símbolo de prueba, debería ser recibido string symbol="EURUSD"; //--- número de posiciones decimales int digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS); //--- valor del punto double point=SymbolInfoDouble(symbol,SYMBOL_POINT); //--- recibiendo un precio de compra double price=SymbolInfoDouble(symbol,SYMBOL_ASK); //--- calcula y normaliza los nivels SL y TP //--- deberían ser calculados en función del tipo de orden double SL=NormalizeDouble(price-1000*point,digits); double TP=NormalizeDouble(price+1000*point,digits); //--- establece un día de duración datetime expiration=TimeTradeServer()+PeriodSeconds(PERIOD_D1); //--- todo está preparado, intentando modificar la orden if(!trade.OrderModify(ticket,price,SL,TP,ORDER_TIME_GTC,expiration)) { //--- mensaje de error Print("El método OrderModify() ha fallado. Return code=",trade.ResultRetcode(), ". Descripción del código: ",trade.ResultRetcodeDescription()); } else { Print("El método OrderModify() se ha ejecutado con éxito. Return code=",trade.ResultRetcode(), " (",trade.ResultRetcodeDescription(),")"); }
Debería recibir el tique de la orden que debe ser cambiado. Deben especificarse los niveles adecuados de Stop Loss y Take Profit según su tipo. Además, el nuevo precio abierto debería también ser el adecuado para el precio actual.
Debería conocer el tique de una orden para borrarlo:
//--- este es un ticket de orden de prueba, debería ser recibido ulong ticket=1234556; //--- todo está preparado, intentando modificar una orden de compra if(!trade.OrderDelete(ticket)) { //--- mensaje de error Print("El método OrderDelete() ha fallado. Return code=",trade.ResultRetcode(), ". Descripción del código: ",trade.ResultRetcodeDescription()); } else { Print("El método OrderDelete() se ha ejecutado con éxito. Return code=",trade.ResultRetcode(), " (",trade.ResultRetcodeDescription(),")"); }
Esta clase contiene también el método de múltiples usos OrderOpen(), que puede trabajar con órdenes pendientes de cualquier clase. A diferencia de lo que ocurre con los métodos específicos BuyLimit, BuyStop, SellLimit y SellStop, requiere que se especifiquen más parámetros esenciales. Quizás lo encuentre más adecuado.
¿Qué más debemos resolver?
De esta forma, hemos respondido a dos de las tres preguntas. Ha elegido el símbolo para su estrategia y le hemos mostrado cómo escribir fácilmente el código de las operaciones de compra y venta y de las órdenes pendientes en un robot de trading. Sin embargo, la sección "clases para transacciones" dispone de algunas herramientas útiles más para los programadores de MQL5:
- COrderInfo - para el trabajo con órdenes;
- CHistoryOrderInfo - para el trabajo con órdenes ejecutadas en el historial de trading;
- CPositionInfo - para el trabajo con posiciones;
- CDealInfo - para el trabajo con contratos;
- CTerminalInfo - para recibir datos en el terminal (esta es muy interesante).
Con estas clases puede centrar su atención en la parte de trading de su estrategia, minimizando los aspectos técnicos. Además, puede usarse la clase CTrade para examinar las solicitudes de transacciones. Después de algo de práctica, será capaz de utilizarla para crear sus propias clases con la lógica necesaria de los resultados de la ejecución de la gestión de las solicitudes de trading.
La última pregunta es cómo recibir señales de trading y cómo crear dicho código en MQL5. La mayoría de principiantes en el trading algorítmico comienzan estudiando sistemas simples de trading, como por ejemplo los que se basan en el cruce de medias móviles. Para hacer esto, debería primero aprender a trabajar con indicadores técnicos, creándolos y usándolos en su robot de trading.
Le recomendamos que lea los artículos de las secciones sobre indicadores y ejemplos>indicadores comenzando por los más sencillos. Esto le permitirá ir de las cuestiones más sencillas a las más complejas. Si quiere hacerse una rápida idea sobre el uso de indicadores, consulte MQL5 para principantes: guía para el uso de indicadores técnicos en asesores expertos.
Simplifique las cosas complejas
En cualquier proyecto, las dificultades iniciales se convierten gradualmente en las cuestiones más simples. Los métodos para el desarrollo de robots de trading que se han mostrado aquí están dirigidos, sobre todo, a principiantes, aunque muchos programadores expertos pueden encontrar información nueva de gran utilidad.
El lenguaje MQL5 proporciona no solo ilimitadas oportunidades para el trading algorítmico, sino que también permite a cualquier persona implementarlos de la forma más simple y rápida. Utilice las clases de trading de la librería estándar para ahorrar tiempo en las cosas más importantes, como por ejemplo, para buscar la respuesta a la eterna pregunta de todos los operadores: qué es una tendencia y cómo puede encontrarse una en tiempo real.
Pronto verá que desarrollar un robot de trading en MQL5 ¡es mucho más fácil que aprender un idioma o seguir una tendencia!
Traducción del ruso hecha por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/ru/articles/481
Uso de los recursos en MQL5
Algoritmos que generan ingresos empleando órdenes Trailing Stop
MQL5 Wizard: Nueva Versión
Visualizar una estrategia en el simulador de Meta Trader 5
- 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