Trading Sistemático

Cómo Consultar la Última Operación Cerrada en MetaTrader 5
MetaTrader5
Cómo Consultar la Última Operación Cerrada en MetaTrader 5

En este artículo, te mostraré cómo obtener los datos de la última operación cerrada sin necesidad de usar bucles. Así podrás tener acceso rápido a información clave sobre tus operaciones.Primero, puedes crear una variable para establecer la hora de inicio del día. (Esto no es estrictamente necesario).También puedes crear algunas variables adicionales para mostrar un resultado gráfico y utilizarlas en otros bloques de código. (Esto tampoco es necesario).Utilizar este código dentro de la función OnTick(); mostrará el resultado en cada tick. También puedes configurarlo para que se ejecute una vez por cada barra.// Variables string DayStart = "00:00"; // Hora de inicio del día double LastClosed_Profit; // Beneficio de la última operación cerrada string TradeSymbol, TradeType; // Inicialización del Asesor Experto -------------------- int OnInit()   {    return(INIT_SUCCEEDED);   } // Desinicialización del Asesor Experto ------------------- void OnDeinit(const int reason)   {   } // Función OnTick -------------------------- void OnTick()   { // Verifica la última operación cerrada.    CheckLastClosed();   } //+------------------------------------------------------------------+ //+------------------------------------------------------------------+ void CheckLastClosed()   {    datetime HistoryTime = StringToTime(DayStart); // Historial desde el inicio del día hasta el tiempo actual    if(HistorySelect(HistoryTime,TimeCurrent))      {       int Total = HistoryDealsTotal();       // Obtener el número de ticket de la última operación y seleccionarlo para trabajar con él.       ulong Ticket = HistoryDealGetTicket(Total -1);       // Obtener los datos necesarios.       LastClosed_Profit = NormalizeDouble(HistoryDealGetDouble(Ticket,DEAL_PROFIT),2);       TradeSymbol      = HistoryOrderGetString(Ticket,ORDER_SYMBOL);       // Identificar si es una operación de venta.       if(HistoryDealGetInteger(Ticket,DEAL_TYPE) == DEAL_TYPE_BUY)         {          TradeType = "Operación de Venta";         }       // Identificar si es una operación de compra       if(HistoryDealGetInteger(Ticket,DEAL_TYPE) == DEAL_TYPE_SELL)         {          TradeType = "Operación de Compra";         }       // Salida gráfica.       Comment("\n","Total de Operaciones - :  ", Total,               "\n","Último Ticket - :  ", Ticket,               "\n", "Último Beneficio Cerrado -:  ", LastClosed_Profit,               "\n", "Última Operación fue -:  ", TradeType);      }   }//+------------------------------------------------------------------+ //+------------------------------------------------------------------+Además, puedes obtener el historial completo de operaciones (desde el inicio de la cuenta) utilizando la función HistorySelect(); de esta manera:// Obtener todo el historial HistorySelect(0,TimeCurrent());

2024.04.22
Optimiza tus operaciones: Cierre automático con botón y ganancias en MetaTrader 5
MetaTrader5
Optimiza tus operaciones: Cierre automático con botón y ganancias en MetaTrader 5

¡Hola, traders! Hoy les traigo una herramienta que puede facilitar mucho la gestión de nuestras operaciones en MetaTrader 5. Se trata de un sistema de trading que permite el cierre automático de órdenes con un solo clic. A continuación, les dejo todos los detalles para que puedan sacarle el máximo provecho. ¿Cómo usar este sistema? 1. Agrega este sistema a cualquier símbolo que estés operando. 2. Configura los valores que necesites para el Take Profit (TP), Stop Loss (SL), trailing y los umbrales de ganancias o pérdidas que desees aplicar a tus órdenes. 3. Este sistema no está basado en un número mágico específico, por lo que si colocas una orden desde tu dispositivo móvil, el sistema modificará automáticamente el SL, TP y el trailing. Características de modificación: 1. Cuenta con 5 botones separados para un manejo más fácil. 2. Cierre automático de todas las órdenes si se alcanza la ganancia, según el parámetro: "CERRAR SI GANANCIA-xxxx" (Coloca 0 si no deseas usar esta función). Ejemplo: Si colocas 100.0, se cerrarán todas las órdenes cuando la ganancia alcance $100. Si colocas 0.0, esta función no estará activada. 3. Cierre automático de todas las órdenes si se alcanza la pérdida, según el parámetro: "CERRAR SI PÉRDIDA-xxxx" (Coloca 0 si no deseas usar esta función). Ejemplo: Si colocas -70.0, se cerrarán todas las órdenes cuando la pérdida alcance -$70. Si colocas 0.0, esta función no estará activada. ¡Les deseo unas buenas operaciones y que esta herramienta les ayude a optimizar su trading! Historial de actualizaciones: - Se agregó el botón para cerrar órdenes de compra. - Se agregó el botón para cerrar órdenes de venta. - Se eliminó el parámetro no utilizado "Lots".

