Qualsiasi domanda da principiante, per non ingombrare il forum. Professionisti, non passate oltre. Da nessuna parte senza di te - 6. - pagina 1100

Nuovo commento
 

Cari programmatori, potete per favore aiutarmi a impostare un divieto di aprire più di una serie di operazioni contemporaneamente (serie è se l'ordine viene chiuso in perdita o a zero e poi apre l'operazione successiva sullo stesso strumento, ma con un lotto più grande), cioè, se si apre una serie di operazioni la seconda e le successive vengono messe su altri strumenti sotto divieto (il bot lavora contemporaneamente su diversi strumenti). Penso che dovrebbe essere fatto attraverso una variabile globale nel terminale, ma non ho abbastanza conoscenza ed esperienza, ho appena iniziato a imparareMQL. Questo è un consulente di opzioni binarie. Ecco il codice

extern double Lots = 1; // Lots

extern int Exp = 1; // Scadenza

extern int Wait = 1; // Numero di candele di una direzione

extern int Timeout = 1; // intervallo di tempo

extern double Multiplier = 3; // Moltiplicatore

extern int Slippage = 5; // Slippage

extern int Magic = 2090; // Magic


biglietto int, Tipo;

doppio prezzo, lotto;

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

//| Funzione di inizializzazione dell'esperto |

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

int OnInit()

{

return(INIT_SUCCEED);

}

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

//| Funzione di deinizializzazione dell'esperto |

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

void OnDeinit(const int reason)

{

}

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

//| funzione tick esperto |

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

void OnTick()

{

// --------------- Aprire le transazioni ---------------

if (OrdersTotal() == 0) // Il numero di ordini deve essere uguale a zero

{

se ((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) < PriceOpenLastHistOrder(OP_BUY))

|| (TypeLastHistOrder() == OP_SELL && PriceCloseLastHistOrder(OP_SELL) > PriceOpenLastHistOrder(OP_SELL))

// Se l'ultimo trade è perdente, si apre lo stesso, ma con un lotto più grande

{

Type = TypeLastHistOrder();

if (Type == OP_BUY) Price = Ask;

if (Type == OP_SELL) Price = Bid;

Lot = NormalizeDouble(LotsLastHistOrder()*Multiplier, 2);

ticket = OrderSend(Symbol(), Type, Lot, Price, Slippage, 0, 0, IntegerToString(Exp), Magic);

}

se (PriceCloseLastHistOrder() == PriceOpenLastHistOrder() && CountHistTrades() > 0)

// se il profitto dell'ultimo trade è uguale a zero, lo stesso trade sarà aperto

{

Type = TypeLastHistOrder();

if (Type == OP_BUY) Price = Ask;

if (Type == OP_SELL) Price = Bid;

Lot = NormalizeDouble(LotsLastHistOrder(), 2);

ticket = OrderSend(Symbol(), Type, Lot, Price, Slippage, 0, 0, IntegerToString(Exp), Magic);

}

se (((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) > PriceOpenLastHistOrder(OP_BUY))

|| (TypeLastHistOrder() == OP_SELL && PriceCloseLastHistOrder(OP_SELL) < PriceOpenLastHistOrder(OP_SELL))

|| CountHistTrades() == 0)// Se l'ultimo trade è redditizio, l'ordine viene aperto

{

if (SignalBuy() && OrdersTotal() == 0)

{

ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, Slippage, 0, 0, IntegerToString(Exp), Magic);

}

if (SignalSell() && OrdersTotal() == 0)

{

ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage, 0, 0, IntegerToString(Exp), Magic);

Comment ("PriceCloseLastHistOrder(OP_BUY)= ", PriceCloseLastHistOrder(OP_BUY), "PriceCloseLastHistOrder(OP_SELL)=",

PriceCloseLastHistOrder(OP_SELL) );

}

}

}

}

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

int CountTrades(int type = -1) // Determina il numero di scambi

{

int cnt = 0;

for (int i=OrdersTotal()-1; i>=0; i--) // Il ciclo passa assolutamente attraverso tutti gli ordini aperti, i è il numero dell'ordine

{

if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) // La funzione controlla se l'ordine con il numero d'ordine i è nel mercato,

// se c'è, vengono controllate le seguenti condizioni...

{

if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && (OrderType() == type || type == -1)) // Se il simbolo

// il simbolo in cui l'ordine è aperto è uguale al simbolo corrente, il tipo di ordine è uguale a magico nelle impostazioni dell'EA corrente, e

// il tipo di ordine è uguale a type (o type == -1 (nel caso in cui non sia importante quale tipo è richiesto per il conteggio dell'ordine))

cnt++; // 1 viene aggiunto alla variabile cnt e alla fine del ciclo cnt sarà uguale al numero di accordi

// aperto dall'EA corrente per la coppia di valute corrente con un certo tipo

}

}

return(cnt); // viene restituito il valore della variabile cnt

}

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

