Chiedete! - pagina 117

Nuovo commento
 

int start(){

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

...

return(0);

}

amatrader:
Per favore, qualcuno può dirmi se è possibile avere un limite di data in un EA, quello che voglio dire è che posso impostare una data di scadenza in un EA che una volta raggiunta la data impostata smetta di fare trading.

Probabilmente direbbe qualcosa del genere:-

controlla la data, se la data è uguale o maggiore di (data impostata) non fare nulla.

Questa è la versione inglese, ho bisogno della versione MQL4...lol

Grazie se qualcuno può aiutarmi.
 
amatrader:
Per favore, qualcuno può dirmi se è possibile avere un limite di data in un EA, quello che voglio dire è che posso impostare una data di scadenza in un EA che una volta raggiunta la data impostata smette di fare trading.

Probabilmente direbbe qualcosa del genere:-

controlla la data, se la data è uguale o maggiore di (data impostata) non fare nulla.

Questa è la versione inglese, ho bisogno della versione MQL4...lol

Grazie se qualcuno può aiutarmi.

Guarda questo thread https://www.mql5.com/en/forum/174194

 

Grazie signore... Molto apprezzato.

 

Weekly High Low.

Qualcuno può postare un indicatore settimanale High Low come quello allegato per il giornaliero?

O magari cambiare l'allegato in un settimanale per me, per favore.

Grazie in anticipo.

File:
daily_high_low_.mq4  4 kb
 

Usa questo indicatore https://www.mql5.com/en/forum/173574/page32 (è giornaliero, settimanale e mensile).

O questo https://www.mql5.com/en/forum/177792

O questo https://www.mql5.com/en/forum/178698

 

Ciao a tutti

Ecco l'ea che sto usando. Qualcuno può per favore dirmi cosa cambiare per avere un BUY-STOP e un SELL_Stop presi allo stesso tempo. Nel modo in cui è ora, o viene attivato un buy-stop o un sell-stop. Vorrei averli entrambi. In secondo luogo, cosa devo fare per limitare il numero di ordini per ogni candela.

Vi ringrazio tutti in anticipo.

Ecco il codice:

void start() {

//---- controlla la storia e il trading

if(Bars<100 || IsTradeAllowed()==false) return;

co=CalculateCurrentOrders(Symbol());

CheckForSignals();

if (co>0) CheckForClose();

CheckForOpen();

co=CalculateCurrentOrders(Symbol());

se (mkt>0) {

BreakEvenStop(BreakEven,0);

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

Stampa("Patrimonio del conto = ",Patrimonio del conto());

Stampa("Saldo del conto = ",Saldo del conto());

se(pcnt>EquityGainPercent)

{

int totale = OrdiniTotali();

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

{

OrderSelect(i, SELECT_BY_POS);

int type = OrderType();

bool result = false;

switch(tipo)

{

//Chiude le posizioni lunghe aperte

caso OP_BUY : result = OrderClose( OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_BID), 5, Red );

pausa;

//Chiude le posizioni corte aperte

caso OP_SELL : risultato = OrderClose( OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_ASK), 5, Rosso );

break;

//Chiude gli ordini in sospeso

caso OP_BUYLIMIT :

caso OP_BUYSTOP :

caso OP_SELLLIMIT :

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

}

if(result == false)

{

Alert("Ordine " , OrderTicket() , " non è riuscito a chiudere. Errore:" , GetLastError() );

Sleep(3000);

}

}

Print("ALL ORDERS CLOSE-->Locked in on Profits");

}

return(0);

}

}

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

//| Calcola le posizioni aperte

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

int CalcolaOrdiniCorrenti(simbolo stringa)

{

int ord; mkt=0;

//----

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

if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) continua;

if(OrderSymbol()==simbolo && OrderMagicNumber()==Numero magico) {

ord++;

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

}

}

//---- restituire il volume degli ordini

return(ord);

}

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

//| Controlla le condizioni degli ordini aperti |

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

void CheckForSignals() {

//controlla i segnali long, short, exit

buysig=false;

sellsig=false;

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);

se (TwoBarReversal) is2brev=IsTwoBarReversal(shift);

/condizione del segnale di entrata lunga

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

buysig=true;

closesell=true;

}

//segnale di entrata short

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

buysig=false;

sellsig=true;

closebuy=true;

}

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

remorder=true;

}

}

void CheckForOpen() {

int res,tr;

//---- condizioni di vendita

co=CalculateCurrentOrders(Symbol());

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

co=CalcolaOrdiniCorrenti(Simbolo());

se (co==0) {

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

}

lastsig=-1;

last=Time[0];

ritorno;

}

//---- condizioni di acquisto

if(buysig && lastsig!=1) {

co=CalculateCurrentOrders(Symbol());

if (co==0) {

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

}

last=Time[0];

lastsig=1;

ritorno;

}

}