2024.04.21
QuickTradeKeys123: Tu Asistente para MetaTrader 5
MetaTrader5
QuickTradeKeys123: Tu Asistente para MetaTrader 5

¡Hola, traders! Hoy quiero hablarles sobre un recurso que puede ser un verdadero aliado en nuestra operativa diaria: el QuickTradeKeys 123, un EA diseñado para facilitarnos la vida en el mercado de divisas. Con este sistema, podrás reaccionar rápida y eficientemente ante cualquier movimiento del mercado. Te cuento cómo funciona: ¿Cómo Funciona QuickTradeKeys 123? Este EA permite realizar operaciones de manera muy sencilla, ¡todo con solo pulsar una tecla! Aquí te dejo un resumen de sus funcionalidades: Tecla '1': Abre una posición de compra con un tamaño de lote predefinido. Tecla '2': Abre una posición de venta con un tamaño de lote predefinido. Tecla '3': Cierra todas las posiciones abiertas que el EA haya gestionado, basándose en el número mágico especificado. Es muy fácil de usar, por lo que tanto los traders novatos como los más experimentados pueden beneficiarse de un control efectivo y rápido de sus operaciones a través del teclado. Ámbito de Aplicación El QuickTradeKeys 123 es apto para todos los pares de divisas y marcos de tiempo. Para obtener el mejor rendimiento y una ejecución veloz, es recomendable operar con un spread bajo y un acceso fluido al mercado. Instalación La instalación es muy sencilla: solo necesitas arrastrar el EA a tu gráfico deseado, asegurarte de que el trading automatizado esté habilitado en MetaTrader y que el EA tenga autorización para ejecutar operaciones. No olvides configurar el número mágico según tus necesidades en los ajustes de entrada. Importante Recuerda que este EA no está destinado para ser usado en cuentas reales a menos que comprendas completamente cómo funciona y los riesgos asociados. ¡Siempre es recomendable probarlo primero en una cuenta demo para familiarizarte con su comportamiento! Espero que esta información te sea útil y te ayude a mejorar tu experiencia de trading. ¡A darle duro al mercado!

2024.04.20
¿Qué es el Trailing Stop en MetaTrader 4? Clásico vs Virtual
MetaTrader4
¿Qué es el Trailing Stop en MetaTrader 4? Clásico vs Virtual

Hola, traders! Hoy vamos a hablar sobre una herramienta muy útil en el trading: el Trailing Stop. En MetaTrader 4, tenemos dos tipos: el Clásico y el Virtual. Vamos a entrar en detalle sobre cada uno y cómo pueden ayudarte a mejorar tus operaciones.Trailing Stop ClásicoEl Trailing Stop Clásico utiliza el Stop Loss para seguir el movimiento del mercado. Esto significa que el Stop Loss se ajusta automáticamente a medida que el precio se mueve a tu favor. Sin embargo, este ajuste se refleja en el servidor de tu bróker, lo que puede ser una ventaja o desventaja dependiendo del contexto. Aquí te dejo un par de definiciones clave:Trailing Gap: Es la distancia entre el precio Bid y Ask.Trailing Start: Es la distancia desde el precio de entrada de tu orden para comenzar a aplicar el trailing.Trailing Stop VirtualPor otro lado, el Trailing Stop Virtual no utiliza el Stop Loss para seguir el precio. En este caso, no se refleja en el servidor de tu bróker, lo que significa que puede ofrecerte más flexibilidad y menos riesgo de que tu operación se cierre por un pequeño retroceso. Es ideal para aquellos que prefieren mantener su estrategia un poco más discreta.En resumen, la elección entre el Trailing Stop Clásico y el Virtual dependerá de tu estilo de trading y de cómo te sientas más cómodo gestionando tus operaciones. ¡Espero que esta información te sea útil y te ayude a tomar decisiones más informadas en el mercado!

2024.04.19
Crea Bloques de Código para Contadores en MetaTrader 5
MetaTrader5
Crea Bloques de Código para Contadores en MetaTrader 5

