Pergunte! - página 117

Novo comentário
 

int start(){

if(TimeCurrent()>D'2008.07.01 12:00:00'){Comentário("EXPIRED"); return(0);}

...

return(0);

}

amatrader:
Por favor, alguns podem me dizer se é possível ter um limite de data em uma EA, o que eu quero dizer é que posso estabelecer uma data de expiração em uma EA que, uma vez atingida a data estabelecida, ela simplesmente pára de negociar.

Provavelmente diria algo como isto: -

verificar data, se a data é igual ou superior a (marcar data) não fazer nada.

Essa é a versão inglesa, eu preciso da versão MQL4...lol

Obrigado, se alguém puder ajudar.
 
amatrader:
Por favor, alguns podem me dizer se é possível ter uma data limite em uma EA, o que eu quero dizer é que posso estabelecer uma data de expiração em uma EA que, uma vez atingida a data estabelecida, ela simplesmente pára de negociar.

Provavelmente diria algo como isto: -

verificar data, se a data é igual ou superior a (marcar data) não fazer nada.

Essa é a versão inglesa, eu preciso da versão MQL4...lol

Obrigado, se alguém puder ajudar.

Veja esta linha https://www.mql5.com/en/forum/174194

 

Obrigado, senhor... Muito apreciado.

 

Mínimo semanal.

Qualquer pessoa pode postar um indicador semanal de Máxima Baixa como o anexo para o diário?

Ou talvez mudar o anexo para um semanal, por favor.

Obrigado antecipadamente.

Arquivos anexados:
daily_high_low_.mq4  4 kb
 

Utilize este indicador https://www.mql5.com/en/forum/173574/page32 (é diário, semanal e mensal).

Ou este aqui https://www.mql5.com/en/forum/177792

Ou este https://www.mql5.com/en/forum/178698

 

Olá a todos

Aqui está a eua que estou usando. Alguém pode me dizer o que mudar para que uma BUY-STOP e uma SELL_Stop sejam tomadas ao mesmo tempo. Do jeito que está agora, ou uma parada de compra ou uma parada de venda é acionada. eu gostaria de ter ambas. Em segundo lugar, o que devo fazer para limitar o número de pedidos para cada vela.

Agradeço antecipadamente a todos vocês.

aqui está o código:

início vazio() {

//---- verificação de histórico e comércio

if(Bars<100 || IsTradeAllowed()==falso) retorna;

co=CalculateCurrentOrders(Symbol());

CheckForSignals();

if (co>0); CheckForClose();

CheckForOpen();

co=CalculateCurrentOrders(Symbol());

if (mkt>0) {

BreakEvenStop(BreakEven,0);

double pcnt =( (AccountEquity()-AccountBalance()) / AccountBalance())*100;

Print("Account equity = ",AccountEquity()));

Print("Account balance = ",AccountBalance()); Print("Account Balance = ",AccountBalance());

if(pcnt>EquityGainPercent)

{

int total = EncomendasTotal();

for(int i=total-1;i>=0;i--)

{

OrderSelect(i, SELECT_BY_POS);

tipo int = OrderType();

bool resultado = falso;

switch(tipo)

{

//fechar posições longas abertas

caso OP_BUY : resultado = OrderClose( OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_BID), 5, Vermelho );

intervalo;

//Close posições curtas abertas

caso OP_SELL : resultado = OrderClose( OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_ASK), 5, Vermelho );

intervalo;

//fechar ordens pendentes

caso OP_BUYLIMIT :

caso OP_BUYSTOP :

caso OP_SELLLIMIT :

caso OP_SELLSTOP : resultado = OrderDelete( OrderTicket() );

}

if(resultado == falso)

{

Alerta("Order " , OrderTicket() , " não conseguiu fechar. Erro:"". , GetLastError() );

Sleep(3000);

}

}

Imprimir ("TODAS AS PEDIDAS FECHADAS-->Lock in on Lucits");

}

retorno(0);

}

}

//+------------------------------------------------------------------+

//| Calcular posições abertas |

//+------------------------------------------------------------------+

int CalculateCurrentOrders(símbolo de corda)

{

int ord; mkt=0;

//----

for(int i=0;i<OrdersTotal();i++) {

if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==falso) continue;

if(OrderSymbol()==símbolo && OrderMagicNumber()==MagicNumber) {

ord++;

if (OrderType()==OP_BUY || OrderType()==OP_SELL) mkt++;

}

}

//---- volume de pedidos de devolução

retorno(ord);

}

//+------------------------------------------------------------------+

//| Verifique as condições de pedidos em aberto |

//+------------------------------------------------------------------+

