Expert Advisor
Phoenix Expert Advisor Forex è molto complicato EA.
Esso utilizza molti standard MetaTrader 4 indicatori (come le medie mobili e buste) per determinare la posizione di entrata e di uscita così come i parametri di posizione.
Questo consulente esperto ha molti parametri di input e memorizzati internamente set di dati per ciascuna delle cinque coppie di valute può essere utilizzato per il commercio con.
L'abbondanza degli indicatori e dei controlli condizionale fare consulente esperto Phoenix un po 'più lenta della CPU per l'elaborazione.
La prova del MetaTrader Expert advisor Phoenix ha portato circa 6.400 dollari di profitto con GBP/USD su un time frame di 15 minuti con 1 lotto standard per aprire posizioni.
Il test è stato fatto nel corso di un periodo di un anno, con massimo drawdown un minimo di € 96.
Ho anche controllato su un periodo di tre anni e ha dimostrato le stesse prestazioni.
MiniFAQ
Quali sono gli stop-loss e take-profit utilizzato da questo EA?
Esso utilizza la variabile di stop-loss e take-profit, ma la media vincere e perdere la posizione resa pips 138 e 148, in media, rispettivamente.
Quanto spesso trada?
Il 15 minuti di GBP / USD grafico (le impostazioni ottimali) questo EA commercio 1 volta al giorno in media.
//+------------------------------------------------------------------+
//| Phoenix_5_6_03.mq4 |
//| Copyright © 2006, Hendrick |
//| |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, Hendrick."
#define MAGICMA_A 20050610
#define MAGICMA_B 20060611
#define MAGICMA01 20050612
#define MAGICMA02 20060613
#define MAGICMA03 20060614
extern string GeneralSettings = "===== General Settings ============================";
extern int PhoenixMode = 3;
extern double Lots = 1;
extern double MaximumRisk = 0.05;
extern int DecreaseFactor = 0;
extern bool MM = true;
extern bool AccountIsMicro = false;
extern bool PrefSettings = true;
extern int CloseAfterHours = 0;
extern int BreakEvenAfterPips = 0;
extern string Mode1 = "====== Phoenix Mode 1 (Classic) ==================";
extern int TakeProfit = 0;
extern int StopLoss = 0;
extern int TrailingStop = 0;
extern string Mode2 = "====== Phoenix Mode 2 (Second trade)==============";
extern int Mode2_OpenTrade_2 = 0;
extern int Mode2_TakeProfit = 0;
extern int Mode2_StopLoss = 0;
extern bool Mode2_CloseFirstTrade = false;
extern string Mode3 = "====== Phoenix Mode 3 (Three trades at once) =====";
extern int Mode3_CloseTrade2_3 = 0;
extern int Mode3_TakeProfit = 0;
extern int Mode3_StopLoss = 0;
extern string Signal1 = "====== Signal 1 ===================================";
extern bool UseSignal1 = true;
extern double Percent = 0;
extern int EnvelopePeriod = 0;
extern string Signal2 = "====== Signal 2 ==================================";
extern bool UseSignal2 = true;
extern int SMAPeriod = 0;
extern int SMA2Bars = 0;
extern string Signal3 = "====== Signal 3 ==================================";
extern bool UseSignal3 = true;
extern int OSMAFast = 0;
extern int OSMASlow = 0;
extern double OSMASignal = 0;
extern string Signal4 = "====== Signal 4 ==================================";
extern bool UseSignal4 = true;
extern int Fast_Period = 0;
extern int Fast_Price = PRICE_OPEN;
extern int Slow_Period = 0;
extern int Slow_Price = PRICE_OPEN;
extern double DVBuySell = 0;
extern double DVStayOut = 0;
extern string Signal5 = "====== Signal 5 =================================";
extern bool UseSignal5 = true;
extern int TradeFrom1 = 0;
extern int TradeUntil1 = 24;
extern int TradeFrom2 = 0;
extern int TradeUntil2 = 0;
extern int TradeFrom3 = 0;
extern int TradeUntil3 = 0;
extern int TradeFrom4 = 0;
extern int TradeUntil4 = 0;
double Poin;
int init()
{
//Checking for unconvetional Point digits number
if (Point == 0.00001) Poin = 0.0001; //5 digits
else if (Point == 0.001) Poin = 0.01; //3 digits
else Poin = Point; //Normal
//+------------------------------------------------------------------+
//| START Preffered Settings |
//+------------------------------------------------------------------+
if(PrefSettings == true)
{
if((Symbol() == "USDJPY") || (Symbol() == "USDJPYm"))
{
Mode2_OpenTrade_2 = 0;
Mode2_TakeProfit = 50;
Mode2_StopLoss = 60;
Mode3_CloseTrade2_3 = 30;
Mode3_TakeProfit = 100;
Mode3_StopLoss = 55;
Percent = 0.0032;
EnvelopePeriod = 2;
TakeProfit = 42;
StopLoss = 84;
TrailingStop = 0;
SMAPeriod = 2;
SMA2Bars = 18;
OSMAFast = 5;
OSMASlow = 22;
OSMASignal = 2;
Fast_Period = 25;
Slow_Period = 15;
DVBuySell = 0.0029;
DVStayOut = 0.024;
}
if((Symbol() == "EURJPY") || (Symbol() == "EURJPYm"))
{
Mode2_OpenTrade_2 = 18;
Mode2_TakeProfit = 70;
Mode2_StopLoss = 30;
Mode3_CloseTrade2_3 = 55;
Mode3_TakeProfit = 70;
Mode3_StopLoss = 80;
Percent = 0.007;
EnvelopePeriod = 2;
TakeProfit = 42;
StopLoss = 84;
TrailingStop = 0;
SMAPeriod = 4;
SMA2Bars = 16;
OSMAFast = 11;
OSMASlow = 20;
OSMASignal = 14;
Fast_Period = 20;
Slow_Period = 10;
DVBuySell = 0.0078;
DVStayOut = 0.026;
}
if((Symbol() == "GBPJPY") || (Symbol() == "GBPJPYm"))
{
Mode2_OpenTrade_2 = 2;
Mode2_TakeProfit = 130;
Mode2_StopLoss = 80;
Mode3_CloseTrade2_3 = 40;
Mode3_TakeProfit = 90;
Mode3_StopLoss = 80;
Percent = 0.0072;
EnvelopePeriod = 2;
TakeProfit = 42;
StopLoss = 84;
TrailingStop = 0;
SMAPeriod = 8;
SMA2Bars = 12;
OSMAFast = 5;
OSMASlow = 36;
OSMASignal = 10;
Fast_Period = 17;
Slow_Period = 28;
DVBuySell = 0.0034;
DVStayOut = 0.063;
}
if((Symbol() == "USDCHF") || (Symbol() == "USDCHFm"))
{
Mode2_OpenTrade_2 = 10;
Mode2_TakeProfit = 90;
Mode2_StopLoss = 65;
Mode3_CloseTrade2_3 = 85;
Mode3_TakeProfit = 130;
Mode3_StopLoss = 80;
Percent = 0.0056;
EnvelopePeriod = 10;
TakeProfit = 42;
StopLoss = 84;
TrailingStop = 0;
SMAPeriod = 5;
SMA2Bars = 9;
OSMAFast = 5;
OSMASlow = 12;
OSMASignal = 11;
Fast_Period = 5;
Slow_Period = 20;
DVBuySell = 0.00022;
DVStayOut = 0.0015;
}
if((Symbol() == "GBPUSD") || (Symbol() == "GBPUSDm"))
{
Mode2_OpenTrade_2 = 5;
Mode2_TakeProfit = 95;
Mode2_StopLoss = 90;
Mode3_CloseTrade2_3 = 90;
Mode3_TakeProfit = 110;
Mode3_StopLoss = 80;
Percent = 0.0023;
EnvelopePeriod = 6;
TakeProfit = 42;
StopLoss = 84;
TrailingStop = 0;
SMAPeriod = 3;
SMA2Bars = 14;
OSMAFast = 23;
OSMASlow = 17;
OSMASignal = 15;
Fast_Period = 25;
Slow_Period = 37;
DVBuySell = 0.00042;
DVStayOut = 0.05;
}
}
return(0);
}
//+------------------------------------------------------------------+
//| END Preffered Settings |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| START EA |
//+------------------------------------------------------------------+
void start()
{
if(Bars<100)
{
Print("bars less than 100");
return(0);
}
if(PhoenixMode==1)//Phoenix Classic
{
CheckOpenTrade();
if(CloseAfterHours != 0) CheckCloseAfterHours();
if(!StopLoss==0) CheckTrailingStop();
if(BreakEvenAfterPips != 0) CheckBreakEven();
}
if(PhoenixMode==2)//Phoenix Second Trade
{
CheckOpenTrade();
if(CloseAfterHours != 0) CheckCloseAfterHours();
CheckSecondTrade();
}
if(PhoenixMode==3)//Phoenix 123
{
CheckOpenTradeMode123();
Mode3_MoveSL_Trade_2_3();
Mode3_MoveSL_Trade_3();
if(Mode3_CloseTrade2_3 != 0) CheckCloseTrade23();
}
}
//+------------------------------------------------------------------+
//| END EA |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| START Function Calculate open positions |
//+------------------------------------------------------------------+
int CalculateCurrentOrders(string symbol)
{
int count=0;
for(int i=0;i<OrdersTotal();i++)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) break;
if(OrderSymbol()==Symbol() && (OrderMagicNumber()==MAGICMA_A || OrderMagicNumber()==MAGICMA_B))
{
count++;
}
}
return(count);
}
//+------------------------------------------------------------------+
//| STOP Function Calculate open positions |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| START Function Check Open Trade |
//+------------------------------------------------------------------+
int CheckOpenTrade()
{
int Signal=0, err = 0, total = OrdersTotal();
if(CalculateCurrentOrders(Symbol()) < 1)
{
if(CheckSignal(Signal)==1)
{
if(OrderSend(Symbol(),OP_SELL,LotsOptimized(),Bid,3,Bid+StopLoss*Poin,Bid-TakeProfit*Poin,"FirstTrade",MAGICMA_A,0,Red) < 0)
{
err = GetLastError();
Print("Error Ordersend(",err,"): ");
return(-1);
}
return(0);
}
if(CheckSignal(Signal)==2)
{
if(OrderSend(Symbol(),OP_BUY,LotsOptimized(),Ask,3,Ask-StopLoss*Poin,Ask+TakeProfit*Poin,"FirstTrade",MAGICMA_A,0,Blue) < 0)
{
err = GetLastError();
Print("Error Ordersend(",err,"): ");
return(-1);
}
return(0);
}
}
}
//+------------------------------------------------------------------+
//| END Function Check Open Trade |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| START MODE 3 Function Check Open Trade |
//+------------------------------------------------------------------+
int CheckOpenTradeMode123()
{
int Signal = 0, err = 0, total = OrdersTotal(), decimalPlaces=1;
if(AccountIsMicro==true) decimalPlaces=2;
double lots123 = NormalizeDouble(LotsOptimized()/3,decimalPlaces);
if(lots123 < 0.1 && AccountIsMicro==false) {lots123=0.1;}
if(lots123 < 0.01 && AccountIsMicro==true) {lots123=0.01;}
if(Mode3CalculateCurrentOrders(Symbol()) < 1)
{
if(CheckSignal(Signal)==1)
{
if(OrderSend(Symbol(),OP_SELL,lots123,Bid,3,Bid+Mode3_StopLoss*Poin,Bid-NormalizeDouble(Mode3_TakeProfit/2,0)*Poin,"Mode3_FirstTrade",MAGICMA01,0,Red)<0)
{
err = GetLastError();
Print("Error Ordersend(",err,"): ");
return(-1);
}
if(OrderSend(Symbol(),OP_SELL,lots123,Bid,3,Bid+Mode3_StopLoss*Poin,Bid-Mode3_TakeProfit*Poin,"Mode3_SecondTrade",MAGICMA02,0,Red)<0)
{
err = GetLastError();
Print("Error Ordersend(",err,"): ");
return(-1);
}
if(OrderSend(Symbol(),OP_SELL,lots123,Bid,3,Bid+Mode3_StopLoss*Poin,Bid-NormalizeDouble(Mode3_TakeProfit*1.5,0)*Poin,"Mode3_ThirdTrade",MAGICMA03,0,Red)<0)
{
err = GetLastError();
Print("Error Ordersend(",err,"): ");
return(-1);
}
return(0);
}
if(CheckSignal(Signal)==2)
{
if(OrderSend(Symbol(),OP_BUY,lots123,Ask,3,Ask-Mode3_StopLoss*Poin,Ask+NormalizeDouble(Mode3_TakeProfit/2,0)*Poin,"Mode3_FirstTrade",MAGICMA01,0,Blue)<0)
{
err = GetLastError();
Print("Error Ordersend(",err,"): ");
return(-1);
}
if(OrderSend(Symbol(),OP_BUY,lots123,Ask,3,Ask-Mode3_StopLoss*Poin,Ask+Mode3_TakeProfit*Poin,"Mode3_SecondTrade",MAGICMA02,0,Blue)<0)
{
err = GetLastError();
Print("Error Ordersend(",err,"): ");
return(-1);
}
if(OrderSend(Symbol(),OP_BUY,lots123,Ask,3,Ask-Mode3_StopLoss*Poin,Ask+NormalizeDouble(Mode3_TakeProfit*1.5,0)*Poin,"Mode3_ThirdTrade",MAGICMA03,0,Blue)<0)
{
err = GetLastError();
Print("Error Ordersend(",err,"): ");
return(-1);
}
return(0);
}
}
}
//+------------------------------------------------------------------+
//| END Function Check Open Trade |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| START Function Check Second Trade |
//+------------------------------------------------------------------+
void CheckSecondTrade()
{
int err = 0, total = OrdersTotal();
for(int z = total - 1; z >= 0; z --)
{
if(!OrderSelect( z, SELECT_BY_POS))
{
err = GetLastError();
Print("OrderSelect( ", z, ", SELECT_BY_POS ) - Error #",err );
continue;
}
if(OrderSymbol() != Symbol()) continue;
if(OrderMagicNumber() == MAGICMA_B) break;
if(OrderMagicNumber() != MAGICMA_A) continue;
if(OrderType() == OP_BUY && (Bid-OrderOpenPrice() > Poin*Mode2_OpenTrade_2))
{
if(OrderSend(Symbol(),OP_BUY,LotsOptimized(),Ask,3,Ask - Mode2_StopLoss * Poin,Ask + Mode2_TakeProfit * Poin,"Mode2_SecondTrade",MAGICMA_B,0,Blue) < 0)
{
err = GetLastError();
Print("Error Ordersend(",err,"): ");
return(-1);
}
if(Mode2_CloseFirstTrade==true) {CloseFirstTrade();}
return(0);
}
if(OrderType() == OP_SELL && (OrderOpenPrice()-Ask > Poin*Mode2_OpenTrade_2))
{
if(OrderSend(Symbol(),OP_SELL,LotsOptimized(),Bid,3,Bid + Mode2_StopLoss * Poin,Bid - Mode2_TakeProfit*Poin,"Mode2_SecondTrade",MAGICMA_B,0,Red) < 0)
{
err = GetLastError();
Print("Error Ordersend(",err,"): ");
return(-1);
}
if(Mode2_CloseFirstTrade==true) {CloseFirstTrade();}
return(0);
}
}
}
//+------------------------------------------------------------------+
//| END Function Check Second Trade |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| START Function Check Close Trade 2 And 3 |
//+------------------------------------------------------------------+
void CheckCloseTrade23()
{
int err = 0, total = OrdersTotal();
bool CloseTrade=false;
for(int z = total - 1; z >= 0; z --)
{
if(!OrderSelect( z, SELECT_BY_POS))
{
err = GetLastError();
Print("OrderSelect( ", z, ", SELECT_BY_POS ) - Error #",err );
continue;
}
if(OrderSymbol() != Symbol()) continue;
if(OrderMagicNumber() != MAGICMA01) continue;
if(OrderType() == OP_BUY && (OrderOpenPrice()-Bid > Poin * Mode3_CloseTrade2_3)) {CloseTrade=true;}
if(OrderType() == OP_SELL && (Ask-OrderOpenPrice() > Poin * Mode3_CloseTrade2_3)) {CloseTrade=true;}
if(CloseTrade)
{
for(int y = total - 1; y >= 0; y --)
{
if(!OrderSelect( y, SELECT_BY_POS))
{
err = GetLastError();
Print("OrderSelect( ", y, ", SELECT_BY_POS ) - Error #",err );
continue;
}
if(OrderSymbol() != Symbol()) continue;
if(OrderMagicNumber() == MAGICMA02 || OrderMagicNumber() == MAGICMA03)
{
if(OrderType() == OP_BUY)
{
if(OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet)<0)
{
err = GetLastError();
Print("Error Ordersend(",err,"): ");
return(-1);
}
return(0);
}
if(OrderType() == OP_SELL)
{
if(OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet)<0)
{
err = GetLastError();
Print("Error Ordersend(",err,"): ");
return(-1);
}
return(0);
}
}
}
}
}
}
//+------------------------------------------------------------------+
//| END Function Check Close Trade 2 And 3 |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| START Check First Trade Mode3 |
//+------------------------------------------------------------------+
void Mode3_MoveSL_Trade_2_3()
{
int err = 0, total = OrdersTotal(), history = HistoryTotal();
bool ChangeStopLoss = false;
for(int z = history - 1; z >= 0; z --)
{
if(!OrderSelect( z,SELECT_BY_POS,MODE_HISTORY))
{
err = GetLastError();
Print("OrderSelect( ", z, ", SELECT_BY_POS ) - Error #",err );
continue;
}
if(OrderSymbol() != Symbol()) continue;
if(OrderMagicNumber() == MAGICMA03) break;
if(OrderMagicNumber() == MAGICMA02) break;
if(OrderMagicNumber() != MAGICMA01) continue;
if(OrderProfit() > 0)
{
ChangeStopLoss=true;
break;
}
}
if(ChangeStopLoss==true)
{
for(int y = total - 1; y >= 0; y --)
{
if(!OrderSelect(y,SELECT_BY_POS))
{
err = GetLastError();
Print("OrderSelect( ", y, ", SELECT_BY_POS ) - Error #",err );
continue;
}
if(OrderSymbol() != Symbol()) continue;
if(OrderMagicNumber() == MAGICMA02 || OrderMagicNumber() == MAGICMA03)
{
if(OrderType()==OP_BUY)
{
if(OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice(),OrderTakeProfit(),0,GreenYellow)<0)
{
err = GetLastError();
Print("OrderSelect( ", y, ", SELECT_BY_POS ) - Error #",err );
continue;
}
// return(0);
}
if(OrderType()==OP_SELL)
{
if(OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice(),OrderTakeProfit(),0,GreenYellow)<0)
{
err = GetLastError();
Print("OrderSelect( ", y, ", SELECT_BY_POS ) - Error #",err );
continue;
}
// return(0);
}
}
}
}
}
//}
//+------------------------------------------------------------------+
//| END Check First Trade Mode 3 |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| START Check Second Trade Mode3 |
//+------------------------------------------------------------------+
void Mode3_MoveSL_Trade_3()
{
double NewSLTrade3B,NewSLTrade3S;
int err = 0, total = OrdersTotal(), history = HistoryTotal();
bool ChangeStopLoss = false;
for(int z = history - 1; z >= 0; z --)
{
if(!OrderSelect( z,SELECT_BY_POS,MODE_HISTORY))
{
err = GetLastError();
Print("OrderSelect( ", z, ", SELECT_BY_POS ) - Error #",err );
continue;
}
if(OrderSymbol() != Symbol()) continue;
if(OrderMagicNumber() == MAGICMA03) break;
if(OrderMagicNumber() == MAGICMA01) break;
if(OrderMagicNumber() != MAGICMA02) continue;
if(OrderProfit() > 0)
{
for(int y = total - 1; y >= 0; y --)
{
if(!OrderSelect(y,SELECT_BY_POS))
{
err = GetLastError();
Print("OrderSelect( ", y, ", SELECT_BY_POS ) - Error #",err );
continue;
}
if(OrderSymbol() != Symbol()) continue;
if(OrderMagicNumber() == MAGICMA03)
{
if(OrderType()==OP_BUY)
{
NewSLTrade3B=OrderOpenPrice()+NormalizeDouble(((OrderTakeProfit()-OrderOpenPrice())/2),Digits);
if(OrderModify(OrderTicket(),OrderOpenPrice(),NewSLTrade3B,OrderTakeProfit(),0,GreenYellow)<0)
{
err = GetLastError();
Print("OrderSelect( ", y, ", SELECT_BY_POS ) - Error #",err );
continue;
}
return(0);
}
if(OrderType()==OP_SELL)
{
NewSLTrade3S=OrderOpenPrice()-NormalizeDouble(((OrderOpenPrice()-OrderTakeProfit())/2),Digits);
if(OrderModify(OrderTicket(),OrderOpenPrice(),NewSLTrade3S,OrderTakeProfit(),0,GreenYellow)<0)
{
err = GetLastError();
Print("OrderSelect( ", y, ", SELECT_BY_POS ) - Error #",err );
continue;
}
return(0);
}
}
}
}
}
}
//+------------------------------------------------------------------+
//| END Check Second Trade Mode 3 |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| START Function Diverge |
//+------------------------------------------------------------------+
double divergence(int F_Period, int S_Period, int F_Price, int S_Price, int mypos)
{
int i;
double maF1, maF2, maS1, maS2;
maF2 = iMA(Symbol(), 0, F_Period, 0, MODE_SMA, F_Price, mypos + 1);
maS2 = iMA(Symbol(), 0, S_Period, 0, MODE_SMA, S_Price, mypos + 1);
return(maF2-maS2);
}
//+------------------------------------------------------------------+
//| END Function Diverge |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| START Function Valid Trade Time |
//+------------------------------------------------------------------+
bool F_ValidTradeTime (int iHour)
{
if(((iHour >= TradeFrom1) && (iHour <= (TradeUntil1-1)))||((iHour>= TradeFrom2) && (iHour <= (TradeUntil2-1)))||((iHour >= TradeFrom3)&& (iHour <= (TradeUntil3-1)))||((iHour >= TradeFrom4) && (iHour <=(TradeUntil4-1))))
{
return (true);
}
else
return (false);
}
//+------------------------------------------------------------------+
//| END Function Valid Trade Time |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| START Check Close Trade After x Hours |
//+------------------------------------------------------------------+
void CheckCloseAfterHours()
{
int total = OrdersTotal();
for(int cnt=0;cnt<total;cnt++)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
if(OrderType()<=OP_SELL &&
OrderSymbol()==Symbol() &&
OrderMagicNumber()==MAGICMA_A)
{
if((CurTime()-OrderOpenTime())>(CloseAfterHours*3600) && OrderProfit()<0)
{
OrderClose(OrderTicket(),OrderLots(),Bid,10,Violet);
}
}
}
}
//+------------------------------------------------------------------+
//| END Check Close Trade After x Hours |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| START Function Check Signals |
//+------------------------------------------------------------------+
//=====================SIGNAL1========================
int CheckSignal(int Signal)
{
Signal=0;
bool BuySignal1=false, SellSignal1=false;
double HighEnvelope1 = iEnvelopes(NULL,0,EnvelopePeriod,MODE_SMA,0,PRICE_CLOSE,Percent,MODE_UPPER,1);
double LowEnvelope1 = iEnvelopes(NULL,0,EnvelopePeriod,MODE_SMA,0,PRICE_CLOSE,Percent,MODE_LOWER,1);
double CloseBar1 = iClose(NULL,0,1);
if(UseSignal1)
{
if(CloseBar1 > HighEnvelope1) {SellSignal1 = true;}
if(CloseBar1 < LowEnvelope1) {BuySignal1 = true;}
}
else {SellSignal1=true;BuySignal1=true;}
//=====================SIGNAL2========================
bool BuySignal2=false, SellSignal2=false;
double SMA1=iMA(NULL,0,SMAPeriod,0,MODE_SMA,PRICE_CLOSE,1);
double SMA2=iMA(NULL,0,SMAPeriod,0,MODE_SMA,PRICE_CLOSE,SMA2Bars);
if(UseSignal2)
{
if(SMA2-SMA1>0) {BuySignal2 = true;}
if(SMA2-SMA1<0) {SellSignal2 = true;}
}
else {SellSignal2=true;BuySignal2=true;}
//=====================SIGNAL3========================
bool BuySignal3=false, SellSignal3=false;
double OsMABar2=iOsMA(NULL,0,OSMASlow,OSMAFast,OSMASignal,PRICE_CLOSE,2);
double OsMABar1=iOsMA(NULL,0,OSMASlow,OSMAFast,OSMASignal,PRICE_CLOSE,1);
if(UseSignal3)
{
if(OsMABar2 > OsMABar1) {SellSignal3 = true;}
if(OsMABar2 < OsMABar1) {BuySignal3 = true;}
}
else {SellSignal3=true;BuySignal3=true;}
//=====================SIGNAL4========================
double diverge;
bool BuySignal4=false,SellSignal4=false;
diverge = divergence(Fast_Period, Slow_Period, Fast_Price, Slow_Price,0);
if(UseSignal4)
{
if(diverge >= DVBuySell && diverge <= DVStayOut)
{BuySignal4 = true;}
if(diverge <= (DVBuySell*(-1)) && diverge >= (DVStayOut*(-1)))
{SellSignal4 = true;}
}
else {SellSignal4=true;BuySignal4=true;}
//=====================SIGNAL5=======================
bool BuySignal5=false, SellSignal5=false;
if(UseSignal5)
{
int iHour=TimeHour(LocalTime());
int ValidTradeTime = F_ValidTradeTime(iHour);
if(ValidTradeTime==true)
{
BuySignal5=true;
SellSignal5=true;
}
}
else {SellSignal5=true;BuySignal5=true;}
if((SellSignal1==true) && (SellSignal2==true) && (SellSignal3==true) && (SellSignal4==true) && (SellSignal5==true)) return(1);
if((BuySignal1==true) && (BuySignal2==true) && (BuySignal3==true) && (BuySignal4==true) && (BuySignal5==true)) return(2);
}
//+------------------------------------------------------------------+
//| END Function Check Signals |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| START Calculate optimal lot size |
//+------------------------------------------------------------------+
double LotsOptimized()
{
if(MM==false) return(Lots);
double lot=Lots;
int orders=HistoryTotal();
int losses=0;
int decimalPlaces=1;
if(AccountIsMicro==true) decimalPlaces=2;
lot=NormalizeDouble(AccountFreeMargin()*MaximumRisk/1000.0,decimalPlaces);
if(DecreaseFactor>0)
{
for(int i=orders-1;i>=0;i--)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY)==false) { Print("Error in history!"); break; }
if(OrderSymbol()!=Symbol() || OrderType()>OP_SELL) continue;
//----
if(OrderProfit()>0) break;
if(OrderProfit()<0) losses++;
}
if(losses>1) lot=NormalizeDouble(lot-lot*losses/DecreaseFactor,decimalPlaces);
}
if(lot<0.1 && AccountIsMicro==false) lot=0.1;
if(lot<0.01 && AccountIsMicro==true) lot=0.01;
if(lot>99) lot=99;
return(lot);
}
//+------------------------------------------------------------------+
//| END Calculate optimal lot size |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| START Function Check TrailingStop |
//+------------------------------------------------------------------+
void CheckTrailingStop()
{
for(int i=0;i<OrdersTotal();i++)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) break;
if(OrderMagicNumber()!=MAGICMA_A || OrderSymbol()!=Symbol()) continue;
if(OrderType() == OP_BUY)
{
if(((Bid - OrderOpenPrice()) > (Poin * TrailingStop)) && (OrderStopLoss() < (Bid - Poin * TrailingStop)))
OrderModify(
OrderTicket(),
OrderOpenPrice(),
Bid - Poin * TrailingStop,
OrderTakeProfit(),
0,
GreenYellow);
}
if(OrderType() == OP_SELL)
{
if(((OrderOpenPrice() - Ask) > (Poin * TrailingStop)) && (OrderStopLoss() > (Ask + Poin * TrailingStop)))
OrderModify(
OrderTicket(),
OrderOpenPrice(),
Ask + Poin * TrailingStop,
OrderTakeProfit(),
0,
Red);
}
}
}
//+------------------------------------------------------------------+
//| END Function Check TrailingStop |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| START Function Check BreakEven |
//+------------------------------------------------------------------+
void CheckBreakEven()
{
for(int i=0;i<OrdersTotal();i++)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) break;
if(OrderMagicNumber()!=MAGICMA_A || OrderSymbol()!=Symbol()) continue;
if(OrderType() == OP_BUY)
{
if((Bid-OrderOpenPrice()) > (Poin*BreakEvenAfterPips))
OrderModify(
OrderTicket(),
OrderOpenPrice(),
OrderOpenPrice(),
OrderTakeProfit(),
0,
GreenYellow);
}
if(OrderType() == OP_SELL)
{
if((OrderOpenPrice()-Ask) > (Poin*BreakEvenAfterPips))
OrderModify(
OrderTicket(),
OrderOpenPrice(),
OrderOpenPrice(),
OrderTakeProfit(),
0,
Red);
}
}
}
//+------------------------------------------------------------------+
//| END Function Check BreakEven |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| START Function Close First Trade |
//+------------------------------------------------------------------+
int CloseFirstTrade()
{
for(int i=0;i<OrdersTotal();i++)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) break;
if(OrderMagicNumber()!=MAGICMA_A || OrderSymbol()!=Symbol()) continue;
OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet);
return(0);
}
}
//+------------------------------------------------------------------+
//| END Function Close First Trade |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| START Function Calculate Current Orders Mode 3 |
//+------------------------------------------------------------------+
int Mode3CalculateCurrentOrders(string symbol)
{
int buys=0,sells=0;
for(int i=0;i<OrdersTotal();i++)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) break;
if(
(OrderSymbol()==Symbol()) &&
((OrderMagicNumber()==MAGICMA01) ||
(OrderMagicNumber()==MAGICMA02) ||
(OrderMagicNumber()==MAGICMA03)))
{
if(OrderType()==OP_BUY) buys++;
if(OrderType()==OP_SELL) sells++;
}
}
return(buys+sells);
}
//+------------------------------------------------------------------+
//| STOP Function Calculate Current Orders Mode 3 |
//+------------------------------------------------------------------+