01. Contar "X" veces y luego pasar. Paso 01: Crea una variable para establecer el límite de conteo. Puedes usarlo como un parámetro de entrada y también para la optimización en tu código. Paso 02: Crea otra variable para almacenar el límite contado (cuántas veces ha sido contado). Paso 03: Una vez que el contador y tu límite de conteo sean iguales, significa que es hora de pasar el bloque de código que especificaste. Paso 04: Una vez que el código haya pasado, asegúrate de reiniciar el contador también. De lo contrario, seguirá contando indefinidamente. Puedes establecer condiciones de filtrado para el bloque del contador también, como: >> "SI esto es verdadero, entonces cuenta una vez." input int conteo = 50; // Establecer el límite de conteo como una entrada int Contador; // variable del contador // Inicialización del Experto -------------------- int OnInit() { return(INIT_SUCCEEDED); } // Desinicialización del Experto ------------------- void OnDeinit(const int razon) { } // OnTick del Experto -------------------------- void OnTick() { Contador ++; // añade 1 al contador en cada tick. Comment("Conteo Actual -:", Contador); if(Contador == conteo) // Contar "X" veces y pasar | Este bloque se ejecuta solo una vez por cada conteo. {      // Tu código va aquí...... Alert(conteo," Veces contadas"); Contador = 0; // Reinicia el contador al final de tu bloque de código. Esto es necesario. } } // Fin de OnTick  <<---------------------- 02. Pasar "X" veces y luego esperar "X" veces y pasar. Este método se puede usar como esperar y pasar, pasar y esperar. Paso 01: Crea una variable para establecer el límite de conteo y límite de espera. Puedes usarlos como parámetros de entrada también para la optimización en tu código. Paso 02: Crea otra variable para almacenar los límites de conteo y espera (cuántas veces ha sido contado y cuántas veces ha esperado). Paso 03: Una vez que el Contador y tu límite de conteo sean iguales, significa que es hora de pasar el bloque de código que especificaste. Paso 04: Una vez que el esperador y tu límite de espera sean iguales, significa que es hora de esperar un poco. Paso 05: Una vez que se alcance el límite de espera, asegúrate de reiniciar el contador y el esperador también. De lo contrario, dejará de funcionar. Puedes establecer condiciones de filtrado para el bloque del contador y el bloque de espera también, como: >> "SI esto es verdadero, espera un momento." input int conteo = 50; // Establecer el límite de conteo como una entrada input int espera = 50; // Establecer el límite de espera como una entrada int Contador; // variable del contador con valor predeterminado "0" int Esperador; // variable de espera con valor predeterminado "0" // Inicialización del Experto -------------------- int OnInit()   {    return(INIT_SUCCEEDED);   } // Desinicialización del Experto ------------------- void OnDeinit(const int razon)   {   } // OnTick del Experto -------------------------- void OnTick()   {    Comment("Ticks contados -: ", Contador, "\n", "Ticks esperados -: ", Esperador);    if(Contador < conteo) // Pasar "X" veces      {       Contador++; // actualiza el contador       // Tu código va aquí.      }    else       if(Esperador < espera) // Esperar por "X" veces         {          Esperador++; // actualiza el esperador          // Tu código va aquí.         }    if(Esperador == espera) // Se alcanzó el límite de espera      {       Contador = 0; // reiniciar contador       Esperador = 0; // reiniciar esperador      }   } // Fin de OnTick  <<---------------------- //+------------------------------------------------------------------+ Especial -: Puedes programar el "Pasar X veces y detenerse" modificando el código anterior al eliminar el bloque de espera. Entonces contará un número específico y dejará de funcionar hasta que el contador sea reiniciado. Puedes reiniciarlo en cualquier parte de tu código si creas estas variables a nivel global.

2024.04.14
Detectar Nuevas Velas en MetaTrader 5: Un Método Efectivo
MetaTrader5
Detectar Nuevas Velas en MetaTrader 5: Un Método Efectivo

En el código anterior, utilizamos el tiempo para detectar una nueva vela. Esta vez, vamos a emplear el conteo de velas para identificar una nueva vela. Este método es mucho más ligero y rápido que el método basado en el tiempo. Declarar las variables en tipo de dato entero para almacenar el conteo de velas. Asignar el conteo de velas a la "BarsTotal_OnInt" durante la inicialización. Utilizar la función iBars(); para asignar el conteo de velas a la variable "BarsTotal_OnTick" en el gráfico en tiempo real. Esta variable se actualiza en cada tick. Emplear comentarios y alertas para verificar la precisión del código. int BarsTotal_OnInt; int BarsTotal_OnTick; //+------------------------------------------------------------------+ //| Función de inicialización del Expert                                   | //+------------------------------------------------------------------+ int OnInit()   {      BarsTotal_OnInt = iBars(NULL,PERIOD_CURRENT); // Asigna el total de velas en la inicialización    return(INIT_SUCCEEDED);   }    void OnTick() // Función OnTick   {      BarsTotal_OnTick = iBars(NULL,PERIOD_CURRENT); // Almacena la cantidad más reciente       if(BarsTotal_OnTick > BarsTotal_OnInt) // Ha llegado una nueva vela    {     BarsTotal_OnInt = BarsTotal_OnTick; // Actualiza la historia.     Alert("Nueva vela ha llegado");     Comment("Conteo de velas en la historia -: ", BarsTotal_OnInt, "\n", "Conteo de velas en vivo -: ", BarsTotal_OnTick); // Aquí va tu código. -------------------------- // Puedes actualizar una "bandera" / variable para usarla más tarde también.    }   }