verificação de sinais nulos() {

//cheque sinais longos, curtos, de saída

buyysig=false;

vendeig=falso;

closebuy=false;

closesell=false;

remorder=false;

int isins,isouts,iskeyrev,is2brev;

if (InsideBar) isins=IsInsideBar(shift);

if (OutSideBar) isouts=IsOutSideBar(shift);

if (KeyReversalBar) iskeyrev=IsKeyReversalBar(shift);

if (TwoBarReversal) is2brev=IsTwoBarReversal(shift);

//longa condição do sinal de entrada

if (isins>0 || isouts>0 || iskeyrev>0 || is2brev>0) {

buyysig=true;

closesell=true;

}

//curto sinal de entrada

se (isins<0 || isouts<0 || iskeyrev<0 || is2brev<0) {

buyysig=false;

vendeig=verdadeiro;

closebuy=true;

}

if (last>0 && (Time[0]-last)/(Period()*60)>=CancelOrderBars) {

remorder=true;

}

}

CheckForOpen() {

int res,tr;

//---- condições de venda

co=CalculateCurrentOrders(Symbol());

if(sellig && lastsig!=-1) {

co=CalculateCurrentOrders(Symbol());

se (co==0) {

res = OpenStop(OP_SELLSTOP,LotsRisk(StopLoss), Low[shift]-OrderPipsDiff*Point, StopLoss, TakeProfit1);

}

lastsig=-1;

last=Time[0];

retornar;

}

//---- condições de compra

if(compra && dura!=1) {

co=CalculateCurrentOrders(Symbol());

se (co==0) {

res = OpenStop(OP_BUYSTOP,LotsRisk(StopLoss), High[shift]+OrderPipsDiff*Point, StopLoss, TakeProfit1);

}

last=Time[0];

lastsig=1;

retorno;

}

}

void BreakEvenStop(int BES, int BELP) {

//levar o stoploss para obter algum lucro

bres;

StopLoss duplo;

se ( BES > 2 ) {

para (int i = 0; i < OrderTotal(); i++) {

se ( OrderSelect (i, SELECT_BY_POS) == falso ) continuar;

se ( OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber ) continuar;

if ( OrderType() == OP_BUY ) {

se ( Bid < OrderOpenPrice()+BES*Point ) continuar;

StopLoss = OrderOpenPrice()+BELP*Point;

se ( StopLoss > OrderStopLoss() ) {

bres=OrderModify (OrderTicket(), OrderOpenPrice(), StopLoss, OrderTakeProfit(), 0, White);

if (!bres) Print("Error Modifying BUY order : "ErrorDescription(GetLastError()));

}

}

se ( OrderType() == OP_SELL ) {

se ( Pergunte > OrderOpenPrice()-BES*Point ) continuar;

StopLoss = OrderOpenPrice()-BELP*Point;

se ( StopLoss < OrderStopLoss() ) {

bres=OrderModify (OrderTicket(), OrderOpenPrice(), StopLoss, OrderTakeProfit(), 0, Gold);

if (!bres) Print("Error Modifying SELL order : "ErrorDescription(GetLastError()));

}

}

}

}

retornar;

}

int IsKeyReversalBar(int shift) {

// Barra de inversão de chave, A abertura da barra de chave deve ser pelo menos ?pips mais alta do que a alta da barra anterior.

// O fechamento da barra de chaves deve ser com na parte alta e fechada da barra anterior. A abertura da barra atual deve ser

//mais baixo do que o fechamento da barra de chaves. Uma ordem SellStop deve ser colocada na parte inferior da barra de chaves se não for executada dentro

// as próximas 4 barras, em seguida, cancelar o pedido. Veja a foto abaixo - breve!

se (Abrir[turno]=Baixo[turno+1] && Fechar[turno]Fechar[turno]) retornar(1);

if (Abrir[shift]>Alto[shift+1] && Fechar[shift]=Fechar[shift+1] && Abrir[shift-1]<Fechar[shift]) retorno(-1);

return(0);

}