void BreakEvenStop(int BES, int BELP) {

//muovi lo stoploss per bloccare un po' di profitto

bool bres;

doppio StopLoss;

se ( BES > 2 ) {

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

if ( OrderSelect (i, SELECT_BY_POS) == false ) continua;

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

if ( OrderType() == OP_BUY ) {

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

StopLoss = OrderOpenPrice()+BELP*Point;

se ( StopLoss > OrderStopLoss() ) {

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

if (!bres) Print("Errore nella modifica dell'ordine BUY : ",ErrorDescription(GetLastError());

}

}

if ( OrderType() == OP_SELL ) {

if ( Ask > OrderOpenPrice()-BES*Point ) continua;

StopLoss = OrderOpenPrice()-BELP*Point;

se ( StopLoss < OrderStopLoss() ) {

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

if (!bres) Print("Errore nella modifica dell'ordine SELL: ",ErrorDescription(GetLastError());

}

}

}

}

return;

}

int IsKeyReversalBar(int shift) {

//Key Reversal Bar, L'apertura della barra chiave dovrebbe essere almeno ?pips più alta del massimo della barra precedente.

//La chiusura della barra chiave dovrebbe essere con tra l'alto e la chiusura della barra precedente. L'apertura della barra corrente deve essere

//inferiore alla chiusura della barra chiave. Un ordine SellStop deve essere piazzato sul minimo della barra chiave se non viene eseguito entro

//le prossime 4 barre, allora cancella l'ordine. Vedi l'immagine qui sotto - short!

if (Open[shift]=Low[shift+1] && Close[shift]Close[shift]) return(1);

se (Open[shift]>Alto[shift+1] && Close[shift]=Chiusura[shift+1] && Open[shift-1]<Chiusura[shift]) return(-1);

return(0);

}

int IsTwoBarReversal(int shift) {

//L'apertura della prima barra dovrebbe essere vicina al minimo della barra precedente e la chiusura dovrebbe essere molto più bassa e

/avere un corpo di buone dimensioni. L'apertura della seconda barra dovrebbe essere molto vicina alla chiusura della prima barra ma entrambe dovrebbero essere ben al di sotto

//il punto medio di ogni barra con la chiusura molto vicina al minimo della 2 barra precedente. Un ordine BuyStop dovrebbe essere piazzato al massimo di

//la barra 1 se non viene eseguito entro 4 barre cancella l'ordine. Vedere l'immagine qui sotto

se (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 &&

Open[shift]<(High[shift]+Low[shift])/2)

return(1);

se (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 &&

Open[shift]>(High[shift]+Low[shift])/2)

return(-1);

return(0);

}

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

int res,tr,col;

stringa posta;

double openprice,sl,tp,stlev;

tries=0;

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

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

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

RefreshRates();

se (mode==OP_SELLSTOP) {

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

altrimenti openprice=Bid-stlev;

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

se (TP>0) tp=openprice-TP*Point;

col=Rosso;

} else

se (mode==OP_BUYSTOP) {

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

altrimenti openprice=Ask+stlev;

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

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

col=Blu;

} 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);

prova++;

}

if (res<=0) Print("Errore nell'apertura dell'ordine pendente: ",ErrorDescription(GetLastError());

return(res);

}

void CheckForClose() {

bool bres; int tr;

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

if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) continua;

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

//---- controllare il tipo di ordine

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

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

continua;

}

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

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

continua;

}

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

bres=DeletePending(OrderTicket());

continua;

}

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

bres=DeletePending(OrderTicket());

continua;

}

}

}

bool DeletePending(int ticket) {

bool bres=false; int tr;

tries=0;

while (!bres && tries<OrderTriesNumber) {

bres=OrderDelete(ticket);

tries++;

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

}

if (!bres) Print("Errore nella cancellazione dell'ordine: ",ErrorDescription(GetLastError());

return (bres);

}

 

Qualcuno conosce il codice per far funzionare un EA solo con un certo numero di conto? Grazie!

 

È qui https://www.mql5.com/en/forum/174194 (post #7)

 

Ne hai avute troppe questa volta

}
 
newdigital:
È qui https://www.mql5.com/en/forum/174194 (post #7)

Grazie newdigital.

Ho il mio codice di inizializzazione (che ha una scadenza temporale) impostato così:

int init()

{if (TimeCurrent()>D'2008.06.07 12:00:00'){Comment("rinnova il tuo abbonamento"); return(0);}

return(0);

}

}

if (Account != AccountNumber()){

Comment("Scambio sul conto : "+NumeroConto()+" VIETATO!");

return(0);

}else {Commento("");}

E ora sto restituendo questo errore:

'}' - parentesi sbilanciate

Cosa sto facendo di sbagliato qui? Inoltre, "int Account = 111111;" va con l'impostazione dell'EA? Grazie.

1...110111112113114115116117118119120121122123124...182
Nuovo commento