2024.04.11
Gestiona tus Operaciones con el Asesor Experto Virtual SL TP Pending en MetaTrader 4
MetaTrader4
Gestiona tus Operaciones con el Asesor Experto Virtual SL TP Pending en MetaTrader 4

Hoy quiero hablarte sobre un script muy interesante que puede hacer tu vida como trader mucho más fácil: el "Virtual_SL_TP_Pending_with_SL_Trailing.mq4". Este Asesor Experto (EA) está diseñado para gestionar tus operaciones estableciendo niveles de stop loss y take profit virtuales, además de permitirte crear órdenes pendientes con una opción de stop loss dinámico. A continuación, desglosamos las características de este script: Derechos de Autor y Enlace: Incluye la información de derechos de autor y un enlace al sitio web del creador. Versión: Muestra la versión del script que estás utilizando. Descripción: Proporciona información sobre el script, incluyendo el correo electrónico del creador, detalles de propiedad intelectual y una advertencia sobre el uso del software bajo tu propio riesgo. Parámetros de Entrada: Variables externas que permiten personalizar el comportamiento del EA, que incluyen: StopLossPoints: Stop Loss inicial en puntos. TakeProfitPoints: Take Profit inicial en puntos. SpreadThreshold: Umbral de spread para el stop loss/take profit virtual en puntos. TrailingStopPoints: Stop dinámico en puntos para la orden pendiente virtual. EnableTrailing: Opción para habilitar o deshabilitar el stop dinámico. Variables Globales: Variables utilizadas en todo el script para almacenar el spread inicial, stop loss virtual, take profit virtual y el precio de la orden pendiente. Función de Inicialización (OnInit): Inicializa el EA al adjuntarlo a un gráfico, calculando el stop loss virtual inicial, el take profit y el precio de la orden pendiente basado en los parámetros de entrada. Función de Tick (OnTick): Se llama en cada tick del precio. Verifica si el spread ha aumentado más allá del umbral y ajusta el stop loss virtual, el take profit y el precio de la orden pendiente en consecuencia. También controla si el precio alcanza el stop loss o take profit virtual y cierra la posición. Si el stop dinámico está habilitado y el precio alcanza el precio de la orden pendiente, coloca una orden pendiente virtual con un stop loss dinámico. Función de Cierre de Posición (ClosePosition): Cierra la posición cuando el precio alcanza el stop loss o take profit virtual. Función de Colocación de Orden Pendiente (PlacePendingOrder): Coloca una orden pendiente virtual con un stop loss dinámico si está habilitado. Este EA te ofrece una manera flexible de gestionar tus operaciones utilizando niveles virtuales y una función de stop dinámico, permitiéndote automatizar tu proceso de gestión de operaciones en MetaTrader 4.

2024.04.10
Cierra Pairs de Divisas con Close Basket Pairs v1 para MetaTrader 4
MetaTrader4
Cierra Pairs de Divisas con Close Basket Pairs v1 para MetaTrader 4

¿Eres un trader que busca optimizar la gestión de tus posiciones en el mercado de divisas? Te presento un script de MQL4 que puede hacer tu vida más fácil: CloseBasketPairs.mq4. Este script está diseñado específicamente para cerrar posiciones en una cesta de pares de divisas cuando se alcanzan ciertos umbrales de ganancias o pérdidas. A continuación, te cuento un poco más sobre sus características: El script se llama CloseBasketPairs.mq4. Está protegido por derechos de autor de MetaQuotes Software Corp. en 2024. Ofrece un enlace a la página web de MetaQuotes. La versión del script es 1.01. El autor del script es persinaru@gmail.com. El script está licenciado bajo el IP 2024 - código abierto y gratuito. Su principal función es cerrar posiciones de una cesta de pares de divisas cuando se cumplen los umbrales de ganancias o pérdidas que se han establecido. Es importante mencionar que el uso del script es bajo tu propio riesgo, y el creador no se hace responsable por daños o pérdidas. Este script define los pares de divisas que forman parte de la cesta y sus tipos de órdenes, así como los umbrales de ganancias y pérdidas. Lo que hace es recorrer todas las posiciones abiertas y verificar si pertenecen a los pares definidos en la cesta. Si una posición cumple con los criterios establecidos (una ganancia que supera el umbral de ganancias o una pérdida que supera el umbral de pérdidas), el script procederá a cerrar dicha posición. Además, incluye funciones para la inicialización, desinicialización y manejo de eventos de ticks. La función PrintStrategyInfo() se utiliza para imprimir información sobre la estrategia implementada.