int CountHistTrades(int type = -1)

{

int cnt = 0;

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

{

se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))

{

if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && (OrderType() == type || type == -1))

cnt++;

}

}

ritorno(cnt);

}

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

bool SignalBuy()

{

per (int i=1; i<=Attesa; i++)

{

se (Close[i] > Open[i]) return(false)

}

se ((iBarShift(Symbol(), 0, TimeLastHistOrder()+Timeout) >= Wait || (Wait == 0 && TimeCurrent() >= TimeLastHistOrder()+Timeout))

&& CountHistTrades() > 0) return(true);

se (CountHistTrades() == 0) return(true);

return(false);

}

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

bool SignalSell()

{

per (int i=1; i<=Attesa; i++)

{

se (Close[i] < Open[i]) return(false)

}

se ((iBarShift(Symbol(), 0, TimeLastHistOrder()+Timeout) >= Wait || (Wait == 0 && TimeCurrent() >= TimeLastHistOrder()+Timeout))

&& CountHistTrades() > 0) return(true);

se (CountHistTrades() == 0) return(true);

return(false);

}

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

datetime TimeLastHistOrder(int type = -1)

{

datetime lasttime = 0;

datetime opentime = 0;


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

{

se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))

{

if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && (OrderType() == type || type == -1))

{

se (OrderCloseTime() > lasttime)

{

lasttime = OrderCloseTime();

opentime = OrderOpenTime();

}

}

}

}

ritorno(opentime);

}

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

int TypeLastHistOrder()

{

datetime time = 0;

int type = -1;

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

{

se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))

{

if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic)

{

se (OrderCloseTime() > time)

{

time = OrderCloseTime();

tipo = OrderType();

}

}

}

}

ritorno(tipo);

}

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

double LotsLastHistOrder(int type = -1)

{

datetime time = 0;

doppio lotti = 0;

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

{

se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))

{

if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && (OrderType() == type || type == -1))

{

se (OrderOpenTime() > time)

{

time = OrderOpenTime();

tempo = OrderLots();

}

}

}

}

return(lots);

}

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

doppio PriceCloseLastHistOrder(int type = -1)

{

datetime time = 0;

doppio prezzo = 0;

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

{

se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))

{

if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && (OrderType() == type || type == -1))

{

se (OrderCloseTime() > time)

{

time = OrderCloseTime();

prezzo = OrderClosePrice();

}

}

}

}

}

}

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

doppio PriceOpenLastHistOrder(int type = -1)

{

datetime time = 0;

doppio prezzo = 0;

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

{

se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))

{

if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && (OrderType() == type || type == -1))

{

se (OrderCloseTime() > time)

{

time = OrderCloseTime();

prezzo = OrderOpenPrice();

}

}

}

}

}

}

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

 
Ciao, colleghi!

Houna domanda durante la programmazione: c'è un modo per ottenere il tempo del server preciso al millisecondo nell'EA?
Per esempio, ottenere: 23.09.2016 14h. : 53 min. 54000 millisecondi? Cioè esattamente 54 secondi, 000 millisecondi.
 
e-partner:
Ciao colleghi!

Houna domanda durante la programmazione: è possibile ottenere in qualche modo nell'Expert Advisor il tempo del server con una precisione di millisecondi?
Per esempio, ottenere: 23.09.2016 14h. : 53 min. 54000 millisecondi? Cioè esattamente 54 secondi, 000 millisecondi.

Domanda interessante. Cosa intendi per specificare l'ultimo tempo noto del server, il tempo dell'ultima citazione di TimeCurrent() o il tempo corrente sul server?

Se è TimeCurrent(), a cosa servirà, se consideriamo che un pacchetto con una nuova quotazione passa attraverso internet dal server al terminale per 10-500 ms e questo tempo varia da pacchetto a pacchetto. Inoltre, non è chiaro quale sia l'arrivo dell'ultima quotazione, se arriva al server da diverse fonti, fornitori di liquidità, e poi viene elaborata, e quindi il server invia un nuovo tick. Inoltre, non si sa come il timer di sistema del server sia sincronizzato con il tempo astronomico. Il 09.01.2014 dalle 04:15 alle 06:15 MSK (giovedì, giorno di trading) stavo scoprendo questo, come la deviazione non è da astronomico, ma dalla media per 31 aziende. La figura per 25 punti di tempo mostra queste deviazioni (in secondi, non in ms):

E che senso ha capire qualcosa in millisecondi dai dati del server?

La seconda opzione è più chiara. Se il tuo computer è sincronizzato con l'ora astronomica con una precisione che conosci, l'ora astronomica della città in cui il server è in funzione è conosciuta con la stessa precisione. Ma perché ne hai bisogno...

 

Non riesco a capire dove sia andata l'ottimizzazione del tester di strategia. I controlli sono tutti in piedi non riesco a capire nulla. MT4 build 1010. Windows 8.1.

