Per favore, aiuta a scrivere EA gratis. 5 idee diverse. - pagina 15
Ti stai perdendo delle opportunità di trading:
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Registrazione
Accedi
Accetti la politica del sito e le condizioni d’uso
Se non hai un account, registrati
Questo è tutto. Capisco, "cercando" di aiutare. Sento che è il momento di condividere altre idee.
Questo è tutto. Capisco, "cercando" di aiutare. Sento che è il momento di condividere altre idee.
Chi sarebbe interessato alla "vecchia bicicletta"? Non hai ancora capito che quello che stai cercando di iniziare ad esplorare è da tempo nel forum e ci sono implementazioni gratuite nel codice base - guarda e gioca in giro. Avete le vostre idee? Altrimenti non c'è niente da discutere.
Per favore aiutami ad aggiungere il numero massimo di ordini aperti al consulente!
//+------------------------------------------------ ------+
//| v128-2.mq4 |
//| Copyright © 2011, Andrey N. Bolkonsky |
//| 21/03/2011 |
//| e-mail: abolk@yandex.ru | Skype: abol1 |
//+------------------------------------------------ ------+
#proprietà copyright "Copyright © 2011, Andrey N. Bolkonsky"
#link proprietà "abolk@yandex.ru"
//
stringa esterna rem2 = "=== Numero di lotti ===";
doppio esterno _Lots0_1 = 0,1; // Livello base (per il 1° ordine)
doppio esterno _Lots0_2 = 0,1; // Livello base (per il 2° ordine)
//
stringa esterna rem3 = "=== Parametri aggiuntivi ===";
int esterno _TakeProfit1_Proc = 50; // Rischio percentuale per prendere profitto del 1° ordine
extern int _SpaseFromMaxMin = 1; // Offset dall'alto/dal basso
//
stringa esterna rem4 = "=== Parametri di pareggio ===";
bool esterno _IsStopLoss_0 = falso; // Abilitazione all'uso del livello di pareggio
extern int _StopLoss_0_Da = 0; // Compensazione dal livello di pareggio (in punti)
extern int _StopLoss_0_Level = 15; // Livello di pareggio
//
stringa esterna rem5 = "=== Parametri del trailing stop ===";
bool esterno _IsTrailingStop = false; // Abilita il trailing stop
bool _IsTrailingStopProfit = true; // Abilitazione di un trailing stop da una posizione di pareggio
//extern int _TrailingStopProfit_From = 0; // Compensazione dal livello di pareggio (in punti)
extern int _TrailingStopLevel = 15; // Livello di trailing stop
extern int _TrailingStopStep = 5; // Fase di spostamento del trailing stop
//
stringa esterna rem6 = "=== Impostazioni utensile ===";
stringa esterna _Symboll = ""; // Nome simbolico dello strumento: "" - simbolo corrente
extern int _Timeframe = 0; // Periodo: 0 - periodo del grafico corrente
int_cifre; // Numero di cifre dopo il punto decimale del prezzo
doppi _Punti; // Dimensione dei punti nella valuta delle quotazioni
extern int _Slippage = 2; // slittamento
int esterno _Magic1 = 1281; // Numero univoco di ordini EA (1° ordine)
int esterno _Magic2 = 1282; // Numero univoco di ordini EA (2° ordine)
//
stringa esterna rem7 = "=== Parametri indicatore MA1 ===";
extern int _MA1_Timeframe = PERIOD_D1; // Periodo: 0 - periodo del grafico corrente
extern int _MA1_Period = 20; // Periodo medio per il calcolo della media mobile
int esterno _MA1_Shift = 0; // Spostamento dell'indicatore rispetto al grafico dei prezzi
int esterno _MA1_Metodo = 0; // Metodo di media: 0 - SMA, 1 - EMA, 2 - SMMA, 3 - LWMA
extern int _MA1_Applied_Price = 0; // Prezzo usato: 0 - chiude, 1 - apre, 2 - alto, 3 - basso
//
stringa esterna rem8 = "=== parametri indicatore MA2 ===";
extern int _MA2_Timeframe = PERIOD_H4; // Periodo: 0 - periodo del grafico corrente
extern int _MA2_Period = 20; // Periodo medio per il calcolo della media mobile
int esterno _MA2_Shift = 0; // Spostamento dell'indicatore rispetto al grafico dei prezzi
int esterno _MA2_Metodo = 0; // Metodo di media: 0 - SMA, 1 - EMA, 2 - SMMA, 3 - LWMA
extern int _MA2_Applied_Price = 0; // Prezzo usato: 0 - chiude, 1 - apre, 2 - alto, 3 - basso
//
stringa esterna rem9 = "=== Parametri dell'indicatore delle bande di Bollinger ===";
//extern int _BB_Timeframe = 0; // Periodo: 0 - periodo del grafico corrente
extern int _BB_Period = 20; // Periodo medio della linea dell'indicatore principale
extern int _BB_Deviation = 2; // Deviazione dalla linea principale
int esterno _BB_Bands_Shift = 0; // Spostamento dell'indicatore rispetto al grafico dei prezzi
extern int _BB_Applied_Price = 0; // Prezzo usato: 0 - chiudi
//
stringa esterna rem10 = "=== parametri dell'indicatore ZigZag ===";
//extern int _ZZ_Timeframe = 0; // Periodo: 0 - periodo del grafico corrente
extern int _ZZ_ExtDepth = 12;
extern int _ZZ_ExtDeviation = 5;
extern int _ZZ_ExtBackstep = 3;
//
datetime_TimePrevious;
datetime _TimeCurrent;
//
stringa_fstr;
int_tp;
//
void MaxOrders(int max_orders=5);
//=++============================================== ======================= = =================++=
int init()
{
if(_Symbol == "") _Symboll = Symbol();
//
_Digitss = MarketInfo(_Simbolo, MODE_DIGITS);
_Punti = MarketInfo(_Simbolo, MODE_POINT);
//
if(_Timeframe == 0) _Timeframe = Periodo();
Print("v128-2 > init() >> _Timeframe=", _Timeframe,
"rem4=",_IsStopLoss_0,
"rem5=",_IsTrailingStop,_IsTrailingStopProfit);
//
_fstr = "v128_";
_tp = _FileReadWriteDouble(_fstr+"_tp.dat", 0); // assicurati che il file esista, se non esiste crealo
Print("v128-2 > init() >> _Timeframe=", _Timeframe, " _tp=",_tp);
//
_TimePrevious=iTime(_Simbolo, _Timeframe, 0);
//
Print("v128-2 > Fatto: init() >> _TimePrevious=", _TimePrevious, " (", TimeToStr(_TimePrevious,TIME_DATE|TIME_MINUTES), ")");
ritorno(0);
}
//=++============================================== ======================= = =================++=
inizio int()
{
doppia P_Chiudi1, P_Chiudi2;
doppia BB_1_superiore, BB_1_inferiore;
doppio MA1_0, MA2_0;
doppia P_ask, P_bid;
bool is_signal_2_buy, is_signal_2_sell;
doppio P1_acquisto, P2_acquisto, P3_acquisto;
doppio P1_vendita, P2_vendita, P3_vendita;
bool is_b1 = falso, is_s1 = falso;
bool is_b2 = falso, is_s2 = falso;
biglietto intero;
//
_TimeCurrent = iTime(_Simbolo, _Timeframe, 0);
if(_TimeCurrent != _TimePrevious)
{
MA1_0 = iMA(_Simbolo, _MA1_Lasso di tempo, _MA1_Periodo, _MA1_Spostamento, _MA1_Metodo, _MA1_Prezzo_applicato, 0);
MA2_0 = iMA(_Simbolo, _MA2_Lasso di tempo, _MA2_Periodo, _MA2_Spostamento, _MA2_Metodo, _MA2_Prezzo_applicato, 0);
BB_1_upper = iBands(_Simbolo, _Timeframe, _BB_Period,_BB_Deviation,_BB_Bands_Shift,_BB_Applied_Price, MODE_UPPER, 1);
BB_1_lower = iBands(_Simbolo, _Timeframe, _BB_Period,_BB_Deviation,_BB_Bands_Shift,_BB_Applied_Price, MODE_LOWER, 1);
P_Chiudi1 = iChiudi(_Simbolo, _Lasso di tempo, 1);
P_Chiudi2 = iChiudi(_Simbolo, _Lasso di tempo, 2);
P_ask = MarketInfo(_Simbolo, MODE_ASK);
P_bid = MarketInfo(_Simbolo, MODE_BID);
Print("v120-4 > ", _Simbolo, " | ", _Lasso di tempo,
" -> MA1_0=", MA1_0, " | MA2_0=", MA2_0,
" -> BB_1_upper=", BB_1_upper, " | BB_1_lower=", BB_1_lower,
" -> P_Chiudi1=", P_Chiudi1, " | P_Chiudi2=", P_Chiudi2,
" -> ask=", P_ask, " | bid=", P_bid);
//
is_signal_2_buy = P_bid >= MA1_0 && P_bid >= MA2_0 && P_Close1 >= BB_1_lower && P_Close2 <= BB_1_lower && P_bid >= BB_1_lower;
is_signal_2_sell = P_bid <= MA1_0 && P_bid <= MA2_0 && P_Close1 <= BB_1_upper && P_Close2 >= BB_1_upper && P_bid <= BB_1_upper;
Print("v128-2 > ", _Simbolo, " | ", _Lasso di tempo,
" -> is_signal2 -> buy=", is_signal_2_buy, " | sell=", is_signal_2_sell);
// ========== per mercato
// ========== apertura di un ordine ACQUISTA
if( is_signal_2_buy )
{
Print("v128-2 > ", _Simbolo, " | ", _Lasso di tempo,
" -> segnale per aprire un ordine ACQUISTA");
OrdersDeleteAll(OP_SELL);
//
se(!è_b1 || !è_b2)
{
P1_acquistare = P_chiedere;
P3_buy = TrovaPrezzoMinMax(false) - (_SpaseFromMaxMin) * _Punto;
_tp = (P1_acquisto - P3_acquisto) / _Punto * (_TakeProfit1_Proc / 100.0);
P2_buy = DoubleTestZero(_tp, P1_buy + (_tp) * _Point);
//
_FileWriteDouble(_fstr+"_tp.dat", _tp);
//
Print("v128-2 > ", _Simbolo, " | ", _Lasso di tempo,
" -> ACQUISTA -> P1_buy=", P1_buy, " | P2_buy=", P2_buy, " | P3_buy=", P3_buy, "_tp=", _tp);
//
ticket = OrderSend(_Symbol, OP_BUY, _Lots0_1, ND(P1_buy), _Slippage, ND(P3_buy), ND(P2_buy),
NULL, _Magic1, 0, CLR_NONE);
se(biglietto == -1)
Print("v128-2 > ", _Simbolo, " | ", _Lasso di tempo,
" -> ACQUISTA (1) > Errore (apertura) #", GetLastError());
altrimenti è_b1 = vero;
//
ticket = OrderSend(_Symbol, OP_BUY, _Lots0_2, ND(P1_buy), _Slippage, ND(P3_buy), 0,
NULL, _Magic2, 0, CLR_NONE);
se(biglietto == -1)
Print("v128-2 > ", _Simbolo, " | ", _Lasso di tempo,
" -> ACQUISTA (2) > Errore (apertura) #", GetLastError());
altrimenti è_b2 = vero;
//
}
altrimenti { is_b1 = vero; is_b2 = vero; }
}
altrimenti { is_b1 = vero; is_b2 = vero; }
//Stampa("= compra +++",è_b1,è_b2,"==",è_s1,è_s2);
// ========== apertura di un ordine VENDITA
if( is_signal_2_sell )
{
Print("v128-2 > ", _Simbolo, " | ", _Lasso di tempo,
" -> segnale per aprire un ordine VENDITA");
OrdersDeleteAll(OP_BUY);
//
se(!è_s1 || !è_s2)
{
P1_vendita = P_offerta;
P3_sell = TrovaPrezzoMinMax(true) + (_SpaseFromMaxMin) * _Punto;
_tp = (P3_sell - P1_sell) / _Punto * (_TakeProfit1_Proc / 100.0);
P2_sell = DoubleTestZero(_tp, P1_sell - (_tp) * _Point);
//
_FileWriteDouble(_fstr+"_tp.dat", _tp);
//
Print("v128-2 > ", _Simbolo, " | ", _Lasso di tempo,
" -> ACQUISTA -> P1_sell=", P1_sell, " | P2_sell=", P2_sell, " | P3_sell=", P3_sell);
//
ticket = OrderSend(_Symbol, OP_SELL, _Lots0_1, ND(P1_sell), _Slippage, ND(P3_sell), ND(P2_sell),
NULL, _Magic1, 0, CLR_NONE);
se(biglietto == -1)
Print("v128-2 > ", _Simbolo, " | ", _Lasso di tempo,
" -> VENDI (1) > Errore (apertura) #", GetLastError());
altrimenti è_s1 = vero;
//
ticket = OrderSend(_Symbol, OP_SELL, _Lots0_2, ND(P1_sell), _Slippage, ND(P3_sell), 0,
NULL, _Magic2, 0, CLR_NONE);
se(biglietto == -1)
Print("v128-2 > ", _Simbolo, " | ", _Lasso di tempo,
" -> VENDI (2) > Errore (apertura) #", GetLastError());
altrimenti è_s2 = vero;
//
}
altrimenti { is_s1 = vero; is_s2 = vero; }
}
altrimenti { is_s1 = vero; is_s2 = vero; }
//Stampa("= vendi +++",è_b1,è_b2,"==",è_s1,è_s2);
// ===========
if(è_b1 && è_s1 && è_b2 && è_s2)
_TimePrevious=_TimeCurrent;
}
//
if(_IsTrailingStop)
{
if( !FindOrders(_Magic1) ) TrailingStop(_tp);
}
//
se(_IsStopLoss_0)
StopLoss_0(_StopLoss_0_Da);
//
ritorno(0);
}
//=++============================================== ======================= = =================++=
double DoubleTestZero(doppio valore, doppio nuovo_valore)
{
if(valore==0) return(valore);
altrimenti ritorno(nuovo_valore);
}
//=++============================================== ======================= = =================++=
doppio ND(doppio valore)
{
return( NormalizeDouble(valore, _Digits) );
}
//=++============================================== ======================= = =================++=
// ordini di chiusura. Fine su chiudi tutto
void OrdersDeleteAll(int cmd)
{
while(CountOrders(cmd) > 0)
{
for(int i = OrdersTotal() - 1; i >= 0 ; i--)
{
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
if( (OrderSymbol() == _Symbol)
&& (OrderMagicNumber() == _Magic1 || OrderMagicNumber() == _Magic2)
&& (TipoOrdine() == cmd) )
{
if(TipoOrdine() == OP_ACQUISTA)
if(!OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_BID), _Slippage, CLR_NONE))
Print("v128-2 > ", _Symbol, " > ACQUISTA -> ticket=", OrderTicket(),
" -> Errore (chiusura) #", GetLastError());
if(TipoOrdine() == OP_VENDITA)
if(!OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_ASK), _Slippage, CLR_NONE))
Print("v128-2 > ", _Symbol, " > SELL -> ticket=", OrderTicket(),
" -> Errore (chiusura) #", GetLastError());
}
}
}
}
// numero di ordini
}
//=++============================================== ======================= = =================++=
// contando il numero di ordini nella direzione
int CountOrders(int cmd)
{
int n = 0;
for(int i = OrdersTotal() - 1; i >= 0 ; i--)
{
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
if( (OrderSymbol() == _Symbol)
&& (OrderMagicNumber() == _Magic1 || OrderMagicNumber() == _Magic2)
&& (TipoOrdine() == cmd) ) n++;
}
}
ritorno(n);
}
//=++============================================== ======================= = =================++=
// cerca un ordine per magia
bool FindOrders(int magic)
{
for(int i = OrdersTotal() - 1; i >= 0 ; i--)
{
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
if( (OrderSymbol() == _Symbol) && (OrderMagicNumber() == magic) )
ritorno(vero);
}
}
ritorno (falso);
}
//=++============================================== ======================= = =================++=
// risolvendo magicamente il livello di pareggio
void StopLoss_0(int da)
{
doppio punto di profitto, offerta, domanda;
bool è;
doppio P3_compra, P3_vendi;
//
for(int i = OrdersTotal() - 1; i >= 0 ; i--)
{
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
if(!( (OrderSymbol() == _Symbol) && (OrderMagicNumber() == _Magic1 || OrderMagicNumber() == _Magic2) )) continue;
//
if(TipoOrdine() == OP_ACQUISTA)
{
offerta = MarketInfo(_Simbolo, MODE_BID);
profitpoint = (offerta - OrderOpenPrice()) / _Point;
è = punto di profitto >= _StopLoss_0_Livello + da;
P3_buy = ND( OrderOpenPrice() + da * _Point);
//
if( è && ( OrderStopLoss() == 0 || OrderStopLoss() < P3_buy ) )
{
Print("v128-2 b4 >", _Simbolo, " | ", _Lasso di tempo,
" -> Bid=", MarketInfo(_Simbolo, MODE_BID),
" | p/o=", OrderOpenPrice(), " | s/l=", OrderStopLoss(), " | P3_buy=", P3_buy,
" | d=", _StopLoss_0_Level, " | profitpoint=", profitpoint);
if(!OrderModify(OrderTicket(), OrderOpenPrice(), P3_buy, OrderTakeProfit(), 0, CLR_NONE))
Print("v128-2 b4 > ", _Simbolo, " | ", _Lasso di tempo,
" -> ACQUISTA > ticket=", OrderTicket(), " > Errore (pareggio) #", GetLastError());
}
}
//
altrimenti se(TipoOrdine() == OP_VENDITA)
{
chiedi = MarketInfo(_Simbolo, MODE_ASK);
profitpoint = (OrderOpenPrice() - chiedi) / _Point;
è = punto di profitto >= _StopLoss_0_Livello + da;
P3_sell = ND( OrderOpenPrice() - da * _Point);
//
if( è && ( OrderStopLoss() == 0 || OrderStopLoss() > P3_sell ) )
{
Print("v128-2 b4 >", _Simbolo, " | ", _Lasso di tempo,
" -> Chiedi =", MarketInfo(_Simbolo, MODE_ASK),
" | p/o=", OrderOpenPrice(), " | s/l=", OrderStopLoss(), " | P3_sell=", P3_sell,
" | d=", _StopLoss_0_Level, " | profitpoint=", profitpoint);
if(!OrderModify(OrderTicket(), OrderOpenPrice(), P3_sell, OrderTakeProfit(), 0, CLR_NONE))
Print("v128-2 b4 > ", _Simbolo, " | ", _Lasso di tempo,
" -> VENDI -> ticket=", OrderTicket(), " > Errore (pareggio) #", GetLastError());
}
}
}
}
}
//=++============================================== ======================= = =================++=
// risolvendo il trailing stop con la magia
void TrailingStop(int da)
{
doppio punto di profitto, offerta, domanda;
doppio dal prezzo;
//
for(int i = OrdersTotal() - 1; i >= 0 ; i--)
{
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
if(!( (OrderSymbol() == _Symbol) && (OrderMagicNumber() == _Magic1 || OrderMagicNumber() == _Magic2) )) continue;
//
if(TipoOrdine() == OP_ACQUISTA)
{
if(_IsTrailingStopProfit) fromprice = OrderOpenPrice() + from * _Point;
else fromprice = OrderStopLoss();
//
offerta = MarketInfo(_Simbolo, MODE_BID);
punto profitto = (offerta - ND(dal prezzo)) / _Punto;
//
if( punto di profitto >= _TrailingStopLevel &&
bid > (OrderStopLoss() + (_TrailingStopLevel + _TrailingStopStep) * _Point) )
{
Print("v128-2 v4 >", _Simbolo, " | ", _Lasso di tempo,
" -> Bid=", MarketInfo(_Simbolo, MODE_BID),
" | p/o=", OrderOpenPrice(), " | s/l=", OrderStopLoss(),
" | d=", _TrailingStopLevel, " | profitpoint=", profitpoint);
if(!OrderModify(OrderTicket(), OrderOpenPrice(), ND(bid - (_TrailingStopLevel) * _Point),
OrderTakeProfit(), 0, CLR_NONE))
{
Print("v128-2 v4 >", _Simbolo, " | ", _Lasso di tempo,
" -> ACQUISTA > ticket=", OrderTicket(), " > Error (trailing stop) #", GetLastError());
}
}
}
//
altrimenti se(TipoOrdine() == OP_VENDITA)
{
if(_IsTrailingStopProfit) fromprice = OrderOpenPrice() - da * _Point;
else fromprice = OrderStopLoss();
//
chiedi = MarketInfo(_Simbolo, MODE_ASK);
profitpoint = (ND(daprezzo) - chiedi) / _Punto;
//
if( punto di profitto >= _TrailingStopLevel &&
ask < (OrderStopLoss() - (_TrailingStopLevel + _TrailingStopStep) * _Point) )
{
Print("v128-2 v4 >", _Simbolo, " | ", _Lasso di tempo,
" -> Chiedi=", MarketInfo(_Simbolo, MODE_ASK),
" | p/o=", OrderOpenPrice(), " | s/l=", OrderStopLoss(),
" | d=", _TrailingStopLevel, " | profitpoint=", profitpoint);
if(!OrderModify(OrderTicket(), OrderOpenPrice(), ND(ask + (_TrailingStopLevel) * _Point),
OrderTakeProfit(), 0, CLR_NONE))
{
Print("v128-2 v4 >", _Simbolo, " | ", _Lasso di tempo,
" -> VENDI > ticket=", OrderTicket(), " > Error (trailing stop) #", GetLastError());
}
}
}
}
}
}
//=++============================================== ======================= = =================++=
// Trovare il fondo locale. Restituisce il prezzo
double FindPriceMinMax(bool isUp)
{
spostamento int = 1;
doppio prezzo = 0, p0,p1,p2;
mentre(prezzo == 0)
{
p0 = iCustom(_Symbol, _Timeframe, "ZigZag", _ZZ_ExtDepth, _ZZ_ExtDeviation, _ZZ_ExtBackstep, 0, shift);
p1 = iCustom(_Symbol, _Timeframe, "ZigZag", _ZZ_ExtDepth, _ZZ_ExtDeviation, _ZZ_ExtBackstep, 1, shift);
p2 = iCustom(_Symbol, _Timeframe, "ZigZag", _ZZ_ExtDepth, _ZZ_ExtDeviation, _ZZ_ExtBackstep, 2, shift);
//Stampa("v128-2 >", _Simbolo, " | ", _Lasso di tempo,
// " > sift=", shift, " | p0=", p0, " | p1=", p1, " | p2=", p2);
se(isUp)
{
if(p0 !=0 && p0 == p1) // vertice trovato
prezzo = p0;
}
altro
{
if(p0 != 0 && p0 == p2) // fondo trovato
prezzo = p0;
}
spostamento++;
}
//Stampa("v128-2 >", _Simbolo, " | ", _Lasso di tempo,
// " -> ritorno(prezzo)=", prezzo);
ritorno(prezzo);
}
//================================================================================ = ======================
// Leggi la variabile dal file.
// Se il file non esiste, crea un file e scrivi la variabile nel file
double _FileReadWriteDouble(string filename, double value)
{
int h1 = FileOpen(nome file, FILE_BIN);
se(h1 > 0)
{
valore = FileReadDouble(h1, DOUBLE_VALUE);
FileChiudi(h1);
}
altro
{
h1 = FileOpen(nome file, FILE_BIN|FILE_WRITE);
FileWriteDouble(h1, valore, DOUBLE_VALUE);
FileChiudi(h1);
}
valore di ritorno);
}
//================================================================================ = ======================
// Scrive la variabile su file
void _FileWriteDouble(nome file stringa, valore doppio)
{
int h1 = FileOpen(nome file, FILE_BIN|FILE_WRITE);
FileWriteDouble(h1, valore, DOUBLE_VALUE);
FileChiudi(h1);
}