2024.04.10
Estrategia simple de seguimiento de tendencias para trading en MetaTrader 4
MetaTrader4
Estrategia simple de seguimiento de tendencias para trading en MetaTrader 4

Hoy quiero compartir con ustedes un script para MetaTrader 4 que implementa una estrategia sencilla de seguimiento de tendencias. Esta estrategia está diseñada para comprar y vender según condiciones predefinidas. A continuación, les dejo un desglose de cómo funciona: Inicialización: Cuando el script se inicializa correctamente, imprime un mensaje en el gráfico. Desinicialización: Al desinicializar, también imprime un mensaje para informar que ha terminado su ejecución. Función OnTick: Esta es la función que se ejecuta cada vez que hay un nuevo tick (cambio de precio) en el mercado. a. Reiniciar Variables de Seguimiento: El script reinicia las variables que rastrean las posiciones de compra y venta abiertas. b. Verificar Órdenes Abiertas: Se revisan todas las órdenes abiertas para ver si hay posiciones de compra o venta existentes. c. Abrir Posición de Compra: Si no hay una posición de compra abierta y la bandera "OpenBuyPosition" está activada, intenta abrir una posición de compra basada en el precio de oferta actual. También establece un stop loss y take profit para la orden de compra. d. Abrir Posición de Venta: Si no hay una posición de venta abierta y la bandera "OpenSellPosition" está activada, intenta abrir una posición de venta basada en el precio de demanda actual, estableciendo también un stop loss y take profit. e. Verificar Órdenes Cerradas: Se chequean las órdenes cerradas. Si una orden de compra o venta se cierra con ganancias, se reinicia la bandera correspondiente. Parámetros de Entrada: El script permite ajustar los parámetros de entrada como el tamaño del lote, el stop loss, el take profit y las banderas para controlar si se deben abrir posiciones de compra o venta. Aviso: Es importante señalar que el script incluye un aviso que aconseja a los usuarios utilizarlo bajo su propio riesgo, eximiendo al creador de cualquier responsabilidad por daños o pérdidas potenciales. En resumen, este script busca automatizar el proceso de ejecución de órdenes de compra y venta siguiendo una estrategia de tendencia continua. Además, permite a los usuarios personalizar parámetros como el tamaño del lote y la dirección de la operación. Sin embargo, es fundamental tener precaución y realizar pruebas exhaustivas antes de utilizarlo en un entorno de trading real.

2024.04.10
Crea un Trailing Stop Dinámico en MetaTrader 5: Guía Práctica
MetaTrader5
Crea un Trailing Stop Dinámico en MetaTrader 5: Guía Práctica