int IsTwoBarReversal(int shift) {

//Two Bar Reversal, A abertura da primeira barra deve ser próxima da barra anterior e o fechamento deve ser muito mais baixo e

// têm um corpo de bom tamanho. A abertura da segunda barra deve ser muito próxima ao fechamento da primeira barra, mas ambas devem estar bem abaixo

// o ponto médio de cada barra com a proximidade de estar muito perto das 2 barras anteriores. Uma ordem BuyStop deve ser colocada no ponto mais alto de

// a barra 1 se não for executada dentro de 4 barras, cancelar a ordem. Veja a figura abaixo

if (MathAbs(Open[shift+1]-Close[shift+1])> MathAbs(Open[shift+1]-Low[shift+2])<=

MathAbs(Close[shift]-Low[shift+2])<=

MathAbs(Open[shift]-Close[shift+1]) &&

Close[shift+1]<(High[shift+1]+Low[shift+1])/2 &&

Aberto[turno]<(Alto[turno]+Baixo[turno])/2)

retorno(1);

if (MathAbs(Open[shift+1]-Close[shift+1])> MathAbs(Open[shift+1]-High[shift+2])<=

MathAbs(Close[shift]-Low[shift+2])<=

MathAbs(Open[shift]-Close[shift+1]) &&

Close[shift+1]>(High[shift+1]+Low[shift+1])/2 &&

Aberto[turno]>(Alto[turno]+Baixo[turno])/2)

retorno(-1);

retorno(0);

}

int OpenStop(int mode,double lot, double prc, int SL, int TP) {

int res,tr,col;

correio em cadeia;

duplo preço aberto,sl,tp,stlev;

try=0;

stlev=(1+MarketInfo(Symbol(),MODE_STOPLEVEL))*Ponto;

while (res<=0 && tries<OrderTriesNumber) {

tr=0; enquanto (tr<5 && !IsTradeAllowed()) { tr++; Sleep(2000); }

RefreshRates();

if (mode==OP_SELLSTOP) {

se (prc<=Bid-stlev) openprice=prc;

caso contrário, openprice=Bid-stlev;

if (SL>0) sl=openprice+SL*Point;

if (TP>0) tp=open priceTP*Point;

col=Red;

} else

if (mode===OP_BUYSTOP) {

se (prc>=Ask+stlev) openprice=prc;

caso contrário, openprice=Ask+stlev;

if (SL>0) sl=openprice-SL*Point;

if (TP>0) tp=openprice+TP*Point;

col=azul;

} else return;

Print(Ask," ",Bid," ",Symbol()," ",mode," ",lot," ",openprice," ",sl," ",tp," ");

res=OrderSend(Symbol(),mode,lot,openprice,slippage,sl,tp,EAName+"_"+MagicNumber,MagicNumber,0,col);

try++;

}

se (res<=0) Imprimir("Erro abrindo ordem pendente : "Descrição do Erro(GetLastError()));

return(res);

}

cheque vazioFechar() {

bres; int tr;

for(int i=0;i<OrdersTotal();i++) {

if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==falso) continue;

if(OrderMagicNumber()!=MagicNumber || OrderSymbol()!=Symbol()) continua;

//---- verificar tipo de pedido

if(OrderType()==OP_BUY && closebuy) {

bres=CloseAtMarket(OrderTicket(),OrderLots());

continuar;

}

if(OrderType()==OP_SELL && closesell) {

bres=CloseAtMarket(OrderTicket(),OrderLots());

continuar;

}

if(OrderType()==OP_BUYSTOP && (closebuy ||| remorder)) {

bres=DeletePending(OrderTicket()));

continuar;

}

if(OrderType()==OP_SELLSTOP && (closesell || remorder)) {

bres=DeletePending(OrderTicket()));

continuar;

}

}

}

bool DeletePending(int ticket) {

bool bres=falso; int tr;

try=0;

enquanto (!bres && tries<OrderTriesNumber) {

bres=OrderDelete(bilhete);

try++;

tr=0; while (tr<5 && !IsTradeAllowed()) { tr++; Sleep(2000); }

}

se (!bres) Imprimir ("Erro ao eliminar ordem : "Descrição do Erro(GetLastError()));

retornar (!bres);

}

 

Alguém sabe o código para fazer um EA funcionar apenas com um determinado número de conta? Obrigado!

 

Está aqui https://www.mql5.com/en/forum/174194 (post #7)

 

Você tem muitos este

}
 
newdigital:
Está aqui https://www.mql5.com/en/forum/174194 (post #7)

Obrigado newdigital.

Tenho meu código de inicialização (que tem uma expiração de tempo) configurado como tal:

int init()

{se (TimeCurrent()>D'2008.06.07 12:00:00'){Comentário("favor renovar sua assinatura"); return(0);}

return(0);

}

}

se (Account != AccountNumber()){

Comentário("Comércio por conta : "+ContaNúmero()+" PROIBIDO!");

retorno(0);

}else {Comentário("");}

E agora estou devolvendo este erro:

'}' - Parênteses desequilibrados

O que eu estou fazendo de errado aqui? Além disso, "int Account = 111111;" vai com a configuração da EA? Obrigado.

1...110111112113114115116117118119120121122123124...182
Novo comentário
Razão: