Qualquer pergunta de novato, de modo a não desorganizar o fórum. Profissionais, não passem por aqui. Em nenhum lugar sem você - 6. - página 1095
Você está perdendo oportunidades de negociação:
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Registro
Login
Você concorda com a política do site e com os termos de uso
Se você não tem uma conta, por favor registre-se
Este código está escrito em MQL5?
para (int i=0; i<SymbolCount; i++)
{
se (CountTrades() == 0) // O número de pedidos deve ser zero
{
if (((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) < PriceOpenLastHistOrder(OP_BUY)) |||
(TypeLastHistOrder() == OP_SELLL && PriceCloseLastHistOrder(OP_SELLL) > PriceOpenLastHistOrder(OP_SELLL))&& MaxOpenOrders > OrderTotal())
// Se o último comércio estiver perdendo, o mesmo comércio será aberto, mas com um lote maior
{
Tipo = TypeLastHistOrder();
se (Tipo == OP_BUY) Preço = LastAsk;
se (Tipo == OP_SELL) Preço = LastBid;
Lote = NormalizeDuplo(LotsLastHistOrder()*Multiplier, 2);
bilhete = OrderSend(Symbols[i], Type, Lot, Price, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
if (PriceCloseLastHistOrder() == PriceOpenLastHistOrder() && CountHistTrades() > 0 && MaxOpenOrders > OrderTotal())
// se o lucro do último comércio for igual a zero, o mesmo comércio será aberto
{
Tipo = TypeLastHistOrder();
se (Tipo == OP_BUY) Preço = LastAsk;
se (Tipo == OP_SELL) Preço = LastBid;
Lote = NormalizeDuplo(LotsLastHistOrder(), 2);
bilhete = OrderSend(Symbols[i], Type, Lot, Price, Slippage, 0, 0, IntegerToString(Exp), Magic)
}
if (((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) > PriceOpenLastHistOrder(OP_BUY))
|| (TypeLastHistOrder() == OP_SELLL && PriceCloseLastHistOrder(OP_SELLL) < PriceOpenLastHistOrder(OP_SELLL))
|| CountHistTrades() == 0)// Se a última negociação for lucrativa, a ordem é aberta
{
if (SignalBuy(Symbols[i]) && MaxOpenOrders > OrderTotal())
{
bilhete = OrderSend(Symbols[i], OP_BUY, Lots, Ask, Slippage, 0, 0, IntegerToString(Exp), Magic)
}
if (SignalSell(Symbols[i]) && MaxOpenOrders > OrderTotal())
{
bilhete = OrderSend(Symbols[i], OP_SELL, Lots, Bid, Slippage, 0, 0, IntegerToString(Exp), Magic)
}
}
}
}
Código em OnTick depois das palavras e assim por diante. Escrito em MQL4, você precisa da MQL5?
Para cada OrderSend, a condição MaxOpenOrders não deve ser maior do que OrderTotal().
Código de procedimento (removido OrderSymbol()==Symbol() e inserido iClose()/iOpen() em vez de Close/Open(), eu não verifiquei a correção do código:
//+------------------------------------------------------------------+
int CountTrades(int tipo = -1)
{
int cnt = 0;
para (int i=OrdensTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
if (OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
cnt++;
}
}
retorno(cnt);
}
//+------------------------------------------------------------------+
int CountHistTrades(int tipo = -1)
{
int cnt = 0;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
if (OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
cnt++;
}
}
retorno(cnt);
}
//+------------------------------------------------------------------+
bool SignalBuy(string Sym)
{
para (int i=1; i<=Wait; i++)
{
double C = iClose(Sym, PERÍODO_M5, i); // Especifique aqui o tempo necessário
duplo O = iOpen(Sym, PERIOD_M5, i);
se(C > O) retornar(falso);
}
if ((iBarShift(Sym, 0, TimeLastHistOrder()+Timeout) >= Espera ||| (Espera == 0 && TimeCurrent() >= TimeLastHistOrder()+Timeout))
&& CountHistTrades() > 0) retorno(true);
se (CountHistTrades() == 0) retornar(true);
retorno(falso);
}
//+------------------------------------------------------------------+
bool SignalSell(string Sym)
{
para (int i=1; i<=Wait; i++)
{
double C = iClose(Sym, PERÍODO_M5, i); // Especifique aqui o tempo necessário
duplo O = iOpen(Sym, PERIOD_M5, i);
se(C < O) retornar(falso);
}
if ((iBarShift(Sym, 0, TimeLastHistOrder()+Timeout) >= Espera ||| (Espera == 0 && TimeCurrent() >= TimeLastHistOrder()+Timeout))
&& CountHistTrades() > 0) retorno(true);
se (CountHistTrades() == 0) retornar(true);
retorno(falso);
}
//+------------------------------------------------------------------+
dataHoraHoraLastHistOrder(tipo int = -1)
{
data/hora da última vez = 0;
data/hora opentime = 0;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
if (OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
{
se (OrderCloseTime() > última vez)
{
lasttime = OrderCloseTime();
opentime = OrderOpenTime();
}
}
}
}
retorno(opentime);
}
//+------------------------------------------------------------------+
int TypeLastHistOrder()
{
data/hora = 0;
tipo int = -1;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
se (OrderMagicNumber() == Magic)
{
se (OrderCloseTime() > tempo)
{
tempo = OrderCloseTime();
tipo = OrderType();
}
}
}
}
retorno(tipo);
}
//+------------------------------------------------------------------+
double LotsLastHistOrder(tipo int = -1)
{
data/hora = 0;
lotes duplos = 0;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
if (OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
{
se (OrderOpenTime() > tempo)
{
tempo = OrderOpenTime();
tempo = OrderLots();
}
}
}
}
devolução(lotes);
}
//+------------------------------------------------------------------+
duplo PriceCloseLastHistOrder(int tipo = -1)
{
data/hora = 0;
preço duplo = 0;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
if (OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
{
se (OrderCloseTime() > tempo)
{
tempo = OrderCloseTime();
preço = OrderClosePrice();
}
}
}
}
retorno(preço);
}
//+------------------------------------------------------------------+
duplo PriceOpenLastHistOrder(int tipo = -1)
{
data/hora = 0;
preço duplo = 0;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
if (OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
{
se (OrderCloseTime() > tempo)
{
tempo = OrderCloseTime();
preço = OrderOpenPrice();
}
}
}
}
retorno(preço);
}
Exp = 1;
bilhete = OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage, 0, 0, IntegerToString(Exp), Magic);
Este código funciona para você? A data deve estar aqui, e maior do que a data atual em 10 minutos (ou seja, TimeCurrent() + 600 no mínimo).
para (int i=0; i<SymbolCount; i++)
{
se (CountTrades() == 0) // O número de pedidos deve ser zero
{
if (((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) < PriceOpenLastHistOrder(OP_BUY)) |||
(TypeLastHistOrder() == OP_SELLL && PriceCloseLastHistOrder(OP_SELLL) > PriceOpenLastHistOrder(OP_SELLL))&& MaxOpenOrders > OrderTotal())
// Se o último comércio estiver perdendo, o mesmo comércio será aberto, mas com um lote maior
{
Tipo = TypeLastHistOrder();
se (Tipo == OP_BUY) Preço = LastAsk;
se (Tipo == OP_SELL) Preço = LastBid;
Lote = NormalizeDuplo(LotsLastHistOrder()*Multiplier, 2);
bilhete = OrderSend(Symbols[i], Type, Lot, Price, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
if (PriceCloseLastHistOrder() == PriceOpenLastHistOrder() && CountHistTrades() > 0 && MaxOpenOrders > OrderTotal())
// se o lucro do último comércio for igual a zero, o mesmo comércio será aberto
{
Tipo = TypeLastHistOrder();
se (Tipo == OP_BUY) Preço = LastAsk;
se (Tipo == OP_SELL) Preço = LastBid;
Lote = NormalizeDuplo(LotsLastHistOrder(), 2);
bilhete = OrderSend(Symbols[i], Type, Lot, Price, Slippage, 0, 0, IntegerToString(Exp), Magic)
}
if (((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) > PriceOpenLastHistOrder(OP_BUY))
|| (TypeLastHistOrder() == OP_SELLL && PriceCloseLastHistOrder(OP_SELLL) < PriceOpenLastHistOrder(OP_SELLL))
|| CountHistTrades() == 0)// Se a última negociação for lucrativa, a ordem é aberta
{
if (SignalBuy(Symbols[i]) && MaxOpenOrders > OrderTotal())
{
bilhete = OrderSend(Symbols[i], OP_BUY, Lots, Ask, Slippage, 0, 0, IntegerToString(Exp), Magic)
}
if (SignalSell(Symbols[i]) && MaxOpenOrders > OrderTotal())
{
bilhete = OrderSend(Symbols[i], OP_SELL, Lots, Bid, Slippage, 0, 0, IntegerToString(Exp), Magic)
}
}
}
}
Código em OnTick depois das palavras e assim por diante. Escrito em MQL4, você precisa da MQL5?
Para cada OrderSend, a condição MaxOpenOrders não deve ser maior do que OrderTotal().
Código de procedimento (removido OrderSymbol()==Symbol() e inserido iClose()/iOpen() em vez de Close/Open(), eu não verifiquei a correção do código:
//+------------------------------------------------------------------+
int CountTrades(int tipo = -1)
{
int cnt = 0;
para (int i=OrdensTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
if (OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
cnt++;
}
}
retorno(cnt);
}
//+------------------------------------------------------------------+
int CountHistTrades(int tipo = -1)
{
int cnt = 0;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
if (OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
cnt++;
}
}
retorno(cnt);
}
//+------------------------------------------------------------------+
bool SignalBuy(string Sym)
{
para (int i=1; i<=Wait; i++)
{
double C = iClose(Sym, PERÍODO_M5, i); // Especifique aqui o tempo necessário
duplo O = iOpen(Sym, PERIOD_M5, i);
se(C > O) retornar(falso);
}
if ((iBarShift(Sym, 0, TimeLastHistOrder()+Timeout) >= Espera ||| (Espera == 0 && TimeCurrent() >= TimeLastHistOrder()+Timeout))
&& CountHistTrades() > 0) retorno(true);
se (CountHistTrades() == 0) retornar(true);
retorno(falso);
}
//+------------------------------------------------------------------+
bool SignalSell(string Sym)
{
para (int i=1; i<=Wait; i++)
{
double C = iClose(Sym, PERÍODO_M5, i); // Especifique aqui o tempo necessário
duplo O = iOpen(Sym, PERIOD_M5, i);
se(C < O) retornar(falso);
}
if ((iBarShift(Sym, 0, TimeLastHistOrder()+Timeout) >= Espera ||| (Espera == 0 && TimeCurrent() >= TimeLastHistOrder()+Timeout))
&& CountHistTrades() > 0) retorno(true);
se (CountHistTrades() == 0) retornar(true);
retorno(falso);
}
//+------------------------------------------------------------------+
dataHoraHoraLastHistOrder(tipo int = -1)
{
data/hora da última vez = 0;
data/hora opentime = 0;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
if (OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
{
se (OrderCloseTime() > última vez)
{
lasttime = OrderCloseTime();
opentime = OrderOpenTime();
}
}
}
}
retorno(opentime);
}
//+------------------------------------------------------------------+
int TypeLastHistOrder()
{
data/hora = 0;
tipo int = -1;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
se (OrderMagicNumber() == Magic)
{
se (OrderCloseTime() > tempo)
{
tempo = OrderCloseTime();
tipo = OrderType();
}
}
}
}
retorno(tipo);
}
//+------------------------------------------------------------------+
double LotsLastHistOrder(tipo int = -1)
{
data/hora = 0;
lotes duplos = 0;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
if (OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
{
se (OrderOpenTime() > tempo)
{
tempo = OrderOpenTime();
tempo = OrderLots();
}
}
}
}
devolução(lotes);
}
//+------------------------------------------------------------------+
duplo PriceCloseLastHistOrder(int tipo = -1)
{
data/hora = 0;
preço duplo = 0;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
if (OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
{
se (OrderCloseTime() > tempo)
{
tempo = OrderCloseTime();
preço = OrderClosePrice();
}
}
}
}
retorno(preço);
}
//+------------------------------------------------------------------+
duplo PriceOpenLastHistOrder(int tipo = -1)
{
data/hora = 0;
preço duplo = 0;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
if (OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
{
se (OrderCloseTime() > tempo)
{
tempo = OrderCloseTime();
preço = OrderOpenPrice();
}
}
}
}
retorno(preço);
}
Dá alguns erros, não conseguia consertá-los. O que há de errado aqui?
//+------------------------------------------------------------------+Pessoal, ajudem. Estou negociando na plataforma MT4 da Stforex. Quando abro um pedido, ele não me mostra o nível de entrada no gráfico (sem linha pontilhada) e, portanto, não é conveniente colocar um fim à perda. Talvez quem saiba o que está errado e como consertá-lo?
http://prntscr.com/chfa36
Configurações - Gráficos - Mostrar níveis de negociação
Rapazes, que função poderia retornar o erro 65 ?
http://prntscr.com/chfa36
Configurações - Gráficos - Mostrar níveis de negociação
Esta função foi originalmente ativada, mas os níveis ainda não aparecem no gráfico.
Comete um par de erros, não consegue acertar. O que há de errado aqui?
Você esqueceu de adicionar um parêntese final nas variáveis OnTick e LastAsk e LastBid. Aqui está o código que compila sem erros, ainda não verifiquei sua funcionalidade:
//+------------------------------------------------------------------+
//| BB1.mq4 |
//| Copyright 2016, MetaQuotes Software Corp. |
//| https://www.mql5.com |
//+------------------------------------------------------------------+
#direitos autorais "Copyright 2016, MetaQuotes Software Corp."
#link da propriedade "https://www.mql5.com"
#propriedade versão "1.00"
#propriedade rigorosa
Lotes duplos externos = 1; // Lotes
Expiração int externa = 1; // Expiração
externo int Espera = 2; // Número de castiçais de uma direção
Tempo esgotado externo int = 1; // Horário
duplo multiplicador externo = 3; // Multiplicador
Slippage externo int = 5; // Slippage
magia interna externa = 774274; // Magia
Exterior int MaxOpenOrders = 1; // Número máximo de pedidos
int ticket, Tipo, SymbolCount;
preço duplo, lote;
cadeia de entrada TradeSymbols = "EURUSD_OP, GBPUSD_OP, AUDUSD_OP, NZDUSD_OP, USDCAD_OP, USDCHF_OP, GBPCAD_OP, AUDNZD_OP, CHFJPY_OP, GBPCHF_OP"; // símbolos para negociação
Símbolos de corda[50]; // 50 é o número máximo possível de símbolos
//--------------------------------------------------
int OnInit()
{
se (IsTesting() || !ExtractSymbols())
{
SymbolCount = 1;
Símbolos[0] = Símbolo();
}
return(INIT_SUCCEED);
}
//--------------------------------------------------
Extrato de BoolSymbols()
{
ushort Comma = StringGetCharacter(",", 0);
SymbolCount = StringSplit(TradeSymbols, Comma, Symbols);
para (int i = 0; i < SymbolCount; i++)
{
StringToUpper(Símbolos[i]);
Symbols[i] = StringTrimRight(Símbolos[i]); // proteção contra espaços acidentais
Symbols[i] = StringTrimLeft(Símbolos[i]);
}
se (SymbolCount > 0) retornar(true);
retorno(falso);
}
//--------------------------------------------------
nulo OnTick()
{
para (int i=0; i<SymbolCount; i++)
{
duplo LastAsk = SymbolInfoDouble(Symbols[i], SYMBOL_ASK);
double LastBid = SymbolInfoDouble(Symbols[i], SYMBOL_BID);
se (CountTrades() == 0) // o número de pedidos deve ser igual a zero
{
if (((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) < PriceOpenLastHistOrder(OP_BUY)) |||
(TypeLastHistOrder() == OP_SELLL && PriceCloseLastHistOrder(OP_SELLL) > PriceOpenLastHistOrder(OP_SELLL)) && MaxOpenOrders > OrderTotal())
// Se o último comércio estiver perdendo, o mesmo comércio será aberto, mas com um lote maior
{
Tipo = TypeLastHistOrder();
se (Tipo == OP_BUY) Preço = LastAsk;
se (Tipo == OP_SELL) Preço = LastBid;
Lote = NormalizeDuplo(LotsLastHistOrder()*Multiplier, 2);
bilhete = OrderSend(Symbols[i], Type, Lot, Price, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
if (PriceCloseLastHistOrder() == PriceOpenLastHistOrder() && CountHistTrades() > 0 && MaxOpenOrders > OrderTotal())
// se o lucro do último comércio for igual a zero, o mesmo comércio será aberto
{
Tipo = TypeLastHistOrder();
se (Tipo == OP_BUY) Preço = LastAsk;
se (Tipo == OP_SELL) Preço = LastBid;
Lote = NormalizeDuplo(LotsLastHistOrder(), 2);
bilhete = OrderSend(Symbols[i], Type, Lot, Price, Slippage, 0, 0, IntegerToString(Exp), Magic)
}
if (((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) > PriceOpenLastHistOrder(OP_BUY))
|| (TypeLastHistOrder() == OP_SELLL && PriceCloseLastHistOrder(OP_SELLL) < PriceOpenLastHistOrder(OP_SELLL))
|| CountHistTrades() == 0)// Se a última negociação for lucrativa, a ordem é aberta
{
if (SignalBuy(Symbols[i]) && MaxOpenOrders > OrderTotal())
{
bilhete = OrderSend(Symbols[i], OP_BUY, Lots, Ask, Slippage, 0, 0, IntegerToString(Exp), Magic)
}
if (SignalSell(Symbols[i]) && MaxOpenOrders > OrderTotal())
{
ticket = OrderSend(Symbols[i], OP_SELL, Lots, Bid, Slippage, 0, 0, IntegerToString(Exp), Magic)
}
}
}
}
}
//+------------------------------------------------------------------+
int CountTrades(int tipo = -1)
{
int cnt = 0;
para (int i=OrdensTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
if (OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
cnt++;
}
}
retorno(cnt);
}
//+------------------------------------------------------------------+
int CountHistTrades(int tipo = -1)
{
int cnt = 0;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
if (OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
cnt++;
}
}
retorno(cnt);
}
//+------------------------------------------------------------------+
bool SignalBuy(string Sym)
{
para (int i=1; i<=Wait; i++)
{
double C = iClose(Sym, PERÍODO_M5, i); // Especifique aqui o tempo necessário
duplo O = iOpen(Sym, PERIOD_M5, i);
se (C > O) retornar(falso);
}
if ((iBarShift(Sym, 0, TimeLastHistOrder()+Timeout) >= Espera ||| (Espera == 0 && TimeCurrent() >= TimeLastHistOrder()+Timeout))
&& CountHistTrades() > 0) retorno(true);
se (CountHistTrades() == 0) retornar(true);
retorno(falso);
}
//+------------------------------------------------------------------+
bool SignalSell(string Sym)
{
para (int i=1; i<=Wait; i++)
{
double C = iClose(Sym, PERÍODO_M5, i); // Especifique aqui o tempo necessário
duplo O = iOpen(Sym, PERIOD_M5, i);
se (C < O) retornar(falso);
}
if ((iBarShift(Sym, 0, TimeLastHistOrder()+Timeout) >= Espera ||| (Espera == 0 && TimeCurrent() >= TimeLastHistOrder()+Timeout))
&& CountHistTrades() > 0) retorno(true);
se (CountHistTrades() == 0) retornar(true);
retorno(falso);
}
//+------------------------------------------------------------------+
dataHoraHoraLastHistOrder(tipo int = -1)
{
data/hora da última vez = 0;
data/hora opentime = 0;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
if (OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
{
se (OrderCloseTime() > última vez)
{
lasttime = OrderCloseTime();
opentime = OrderOpenTime();
}
}
}
}
retorno(opentime);
}
//+------------------------------------------------------------------+
int TypeLastHistOrder()
{
data/hora = 0;
tipo int = -1;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
se (OrderMagicNumber() == Magic)
{
se (OrderCloseTime() > tempo)
{
tempo = OrderCloseTime();
tipo = OrderType();
}
}
}
}
retorno(tipo);
}
//+------------------------------------------------------------------+
double LotsLastHistOrder(tipo int = -1)
{
data/hora = 0;
lotes duplos = 0;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
if (OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
{
se (OrderOpenTime() > tempo)
{
tempo = OrderOpenTime();
tempo = OrderLots();
}
}
}
}
devolução(lotes);
}
//+------------------------------------------------------------------+
duplo PriceCloseLastHistOrder(int tipo = -1)
{
data/hora = 0;
preço duplo = 0;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
if (OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
{
se (OrderCloseTime() > tempo)
{
tempo = OrderCloseTime();
preço = OrderClosePrice();
}
}
}
}
retorno(preço);
}
//+------------------------------------------------------------------+
duplo PriceOpenLastHistOrder(int tipo = -1)
{
data/hora = 0;
preço duplo = 0;
para (int i=OrdensHistóriaTotal()-1; i>=0; i--)
{
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
if (OrderMagicNumber() == Magic && (OrderType() == type ||| type == -1))
{
se (OrderCloseTime() > tempo)
{
tempo = OrderCloseTime();
preço = OrderOpenPrice();
}
}
}
}
retorno(preço);
}
Olá!
Como você pode determinar se uma posição foi fechada na TP? Não acho que OrderClosePrice()==OrderTakeProfit() seria correto de usar.