Este bloque de código funciona si utilizas un Stop Loss o no. Requisitos Necesitas incluir "Trade.mqh" para acceder a la clase CTrade, que te permite trabajar con posiciones y órdenes. #include <Trade\Trade.mqh> // <<------------------------------------------ Incluye "Trade.mqh" para acceder a la clase CTrade Debes establecer un parámetro de entrada para ajustar la distancia del trailing stop como desees. Esto no es obligatorio, pero es conveniente. input double Traling_Step = 3.0; Necesitas definir una instancia de la clase CTrade. El nombre puede ser cualquier nombre que elijas. Es recomendable definirla después del manejador de eventos OnInit. Luego, debes crear una sentencia if para verificar si hay alguna posición activa en ese momento. Esta sentencia llama a la función Check_TrailingStop(); para cada tick. Esto es importante porque el EA debe hacer el trailing de manera rápida y suave. Recuerda colocar esta sentencia al inicio del manejador de eventos OnTick para que funcione correctamente. //+------------------------------------------------------------------+ //| Función de inicialización del Expert                                   | //+------------------------------------------------------------------+ int OnInit()   {    //--- crea un temporizador    EventSetTimer(60); //---    return(INIT_SUCCEEDED);   } // <<------------------------------------------ Declara la clase "CTrade". Puedes reemplazar "trade" por cualquier nombre que quieras CTrade trade; void OnTick()   {    if(PositionsTotal() > 0) // llama a la función de trailing stop para cada tick si hay posiciones en ejecución.      {       Check_TralingStop();      }               } Necesitas declarar una función personalizada llamada Check_TrailingStop(); (en este caso) para realizar el resto. Puedes usar cualquier nombre que desees. La función personalizada recorre todas las posiciones abiertas y las ajusta a la distancia que necesites. void Check_TralingStop()   {    int totalPositions = PositionsTotal();    for(int count =0; count < totalPositions; count++)      {       ulong TicketNo = PositionGetTicket(count); // Obtiene el número de ticket de la posición usando el 'índice' de la posición.       if(PositionSelectByTicket(TicketNo)) // Selecciona una posición usando el número de ticket (ya hemos obtenido el ticket).         {            if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) // Verifica el tipo de posición.            {             double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);             double stopLoss  = PositionGetDouble(POSITION_SL);       // <<-------------------Obtiene el Stop Loss actual de la posición             double takeProfit = PositionGetDouble(POSITION_TP);             double bidPrice  = SymbolInfoDouble(_Symbol,SYMBOL_BID);             ulong ticket = PositionGetTicket(count);             double trailingLevel = NormalizeDouble(bidPrice - (Traling_Step * Point()),_Digits);             if(stopLoss < openPrice) // Si el Stop Loss es nulo.               {                if(bidPrice > openPrice && trailingLevel > openPrice) // Se ejecuta solo una vez por posición. Establece el primer SL.                 trade.PositionModify(ticket,trailingLevel,takeProfit); // Modifica el Trailing Stop usando "CTrade.trade"               }             if(bidPrice > openPrice && trailingLevel > stopLoss) // Verifica si el nivel de trailing está por encima del nivel anterior.               {                trade.PositionModify(ticket,trailingLevel,takeProfit); // Modifica el Trailing Stop usando "CTrade.trade"               }            }          if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)            {             double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);             double stopLoss  = PositionGetDouble(POSITION_SL);             double takeProfit = PositionGetDouble(POSITION_TP);             double bidPrice  = SymbolInfoDouble(_Symbol,SYMBOL_BID);             double askPrice  = SymbolInfoDouble(_Symbol,SYMBOL_ASK);             ulong ticket = PositionGetTicket(count);             double trailingLevel = NormalizeDouble(askPrice + (Traling_Step * Point()),_Digits);             if(stopLoss < openPrice) // Si el Stop Loss es nulo.               {                if(askPrice < openPrice && trailingLevel < openPrice) // Se ejecuta solo una vez por posición. Establece el primer SL.                 trade.PositionModify(ticket,trailingLevel,takeProfit); // Modifica el Trailing Stop usando "CTrade.trade"               }             if(askPrice < openPrice && trailingLevel < stopLoss) // Verifica si el nivel de trailing está por debajo del nivel anterior.               {                trade.PositionModify(ticket,trailingLevel,takeProfit); // Modifica el Trailing Stop usando "CTrade.trade"               }            }       }      }   }

2024.04.05
Código Sencillo para Detectar Nuevas Velas en MetaTrader 5
MetaTrader5
Código Sencillo para Detectar Nuevas Velas en MetaTrader 5

En este artículo, vamos a ver un código que detecta una nueva vela o nuevo bar en MetaTrader 5 cuando se recibe. El principio básico de este código es muy simple. Primero, el código guarda el tiempo de la vela anterior. Luego, añade 60 segundos (equivalente a 1 minuto; puedes ajustar el tiempo como desees) al tiempo de la vela anterior, lo que nos da el valor de cierre de la vela actual. Una vez que: Tiempo Actual = valor de cierre de la vela actual, eso significa que se ha recibido una nueva vela o que la vela actual ha cerrado. En este código, la variable booleana NewBarRecived evita que este bloque de código se ejecute múltiples veces, asegurando que se ejecute solo una vez por cada vela. Las funciones Comment(); y PlaySound("ok.wav"); se utilizan para verificar la precisión del bloque de código. Puedes eliminarlas si lo prefieres. La bandera se restablece a false una vez que el tiempo actual supera el tiempo de cierre de la vela actual, lo que permite verificar la llegada del siguiente bar. (Revisa los comentarios para más detalles). //+------------------------------------------------------------------+ //|                                                  Detectar Nueva Vela.mq5 | //|                                                  por H A T Lakmal | //|                                                   https://t.me/Lakmal846 | //+------------------------------------------------------------------+ bool NewBarRecived = false; // Bandera para control. //+------------------------------------------------------------------+ //| Función de inicialización del experto                                   | //+------------------------------------------------------------------+ int OnInit()   { //--- crear temporizador    EventSetTimer(60); //---    return(INIT_SUCCEEDED);   } //+------------------------------------------------------------------+ //| Función de desinicialización del experto                                 | //+------------------------------------------------------------------+ void OnDeinit(const int reason)   { //--- destruir temporizador    EventKillTimer();   } //+------------------------------------------------------------------+ //| Función de tick del experto                                             | //+------------------------------------------------------------------+ void OnTick()   {    datetime TimePreviousBar = iTime(_Symbol,PERIOD_M1,1);    datetime TimeCurrentClose = TimePreviousBar + 60; // Tiempo de cierre de la vela actual.    datetime Time_Current = TimeCurrent();    if(Time_Current == TimeCurrentClose && NewBarRecived == false)      {       PlaySound("ok.wav");   // Para verificar que funcione correctamente.       NewBarRecived = true; // Actualiza la bandera para evitar llamadas múltiples.       // Aquí va tu código ----- (Haz algo)      }    else       if(Time_Current > TimeCurrentClose)         {          NewBarRecived = false; // Restablece la bandera para la próxima apertura de bar.          // Aquí va tu código ----- (Haz algo)         }    Comment(" " +  " " +  "Tiempo de la Vela Actual -: " + TimeToString(TimePreviousBar,TIME_DATE|TIME_MINUTES|TIME_SECONDS) +            " " + "Tiempo de Cierre Actual -: " +TimeToString(TimeCurrentClose,TIME_DATE|TIME_MINUTES|TIME_SECONDS) +            " " + "Tiempo Actual -: " + TimeToString(Time_Current,TIME_DATE|TIME_MINUTES|TIME_SECONDS) + " " +" " + "Una Nueva Vela Recibida -: " + NewBarRecived); // Para verificar cálculos   } //+------------------------------------------------------------------+ //| Función del temporizador                                                   | //+------------------------------------------------------------------+ void OnTimer()   { //---   } //+------------------------------------------------------------------+ //| Función de trading                                                    | //+------------------------------------------------------------------+ void OnTrade()   { //---   } //+------------------------------------------------------------------+ //| Función de eventos del gráfico                                                  | //+------------------------------------------------------------------+ void OnChartEvent(const int id,                   const long &lparam,                   const double &dparam,                   const string &sparam)   { //---   } //+------------------------------------------------------------------+  