Si prega di consigliare come abilitare l'ottimizzazione.

Allegherò degli screenshot. Non riesco a vedere il pulsante di ottimizzazione.

File:
desktop.zip  129 kb
 
Perché il mio MT4 b1010 non permette il debug sui dati storici (il pulsante e la voce di menu non sono attivi)? In MT5 tutto è ok.
 
Perché gli sviluppatori lo hanno proibito.
 
int Magik;
int Slippage = 5,stopL1 = 50,takeP1 = 20;
int tendenza,TicketS,TicketB;
doppio rsi,TP,SL;
//+------------------------------------------------------------------+
//| Funzione di inizializzazione dell'esperto |
//+------------------------------------------------------------------+
int OnInit()
{
if(Digits == 3 || Digits == 5)
{
Scivolamento *= 10;
stopL1 *= 10;
{ takeP1 *= 10;
}

return(INIT_SUCCEED);
}
//+------------------------------------------------------------------+
//| Funzione di deinizializzazione dell'esperto |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{

}
//+------------------------------------------------------------------+
//| funzione tick esperto |
//+------------------------------------------------------------------+
void OnTick()
{
double priseBuy = FindLastOrderPrise (OP_BUY);
double priseSel = FindLastOrderPrise (OP_SELL);
double frezeelevl = MarketInfo(OrderSymbol(),MODE_FREEZELEVEL);
rsi = iRSI(Symbol(),PERIOD_D1,7,PRICE_CLOSE,0);
tendenza = WhatTrend();
se (CountTrades() == 0)
{
if(trend == 1 && rsi <=30)
{
if(OrderSend(Symbol(),OP_BUYLIMIT,0.10,Ask,Slippage,0,0, "first buy order set",Magik,0)== true)
{
TicketB = FindLastTicket(OP_BUY);
se(TicketB >0)
{
SL = priseBuy + NormalizeDouble(takeP1 * Point,Digits);
TP = priseBuy - NormalizeDouble(stopL1 * Point,Digits);
se(OrderModify(TicketB,priseBuy,SL,TP,0)== true)
Commento("hooraaaahhhh");
}

}
}// if(trend == 1 && rsi <= 30)
else if(trend == 2 && rsi >= 70)
{
if(OrderSend(Symbol(),OP_SELLLIMIT,0.10,Bid,Slippage,0,0, "primo ordine impostato",Magik,0)== true)
{
for(int i = OrdiniTotali()-1;i >0;i--)
{
OrderSelect(i,SELECT_BY_TICKET,MODE_TRADES);
if (OrderType()== OP_SELL && OrderMagicNumber() == Magik)
{
double sl = OrderOpenPrice() + NormalizeDouble(stopL1 * Point,Digits);
double tp = OrderOpenPrice() - NormalizeDouble(takeP1 * Point,Digits);
if(OrderModify(OrderTicket(),OrderOpenPrice(),sl,tp,0)==true)break;
altrimenti continuare;
}
}
}
}
}// (CountTrades() == 0)

}

Chiedo ai programmatori competenti di spiegarmi qual è il mio errore! Perché l'ordine non viene modificato!!! e il compilatore non dà errori mentre lo fa

 
Ho studiato il tutorial, ho letto e preso appunti... potreste indicare gli errori nello specifico... perché il compilatore non dà errori e non ci sono errori nel tester, ma l'ordine non viene modificato, come se l'ordine non fosse affatto visibile nel programma
 
burbur87:
Ho studiato il tutorial, ho letto e preso appunti, potresti indicare gli errori nello specifico... perché il compilatore non dà nessun errore e non ci sono errori nel tester, ma l'ordine non è modificato, è come se l'ordine non si vedesse affatto nel programma

Leggete attentamente cosa restituisce OrderSend()

 if(OrderSend (Symbol(),OP_SELLLIMIT,0.10,Bid,Slippage,0,0,"первый ордер сел установлен",Magik,0) > 0)

In realtà, io farei quanto segue:

   int ticket=OrderSend (Symbol(),OP_SELLLIMIT,0.10,Bid,Slippage,0,0,"первый ордер сел установлен",Magik,0);
   if(ticket>=0)
      {
        if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES))
          {
            if (OrderStopLoss()==0 || OrderTakeProfit()==0)
             {
               double sl = OrderOpenPrice() + NormalizeDouble(stopL1 * Point,Digits);
               double tp = OrderOpenPrice() - NormalizeDouble(takeP1 * Point,Digits);
               if(!OrderModify(OrderTicket(),OrderOpenPrice(),sl,tp,0)) Print("Error ",GetLastError()," modify order ",ticket);
             }
          }
      }
 
Sepulca:

Leggete attentamente cosa restituisce OrderSend()

if(ticket>=0)

Infatti, io farei così:

Un biglietto può essere zero?
1...109310941095109610971098109911001101110211031104110511061107...1178
Nuovo commento