Cualquier pregunta de novato, para no saturar el foro. Profesionales, no pasen de largo. En ninguna parte sin ti - 6. - página 1096
Está perdiendo oportunidades comerciales:
- Aplicaciones de trading gratuitas
- 8 000+ señales para copiar
- Noticias económicas para analizar los mercados financieros
Registro
Entrada
Usted acepta la política del sitio web y las condiciones de uso
Si no tiene cuenta de usuario, regístrese
¡Hola!
¿Cómo se puede determinar si una posición está cerrada en TP? No creo que OrderClosePrice()==OrderTakeProfit() sea correcto de usar.
En el comentario de la orden busque [tp] si hay...
En el comentario de la orden busque [tp] si hay uno...
Hola Profi.
ayudar a corregir el error en el indicador.....
indicador está funcionando.
La señal se activa en la barra 0.
Pero cuando se reciben otros ticks en la barra actual, se dispara de nuevo y da nuevas señales.
Necesito que ponga esta señal en un círculo en el lugar del precio del evento actual cuando ocurra el evento de Venta o Compra, y no se hayan procesado otros eventos en esta barra abierta.
Quiero evitar nuevas señales y círculos en esta barra.
________________________
Entiendo que dirán que es una tontería, que son señales falsas, etc., pero esto es exactamente lo que necesito.
Sé que debería crear una bandera, un marcador, etc., pero no tengo tiempo para estudiar el idioma por mí mismo.
_________________________
Le agradecería mucho que añadiera dicha bandera al archivo adjunto y que marcara las líneas añadidas con el color.....
Gracias, y espero que alguien responda
Comete un par de errores, no puede hacerlo bien. ¿Qué pasa aquí?
//+------------------------------------------------------------------+Por favor, ayúdenme a comerciar con las noticias. Necesito un EA que tenga dos funciones principales.
La primera función: colocarórdenes pendientes con un TP y un SL determinados, en un momento dado y a un nivel de precio determinado.
La segunda función: mantener las órdenes pendientes en paralelo al precio. Significa moverlos junto con el precio (es muy molesto hacerlo manualmente). En un momento dado, en el momento de la publicación de la noticia, tenemos que detener esta acción y esperar hasta que el precio toque una de las órdenes. La segunda orden se elimina inmediatamente después.
Una vez más:
2 minutos antes de la publicación de la noticia, ponga dos órdenes de stop opuestas a una distancia de 10 puntos del precio, inmediatamente active la función de movimiento paralelo al precio, 2 minutos se mueven junto con el precio, una orden se aleja del precio, la segunda se pone al día con el precio. En el momento de la publicación de la noticia, debe desactivar la función de movimiento de órdenes pendientes y esperar a que se produzca el desglose de una de las órdenes. La segunda orden se elimina inmediatamente después de la ruptura de la primera.
Variables que se modifican en las propiedades de un EA (aproximadamente como me imagino, no sé cuál es la realización en la realidad)
TP - 600 (por defecto)
Trall - 300 (por defecto)
SL - 100 (por defecto)
Pips - 100 (distancia del precio por defecto)
Deslizamiento - 100 (deslizamiento en pips por defecto)
Lote - 0,1
Riesgo - 10 //por ciento (bueno, no es necesario, lo preguntaré más tarde si es necesario)
TimeNews1On - true (utilice las celdas de abajo para introducir la hora, false - el asesor no las negocia)
HoraNewsHour - hora (hora de publicación de noticias 1)
TimeNewsMin - minutos (tiempo del comunicado de prensa 1)
TimeNews2On - false (por defecto)
TiempoHoraDeLasNoticias - horas (tiempo de las noticias 2)
TimeNewsMin - minutos (tiempo del comunicado de prensa 2)
TimeNews3On - falso
TiempoHoraDeLasNoticias - horas (tiempo de las noticias 3)
TimeNewsMin - minutos (tiempo del comunicado de prensa 3)
TimeNews4On - falso
TiempoHoraDeNoticias - horas (tiempo de publicación de noticias 4)
TimeNewsMin - minutos (tiempo del comunicado de prensa 4)
TimeNews5On - falso
TiempoHoraDeNoticias - horas (tiempo de publicación de noticias 5)
TimeNewsMin - minutos (tiempo del comunicado de prensa 5)
Insta, cinco dígitos.
Todo esto lo estoy haciendo manualmente, es demasiado problema, y ahora no tengo tiempo para elaborar las noticias, quiero colocar el Expert Advisor por la mañana o por la noche en los pares en los que habrá noticias ese día, para que todos funcionen.
--------------------------------------
Si conoce a un experto de este tipo, por favor, compártalo.
Gracias de antemano.
Volvamos a su código fuente. Pruébalo así:
int OnInit()
{
if (!GlobalVariableCheck("AllowNewOrders")) GlobalVariableSet("AllowNewOrders",1);
return(INIT_SUCCEED);
}
void OnDeInit()
{
GlobalVariableSet("AllowNewOrders",1);
}
void OnTick()
{
if (CountTrades() == 0) // El número de órdenes debe ser cero
{
if ((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) < PriceOpenLastHistOrder(OP_BUY))
|| (TypeLastHistOrder() == OP_SELL && PriceCloseLastHistOrder(OP_SELL) > PriceOpenLastHistOrder(OP_SELL))
// Si la última operación es perdedora, se abre la misma, pero con un lote mayor
{
GlobalVariableSet("AllowNewOrders", 0);
Tipo = TypeLastHistOrder();
if (Type == OP_BUY) Precio = Ask;
if (Type == OP_SELL) Precio = Oferta;
Lote = NormalizeDouble(LotsLastHistOrder()*Multiplier, 2);
ticket = OrderSend(Symbol(), Type, Lot, Price, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
if (PriceCloseLastHistOrder() == PriceOpenLastHistOrder() && CountHistTrades() > 0)
// si el beneficio de la última operación es igual a cero, se abrirá la misma operación
{
GlobalVariableSet("AllowNewOrders", 0);
Tipo = TypeLastHistOrder();
if (Type == OP_BUY) Precio = Ask;
if (Type == OP_SELL) Precio = Oferta;
Lot = NormalizeDouble(LotsLastHistOrder(), 2);
ticket = OrderSend(Symbol(), Type, Lot, Price, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
if (((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) > PriceOpenLastHistOrder(OP_BUY))
|| (TypeLastHistOrder() == OP_SELL && PriceCloseLastHistOrder(OP_SELL) < PriceOpenLastHistOrder(OP_SELL))
|| CountHistTrades() == 0)// Si la última operación es rentable, abrir orden
{
if (GlobalVariableGet("AllowNewOrders") > 0)return;
if (SignalBuy() && MaxOpenOrders > OrdersTotal())
{
ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, Slippage, 0, 0, IntegerToString(Exp), Magic);
if (ticket>0) GlobalVariableSet("AllowNewOrders", 0);
}
if (SignalSell() && MaxOpenOrders > OrdersTotal())
{
ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage, 0, 0, IntegerToString(Exp), Magic);
if (ticket>0) GlobalVariableSet("AllowNewOrders", 0);
}
}
}
}
No lo he comprobado, porque no entiendo cómo varias copias de un EA con un límite total de 1 orden van a determinar en qué símbolo (después de una serie rentable) es mejor empezar a operar?
Por favor, ayuden a operar con las noticias. Realmente necesito un EA que debe tener dos funciones principales.
Primera función: colocarórdenes pendientes con un TP y un SL determinados, en un momento determinado y a un nivel determinado del precio.
La segunda función: mantener las órdenes pendientes en paralelo al precio. Significa moverlos junto con el precio (es demasiado molesto hacerlo manualmente). En un momento dado, en el momento de la publicación de la noticia, tenemos que detener esta acción y esperar hasta que el precio toque una de las órdenes. La segunda orden se elimina inmediatamente después.
Una vez más:
2 minutos antes de la publicación de la noticia, ponga dos órdenes de stop opuestas a una distancia de 10 puntos del precio, inmediatamente active la función de movimiento paralelo al precio, 2 minutos se mueven junto con el precio, una orden se aleja del precio, la segunda lo alcanza. En el momento de la publicación de la noticia, debe desactivar la función de movimiento de órdenes pendientes y esperar a que se produzca el desglose de una de las órdenes. La segunda se borrará inmediatamente después de la ruptura de la primera.
Si conoce o ha conocido a estos asesores, por favor comparta
Gracias de antemano.
Puedo enviarte el código para leer las noticias de un archivo, puede ser útil. Una vez a la semana, se mira el calendario económico y se introducen los datos en el archivo carpeta_con_terminal\MQL4\Files\novosti.txt de las noticias a las que hay que prestar atención, el asesor se puede activar incluso justo antes de las noticias (se puede utilizar este asesor para seguir el inicio de la sesión americana, por ejemplo - en caso de que haya un fuerte movimiento). No he terminado el código de comercio porque me han "engañado" seriamente un par de veces las noticias :)) La última versión colocó seis órdenes (3 stops de compra + 3 stops de venta) a diferentes distancias con diferentes Take Profit. De todos modos, mi código de noticias funciona, pero tengo que mejorar mi código de operaciones.
#propiedad estricta
input string NewsFilename = "novosti.txt"; // Nombre del archivo de texto que contiene las noticias
input int MinutosAntes = 5; // Cuántos minutos antes de la publicación de la noticia deben realizarse los pedidos
input int MinutesAfter1 = 15; // cuántos minutos después de la publicación de la noticia se eliminan las órdenes del primer grupo
input int MinutosDespués2 = 30; // cuántos minutos después de la publicación de la noticia se eliminan las órdenes del Grupo 2
input int MinutosDespués3 = 30; // cuántos minutos después de la publicación de la noticia se eliminan las órdenes del Grupo 3
input int PrecioIndent1 = 15; // Indentación del precio en puntos
input int PriceIndent2 = 5; // Retrocede desde el TakeProfit anterior en puntos
input int TakeProfit1 = 40; // Tamaño de TakeProfit para el primer grupo en puntos
input int TakeProfit2 = 60; // Tamaño de TakeProfit para el 2º grupo en puntos
input int TakeProfit3 = 100; // Tamaño de TakeProfit para el tercer grupo en puntos
input int StopLoss = 20; // Tamaño del StopLoss para todas las órdenes en puntos
input double Multiplicador1 = 1.0; // Coeficiente al lote de pedido del 2º grupo
input double Multiplicador2 = 2.0; // coeficiente a los lotes de orden del 3er grupo
input int RiesgoMáximo = 10; // Riesgo máximo en porcentajes
//====================================================================================================
datetime Times[200]; // LastTime;
cadena Símbolos[200];
bool NoticiasPasadas[200];
int Cuenta de noticias;
//====================================================================================================
int OnInit()
{
// Cargando noticias frescas
if (!LoadNews()) return(INIT_FAILED);
return(INIT_SUCCEED);
}
//====================================================================================================
void OnTick()
{
if (!IsTradeAllowed()) return;
datetime TestTime = iTime(Symbol(), PERIOD_H1, 0);
// Actualización de las noticias al principio de cada día
if (TimeDay(TestTime) != TimeDay(LastTime))
{
LastTime = TestTime;
if (!LoadNews())
{
Alert("¡Error de actualización de noticias!");
volver;
}
}
//-------------------------------------------------------------------------------------------------
for (int i = 0; i < NewsCount; i++)
{
// El comunicado de prensa de Till puso órdenes de avance
if (Times[i] > TimeCurrent() && Times[i] - TimeCurrent() <= MinutesBefore * 60 && !NewsPassed[i])
{
PrintFormat("La hora actual es %s, es hora de establecer las órdenes de moneda - %s", TimeToStr(TimeCurrent(), TIME_DATE|TIME_MINUTES), Symbols[i]);
SetupOrders(Symbols[i];
NewsPassed[i] = true;
}
}
//-------------------------------------------------------------------------------------------------
}
//====================================================================================================
bool CargarNoticias()
{
int Cuenta, Tic = 0;
string Str, Datos[40];
ResetLastError();
if (!FileIsExist(NewsFilename, 0))
{
PrintFormat("El archivo de noticias %s no existe", NewsFilename);
Print("El archivo debe estar en la carpeta \MQL4\Files, en caso de prueba - en la carpeta \Tester\Files.");
return(false);
}
int Handle = FileOpen(NewsFilename, FILE_READ|FILE_SHARE_READ|FILE_TXT);
if (Handle != INVALID_HANDLE)
{
while (!FileIsEnding(Handle))
{
Str = FileReadString(Handle);
Count = StringSplit(Str, StringGetChar(" ", 0), Data);
for (int i = 1; i < Count; i = i + 2)
{
Times[Tick] = StringToTime(Data[0] + " + Data[i]);
Símbolos[Tick] = Datos[i + 1];
Tick++;
}
}
FileClose(Handle);
NewsCount = Tick;
for (int i = 0; i < NewsCount; i++)
{
if (Times[i] > TimeCurrent()) NewsPassed[i] = false;
Si no, NewsPassed[i] = false;
}
PrintFormat("Número de noticias cargadas - %i.", NewsCount);
return(true);
}
PrintFormat("No se puede abrir el archivo %s. Código de error %d", NewsFilename, GetLastError());
return(false);
}
//====================================================================================================
void SetupOrders(string Sym)
{
int Ticket, Dig, Count;
doble Precio, TP, SL, Lote;
datetime KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter1) * 60;
cadena SymList[7];
//-------------------------------------------------------------------------------------------------
if (Sym == "AUD")
{
SymList[0] = "AUDCAD"; SymList[1] = "AUDCHF"; SymList[2] = "AUDJPY"; SymList[3] = "AUDNZD";
SymList[4] = "AUDUSD"; SymList[5] = "EURAUD"; SymList[6] = "GBPAUD";
}
//-------------------------------------------------------------------------------------------------
si (Sym == "CAD")
{
SymList[0] = "AUDCAD"; SymList[1] = "CADCHF"; SymList[2] = "CADJPY"; SymList[3] = "EURCAD";
SymList[4] = "GBPCAD"; SymList[5] = "NZDCAD"; SymList[6] = "USDCAD";
}
//-------------------------------------------------------------------------------------------------
si (Sym == "CHF")
{
SymList[0] = "AUDCHF"; SymList[1] = "CADCHF"; SymList[2] = "EURCHF"; SymList[3] = "GBPCHF";
SymList[4] = "CHFJPY"; SymList[5] = "NZDCHF"; SymList[6] = "USDCHF";
}
//-------------------------------------------------------------------------------------------------
si (Sym == "EUR")
{
SymList[0] = "EURAUD"; SymList[1] = "EURCAD"; SymList[2] = "EURCHF"; SymList[3] = "EURGBP";
SymList[4] = "EURJPY"; SymList[5] = "EURNZD"; SymList[6] = "EURUSD";
}
//-------------------------------------------------------------------------------------------------
si (Sym == "GBP")
{
SymList[0] = "EURGBP"; SymList[1] = "GBPAUD"; SymList[2] = "GBPCAD"; SymList[3] = "GBPCHF";
SymList[4] = "GBPJPY"; SymList[5] = "GBPNZD"; SymList[6] = "GBPUSD";
}
//-------------------------------------------------------------------------------------------------
si (Sym == "JPY")
{
SymList[0] = "AUDJPY"; SymList[1] = "CADJPY"; SymList[2] = "CHFJPY"; SymList[3] = "EURJPY";
SymList[4] = "GBPJPY"; SymList[5] = "NZDJPY"; SymList[6] = "USDJPY";
}
//-------------------------------------------------------------------------------------------------
si (Sym == "NZD")
{
SymList[0] = "AUDNZD"; SymList[1] = "EURNZD"; SymList[2] = "GBPNZD"; SymList[3] = "NZDCAD";
SymList[4] = "NZDCHF"; SymList[5] = "NZDJPY"; SymList[6] = "NZDUSD";
}
//-------------------------------------------------------------------------------------------------
si (Sym == "USD")
{
SymList[0] = "AUSUSD"; SymList[1] = "EURUSD"; SymList[2] = "GBPUSD"; SymList[3] = "NZDUSD";
SymList[4] = "USDCAD"; SymList[5] = "USDCHF"; SymList[6] = "USDJPY";
}
//-------------------------------------------------------------------------------------------------
for (int i = 0; i < 7; i++)
{
Cuenta = 0;
Dig = int(MarketInfo(SymList[i], MODE_DIGITS));
Lote = NormalizarDoble(0,01, 2);
//Comprar
KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter1) * 60;
Precio = NormalizeDouble(MarketInfo(SymList[i], MODE_ASK) + PriceIndent1 / pow(10, Dig-1), Dig);
TP = NormalizeDouble(Precio + TakeProfit1 / pow(10, Dig-1), Dig);
SL = NormalizeDouble(Precio - StopLoss / pow(10, Dig-1), Dig);
Ticket = OrderSend(SymList[i], OP_BUYSTOP, Lot, Price, 5, SL, TP, NULL, 0, KeepAlive, clrLimeGreen);
if (Ticket > 0) Count++; else PrintFormat("Error al crear la orden %i, símbolo %s, precio %f, Take %f, Stop %f, Lote %f.", GetLastError(), SymList[i], Price, TP, SL, Lot);
KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter2) * 60;
Precio = NormalizeDouble(TP + PriceIndent2 / pow(10, Dig-1), Dig);
TP = NormalizeDouble(Precio + TakeProfit2 / pow(10, Dig-1), Dig);
SL = NormalizeDouble(Precio - StopLoss / pow(10, Dig-1), Dig);
Ticket = OrderSend(SymList[i], OP_BUYSTOP, Lot * Multiplier1, Price, 5, SL, TP, NULL, 0, KeepAlive, clrLimeGreen);
if (Ticket > 0) Count++; else PrintFormat("Error al crear la orden %i, símbolo %s, precio %f, Take %f, Stop %f, Lote %f.", GetLastError(), SymList[i], Price, TP, SL, Lot*Multiplier1);
KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter3) * 60;
Precio = NormalizeDouble(TP + PriceIndent2 / pow(10, Dig-1), Dig);
TP = NormalizeDouble(Precio + TakeProfit2 / pow(10, Dig-1), Dig);
SL = NormalizeDouble(Precio - StopLoss / pow(10, Dig-1), Dig);
Ticket = OrderSend(SymList[i], OP_BUYSTOP, Lot*Multiplier2, Price, 5, SL, TP, NULL, 0, KeepAlive, clrLimeGreen);
if (Ticket > 0) Count++; else PrintFormat("Error al crear la orden %i, símbolo %s, precio %f, toma %f, stop %f, lote %f.", GetLastError(), SymList[i], Price, TP, SL, Lot*Multiplier2);
// Venta
KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter1) * 60;
Precio = NormalizeDouble(MarketInfo(SymList[i], MODE_BID) - PriceIndent1 / pow(10, Dig-1), Dig);
TP = NormalizeDouble(Precio - TakeProfit1 / pow(10, Dig-1), Dig);
SL = NormalizeDouble(Precio + StopLoss / pow(10, Dig-1), Dig);
Ticket = OrderSend(SymList[i], OP_SELLSTOP, Lot, Price, 5, SL, TP, NULL, 0, KeepAlive, clrOrangeRed);
if (Ticket > 0) Count++; else PrintFormat("Error al crear la orden %i, símbolo %s, precio %f, Take %f, Stop %f, Lote %f.", GetLastError(), SymList[i], Price, TP, SL, Lot);
KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter2) * 60;
Precio = NormalizeDouble(TP - PriceIndent2 / pow(10, Dig-1), Dig);
TP = NormalizeDouble(Precio - TakeProfit2 / pow(10, Dig-1), Dig);
SL = NormalizeDouble(Precio + StopLoss / pow(10, Dig-1), Dig);
Ticket = OrderSend(SymList[i], OP_SELLSTOP, Lot, Price, 5, SL, TP, NULL, 0, KeepAlive, clrOrangeRed);
if (Ticket > 0) Count++; else PrintFormat("Error al crear la orden %i, símbolo %s, precio %f, Take %f, Stop %f, Lote %f.", GetLastError(), SymList[i], Price, TP, SL, Lot*Multiplier1);
KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter3) * 60;
Precio = NormalizeDouble(TP - PriceIndent2 / pow(10, Dig-1), Dig);
TP = NormalizeDouble(Precio - TakeProfit3 / pow(10, Dig-1), Dig);
SL = NormalizeDouble(Precio + StopLoss / pow(10, Dig-1), Dig);
Ticket = OrderSend(SymList[i], OP_SELLSTOP, Lot, Price, 5, SL, TP, NULL, 0, KeepAlive, clrOrangeRed);
PrintFormat("Hay %i órdenes colocadas por el símbolo %s", SymList[i], Count);0 }
}
El archivo de noticias tiene el siguiente aspecto:
15.09.2016 01:45 NZD 04:30 AUD 10:30 CHF 14:00 GBP 15:30 USD
16.09.2016 15:30 USD 17:00 USD
y así sucesivamente...
Volvamos a su código fuente. Pruébalo así:
int OnInit()
{
if (!GlobalVariableCheck("AllowNewOrders")) GlobalVariableSet("AllowNewOrders",1);
return(INIT_SUCCEED);
}
void OnDeInit()
{
GlobalVariableSet("AllowNewOrders",1);
}
void OnTick()
{
if (CountTrades() == 0) // El número de órdenes debe ser cero
{
if ((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) < PriceOpenLastHistOrder(OP_BUY))
|| (TypeLastHistOrder() == OP_SELL && PriceCloseLastHistOrder(OP_SELL) > PriceOpenLastHistOrder(OP_SELL))
// Si la última operación es perdedora, se abre la misma, pero con un lote mayor
{
GlobalVariableSet("AllowNewOrders", 0);
Tipo = TypeLastHistOrder();
if (Type == OP_BUY) Precio = Ask;
if (Type == OP_SELL) Precio = Oferta;
Lote = NormalizeDouble(LotsLastHistOrder()*Multiplier, 2);
ticket = OrderSend(Symbol(), Type, Lot, Price, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
if (PriceCloseLastHistOrder() == PriceOpenLastHistOrder() && CountHistTrades() > 0)
// si el beneficio de la última operación es igual a cero, se abrirá la misma operación
{
GlobalVariableSet("AllowNewOrders", 0);
Tipo = TypeLastHistOrder();
if (Type == OP_BUY) Precio = Ask;
if (Type == OP_SELL) Precio = Oferta;
Lot = NormalizeDouble(LotsLastHistOrder(), 2);
ticket = OrderSend(Symbol(), Type, Lot, Price, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
if (((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) > PriceOpenLastHistOrder(OP_BUY))
|| (TypeLastHistOrder() == OP_SELL && PriceCloseLastHistOrder(OP_SELL) < PriceOpenLastHistOrder(OP_SELL))
|| CountHistTrades() == 0)// Si la última operación es rentable, se abre la orden
{
if (GlobalVariableGet("AllowNewOrders") > 0)return;
if (SignalBuy() && MaxOpenOrders > OrdersTotal())
{
ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, Slippage, 0, 0, IntegerToString(Exp), Magic);
if (ticket>0) GlobalVariableSet("AllowNewOrders", 0);
}
if (SignalSell() && MaxOpenOrders > OrdersTotal())
{
ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage, 0, 0, IntegerToString(Exp), Magic);
if (ticket>0) GlobalVariableSet("AllowNewOrders", 0);
}
}
}
}
No lo he comprobado, porque no entiendo cómo varias copias de un EA con un límite total de 1 orden van a detectar en qué símbolo (después de una serie rentable) es mejor empezar a operar?
Alexander, el bot tiene que esperar el número especificado de velas en cada símbolo en una dirección y luego iniciar una serie, es decir, en qué símbolo se activa primero esta condición para ese símbolo y abrir la primera operación. Al mismo tiempo, debe prohibir la apertura de una serie para otros símbolos hasta que la primera serie termine con ganancias.
El último código que has dado es un paso adelante: no abre ningún trato en absoluto (es decir, la prohibición está activa). No he entendido por qué ninguno. Adjunto una captura de pantalla del registro.
Quizá sea el momento de aprender a insertar código.