2024.04.05
Cierra tus operaciones con ganancias o pérdidas en la divisa de tu cuenta: Optimización para MetaTrader 4
MetaTrader4
Cierra tus operaciones con ganancias o pérdidas en la divisa de tu cuenta: Optimización para MetaTrader 4

//+------------------------------------------------------------------------------------------------------------------------------+ //| Optimización de Cierra_tus_operaciones_con_ganancias_o_pérdidas_en_la_divisa_de_tu_cuenta_V2: Novedades: //| //| 1. Manejo de Errores: El código ahora incluye un manejo de errores para situaciones donde las órdenes no pueden ser cerradas o eliminadas. //| 2. Optimización del Código: Se ha optimizado el código para evitar repeticiones y mejorar la legibilidad. //| 3. Eficiencia: Se han eliminado bucles o cálculos innecesarios. //| 4. Limpieza de objetos en el gráfico al desinicializar el Asesor Experto. //+------------------------------------------------------------------------------------------------------------------------------+ Al establecer 0, el Asesor Experto no realizará ninguna acción.    La Cierre_Ganancias_en_Divisa_de_Cuenta debe ser mayor que la cantidad actual de Equidad, de lo contrario, las operaciones se ejecutarán inmediatamente. Ejemplo: Si la Equidad es de 55,000€ y la Cierre_Ganancias_en_Divisa_de_Cuenta está configurada en 55,500€ para obtener 500€. Cierre_Ganancias_en_Divisa_de_Cuenta  > O && <  55,000€ = ejecución inmediata La Cierre_Pérdidas_en_Divisa_de_Cuenta debe ser menor que la cantidad actual de Equidad, de lo contrario, las operaciones se ejecutarán inmediatamente. Ejemplo: Si la Equidad es de 55,000€ y la Cierre_Pérdidas_en_Divisa_de_Cuenta está configurada en 54,500€ para perder solo 500€.  Cierre_Pérdidas_en_Divisa_de_Cuenta  > 55,000€ = ejecución inmediata Los picos en el spread pueden evitarse reduciendo el número del spread, pero el mercado hará lo que quiera y pueden ocurrir ganancias o pérdidas mayores.  Si el spread se establece por debajo del spread promedio de los pares negociados, esas posiciones no se ejecutarán.  ADVERTENCIA: Usa este software bajo tu propio riesgo. ¡El mercado Forex es muy volátil!  #propiedad copyright     "Copyright 2024, MetaQuotes Ltd." #propiedad enlace          "https://www.mql5.com" #propiedad versión       "1.01" #propiedad descripción   "persinaru@gmail.com" #propiedad descripción   "IP 2024 - código abierto gratuito" #propiedad descripción   "Este EA cierra todas las operaciones en ganancias y pérdidas calculadas en la divisa de la cuenta." #propiedad descripción   "" #propiedad descripción   "ADVERTENCIA: Usa este software bajo tu propio riesgo." #propiedad descripción   "El creador de este script no se hace responsable de ningún daño o pérdida." #propiedad descripción   "" #propiedad estricto #propiedad mostrar_inputs extern string  Descripción = "Este EA cierra todas las operaciones y órdenes pendientes cuando se alcanza una ganancia o pérdida. Las ganancias y pérdidas se calculan en la divisa de la cuenta.";  extern int Cierre_Ganancias_en_Divisa_de_Cuenta     = 0;  extern int Cierre_Pérdidas_en_Divisa_de_Cuenta     = 0;  extern int Spread = 10;

2024.03.25
Guía Práctica sobre Redes Neuronales para Trading Algorítmico con MQL5
MetaTrader5
Guía Práctica sobre Redes Neuronales para Trading Algorítmico con MQL5

El libro "Redes neuronales para trading algorítmico con MQL5" es tu compañero ideal para aprender a utilizar el aprendizaje automático y las redes neuronales en el trading. Este material está dirigido a traders algorítmicos que desean dominar la creación de estrategias de trading utilizando técnicas avanzadas de inteligencia artificial. La obra consta de 7 capítulos que abarcan todo lo que necesitas saber para iniciarte en el uso de redes neuronales e integrarlas en tus robots de trading en MQL5. Con explicaciones claras y sencillas, aprenderás los fundamentos del aprendizaje automático y descubrirás diferentes tipos de redes neuronales, incluyendo modelos convolucionales y recurrentes, así como soluciones arquitectónicas más complejas y mecanismos de atención. Para facilitar la integración de estas soluciones en tus robots de trading dentro del entorno MQL5, el libro ofrece una gran cantidad de ejemplos prácticos. Además, se exploran diversos métodos para mejorar la convergencia de los modelos, tales como la Normalización por Lotes y el Dropout. El autor también brinda orientación práctica sobre cómo entrenar redes neuronales y cómo incorporarlas en tus estrategias de trading. Aprenderás a crear Asesores Expertos que te permitirán probar el rendimiento de los modelos entrenados con nuevos datos, lo que te permitirá evaluar su potencial en los mercados financieros reales. "Redes neuronales para trading algorítmico con MQL5" no es solo un libro, es una guía práctica que te ayudará a integrar técnicas avanzadas de toma de decisiones en tus algoritmos de trading y mejorar tus resultados financieros. Comienza a aprender hoy sobre las capacidades avanzadas del aprendizaje automático y lleva tu trading al siguiente nivel.

2024.02.29
EA Manual de Compra y Venta para Traders Novatos en MetaTrader 4
MetaTrader4
EA Manual de Compra y Venta para Traders Novatos en MetaTrader 4

¡Hola traders! Hoy quiero hablarles sobre el EA Manual de Compra y Venta que es ideal para aquellos que están comenzando en el mundo del trading. Este Asesor Experto es perfecto para practicar y mejorar tu estrategia de trading, tanto en modo de retroceso como en operaciones en vivo. Con este EA, puedes probar tu propio sistema de trading usando el modo de retroceso, lo cual es excelente para entender cómo funciona el mercado y ajustar tus estrategias. El EA Manual de Compra y Venta te permite operar manualmente, pausar o modificar la velocidad de la revisión de retroceso, lo que facilita el ejercicio de trading manual. ¿Cómo Funciona? Veamos los distintos botones que encontrarás: 1. Botón de [Lots]: Después del cuadro de entrada, puedes modificar el número de lotes. 2. Botón de [BUY]: Al presionar este botón, se colocará una orden de compra con el número de lotes especificados. 3. Botón de [SELL]: Presionándolo, colocarás una orden de venta con el tamaño de lote especificado. 4. Botón de [SL Modify TP]: Este botón te permite modificar el Stop Loss y el Take Profit. Al presionarlo, se ajustará el Stop Loss y el Take Profit de todas las órdenes en relación con el precio actual. 5. Botón de [Close All Buy]: Este botón cerrará todas las órdenes de compra abiertas. 6. Botón de [Close All Sell]: Al presionar este botón, cerrarás todas las órdenes de venta abiertas. 7. Botón de [Close All Orders]: Usando este botón, podrás cerrar todas las órdenes en el mercado. 8. Información de órdenes abiertas: En el lado derecho de la pantalla, podrás ver la información sobre las órdenes abiertas y las ganancias. Descripción de Parámetros A continuación, algunos parámetros clave que deberías conocer: 1. MM: Calcula automáticamente el tamaño de lote predeterminado usando la relación de riesgo. 2. Riesgo: Por ejemplo, 0.2 para un balance de 10,000 significará 0.2 lotes. 3. Lotes: Tamaño fijo de lotes si MM está desactivado, se usará este número fijo. 4. SL: Stop Loss, el valor predeterminado es de 250 micro-puntos. 5. TP: Take Profit, el valor predeterminado es de 500 micro-puntos. Además, hay otros parámetros relacionados con la interfaz que puedes ajustar según tus necesidades. ¡Así que anímate a practicar tu propio sistema de trading! Gracias a todos por leer y espero que encuentren útil esta información.

2024.02.29
Primero Anterior 2 3 4 5 6 7 8 9 10 11 12 Siguiente Último