EA MFI_R2-v21

EA MFI_R2-v21 最新版

官方版 无广告 93

更新日期:2022-03-03 分类标签: 语言:中文 平台:没限制

11 人已下载 手机查看

//+------------------------------------------------------------------+
//| EA MFI_R2-v21.mq4 |
//| Copyright 2019, MetaQuotes Software Corp. |
//| https://www.mql5.com |
//+------------------------------------------------------------------+

#property version " "
#property strict

#include <stdlib.mqh>

// This makes code easier to read

#define AUDCAD 1
#define AUDJPY 2
#define AUDNZD 3
#define AUDUSD 4
#define CHFJPY 5
#define EURAUD 6
#define EURCAD 7
#define EURCHF 8
#define EURGBP 9
#define EURJPY 10
#define EURUSD 11
#define GBPCHF 12
#define GBPJPY 13
#define GBPUSD 14
#define NZDJPY 15
#define NZDUSD 16
#define USDCAD 17
#define USDCHF 18
#define USDJPY 19
#define UNEXPECTED 999

extern string Expert_Name = "---- EA MFI_R2_v21 ----";

//+---------------------------------------------------+
//|Money Management |
//+---------------------------------------------------+

extern double LotSize=0.1;
extern double RiskPercent=2.0;
extern bool UseMoneyMgmt=false;
extern bool BrokerPermitsFractionalLots = true;

//+---------------------------------------------------+
//|Indicator Variables |
//| Change these to try your own system |
//| or add more if you like |
//+---------------------------------------------------+

extern string mi="--Moving Average settings--";
extern int MaTrend_Period = 200;

extern string ri="--MFI settings--";
extern int MFI_Period = 5; // input value to be optimized
extern bool UseDefaultMFI_Period = true;
extern int BuyWhenMFIBelow = 65;
extern int SellWhenMFIAbove = 35;
extern double MFI_Overbought_Value = 75.0;
extern double MFI_Oversold_Value = 25.0;

// Added to test confirmation of trend

extern int useMFI4BarsBack = 0;
extern int BuyWhenAbove = 55;
extern int SellWhenBelow = 45;

// Added to test new exit strategy

extern int useNewExitStrategy = 0;
extern int MFI_High_OverBought_Exit = 98;
extern int MFI_Low_OverSold_Exit = 2;

// Added Blutos newest exit using Price close vs SMA 200

extern int use200SMA_Exit = 1;
extern int useMFI14_Exit = 1;
extern int MFI_Exit_Period = 14;
extern int useCCI50_Exit = 0;
extern int CCI_ExitLevel = 0;

extern string st1="--Signal_TimeFrame--";
extern int Signal_TimeFrame = 0;

extern string hd = " --Limit 1 trade per day --";
extern int useDelay = 1;

// Added this for possible filter for flat markets

extern string ai="--Moving Average Angle filter settings--";
extern string a2=" Set switch to 1 to use filter";
extern int useMaAngleFilter = 0;
extern int TrendTimeFrame = 0;
extern double Threshold=20;
extern int PrevShift=3;
extern int CurShift=1;

//+---------------------------------------------------+
//|Profit controls |
//+---------------------------------------------------+

extern string st6 = "--Profit Controls--";
extern double StopLoss=0;
extern double TakeProfit=700;
extern int Slippage=3;

extern string tsp0 = "--Trailing Stop Types--";
extern string tsp1 = " 1 = Trail immediately";
extern string tsp2 = " 2 = Wait to trail";
extern string tsp3 = " 3 = Uses 3 levels before trail";
extern string tsp4 = " 4 = Breakeven + Lockin";
extern string tsp5 = " 5 = Step trail";
extern string tsp6 = " 6 = EMA trail";
extern string tsp7 = " 7 = pSAR trail";
extern string tsp8 = " 8 = Blutos pSar trail";
extern bool UseTrailingStop = true;
extern int TrailingStopType = 8;

extern string ts2 = "Settings for Type 2";
extern double TrailingStop = 15; // Change to whatever number of pips you wish to trail your position with.

extern string ts3 = "Settings for Type 3";
extern double FirstMove = 20; // Type 3 first level pip gain
extern double FirstStopLoss = 50; // Move Stop to Breakeven
extern double SecondMove = 30; // Type 3 second level pip gain
extern double SecondStopLoss = 30; // Move stop to lock is profit
extern double ThirdMove = 40; // type 3 third level pip gain
extern double TrailingStop3 = 20; // Move stop and trail from there

extern string ts4 = "Settings for Type 4";
extern double BreakEven = 30;
extern int LockInPips = 1; // Profit Lock in pips

extern string ts5 = "Settings for Type 5";
extern int eTrailingStop = 10;
extern int eTrailingStep = 2;

extern string ts6 = "Settings for Type 6";
extern int EMATimeFrame = 30;
extern int Price = 0;
extern int EMAPeriod = 13;
extern int EMAShift = 2;
extern int InitialStop = 0;

extern string ts7 = "Settings for Type 7";
extern string pi="--pSAR settings--";
extern double StepParabolic = 0.02;
extern double MaxParabolic = 0.2;
extern int Interval = 5;

extern string ts8 = "Settings for Type 8";
extern string pi2="--pSAR settings--";
extern double SarStep = 0.02;
extern double SarMax = 0.20;
bool dummyResult;

//+---------------------------------------------------+
//|General controls |
//+---------------------------------------------------+

int MagicNumber=0;
string setup;
int SignalCandle = 1;
int TradesInThisSymbol = 0;
double MM_OrderLotSize=0;
datetime StopTime; // Time to wait after a trade is stopped out
bool StoppedOut=false;

//+---------------------------------------------------+
//| Indicator values for signals and filters |
//| Add or Change to test your system |
//+---------------------------------------------------+

int myMFI_Period = 2; // Used by MFI indicator call
double MFI_Day_0 = 0, MFI_Day_1=0, MFI_Day_2=0, MFI_Day_3=0, SMA_Day3=0;

 

int init()
{
/*
if (Symbol()=="AUDCADm" || Symbol()=="AUDCAD") {MagicNumber=200001;}
if (Symbol()=="AUDJPYm" || Symbol()=="AUDJPY") {MagicNumber=200002;}
if (Symbol()=="AUDNZDm" || Symbol()=="AUDNZD") {MagicNumber=200003;}
if (Symbol()=="AUDUSDm" || Symbol()=="AUDUSD") {MagicNumber=200004;}
if (Symbol()=="CHFJPYm" || Symbol()=="CHFJPY") {MagicNumber=200005;}
if (Symbol()=="EURAUDm" || Symbol()=="EURAUD") {MagicNumber=200006;}
if (Symbol()=="EURCADm" || Symbol()=="EURCAD") {MagicNumber=200007;}
if (Symbol()=="EURCHFm" || Symbol()=="EURCHF") {MagicNumber=200008;}
if (Symbol()=="EURGBPm" || Symbol()=="EURGBP") {MagicNumber=200009;}
if (Symbol()=="EURJPYm" || Symbol()=="EURJPY") {MagicNumber=200010;}
if (Symbol()=="EURUSDm" || Symbol()=="EURUSD") {MagicNumber=200011;}
if (Symbol()=="GBPCHFm" || Symbol()=="GBPCHF") {MagicNumber=200012;}
if (Symbol()=="GBPJPYm" || Symbol()=="GBPJPY") {MagicNumber=200013;}
if (Symbol()=="GBPUSDm" || Symbol()=="GBPUSD") {MagicNumber=200014;}
if (Symbol()=="NZDJPYm" || Symbol()=="NZDJPY") {MagicNumber=200015;}
if (Symbol()=="NZDUSDm" || Symbol()=="NZDUSD") {MagicNumber=200016;}
if (Symbol()=="USDCHFm" || Symbol()=="USDCHF") {MagicNumber=200017;}
if (Symbol()=="USDJPYm" || Symbol()=="USDJPY") {MagicNumber=200018;}
if (Symbol()=="USDCADm" || Symbol()=="USDCAD") {MagicNumber=200019;}
if (MagicNumber==0) {MagicNumber = 200999;}
*/

//#################################################################################################################

// MagicNumber = func_Symbol2Val(Symbol()) + 200000;

MagicNumber = 200000 + func_Symbol2Val(Symbol())*100 + func_TimeFrame_Const2Val(Period());
setup=Expert_Name + Symbol() + "_" + func_TimeFrame_Val2String(func_TimeFrame_Const2Val(Period()));
if (UseDefaultMFI_Period) myMFI_Period = MFI_Period; else myMFI_Period = AssignMFI_Period(Symbol());

return(0);
}

int deinit()
{
return(0);
}

 

int AssignMFI_Period(string symbol)
{

int MFI = 0;
int which = func_Symbol2Val(symbol);

switch (which)
{
case AUDCAD : MFI = 5;
break;
case AUDJPY : MFI = 7;
break;
case AUDNZD : MFI = 6;
break;
case AUDUSD : MFI = 4;
break;
case CHFJPY : MFI = 4;
break;
case EURAUD : MFI = 2;
break;
case EURCAD : MFI = 3;
break;
case EURCHF : MFI = 3;
break;
case EURGBP : MFI = 2;
break;
case EURJPY : MFI = 4; // Optimized value
break;
case EURUSD : MFI = 4;
break;
case GBPCHF : MFI = 6;
break;
case GBPJPY : MFI = 4;
break;
case GBPUSD : MFI = 3;
break;
case NZDJPY : MFI = 6;
break;
case NZDUSD : MFI = 7;
break;
case USDCAD : MFI = 2;
break;
case USDCHF : MFI = 4;
break;
case USDJPY : MFI = 4;
break;
case UNEXPECTED : MFI = 4;
}
if (MFI == 0) MFI = 4;
return (MFI);
}

//+------------------------------------------------------------------+
//| LastTradeStoppedOut |
//| Check History to see if last trade stopped out |
//| Return Time for next trade |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| LastTradeClosedToday |
//| Check History to see if last trade closed today |
//+------------------------------------------------------------------+

bool LastTradeClosedToday()
{
int cnt, total;
bool Closed;

total = HistoryTotal();
for (cnt = total - 1; cnt >= 0; cnt--)
{
dummyResult=OrderSelect (cnt, SELECT_BY_POS, MODE_HISTORY);

if(OrderSymbol()!=Symbol()) continue;
if (OrderMagicNumber() != MagicNumber) continue;

Closed = false;
if (OrderType() == OP_BUY)
{
if (TimeDay(OrderCloseTime()) == TimeDay(TimeCurrent()))
{
Closed = true;
}
cnt = 0;
}
if (OrderType() == OP_SELL)
{
if (TimeDay(OrderCloseTime()) == TimeDay(TimeCurrent()))
{
Closed = true;
}
cnt = 0;
}

}

return (Closed);
}

//===================================================================
// EMA_Angle.mq4
// jpkfox
//
// You can use this indicator to measure when the EMA angle is
// "near zero". AngleTreshold determines when the angle for the
// EMA is "about zero": This is when the value is between
// [-AngleTreshold, AngleTreshold] (or when the histogram is red).
// EMAPeriod: EMA period
// AngleTreshold: The angle value is "about zero" when it is
// between the values [-AngleTreshold, AngleTreshold].
// StartEMAShift: The starting point to calculate the
// angle. This is a shift value to the left from the
// observation point. Should be StartEMAShift > EndEMAShift.
// StartEMAShift: The ending point to calculate the
// angle. This is a shift value to the left from the
// observation point. Should be StartEMAShift > EndEMAShift.
//
// Return 1 for up OK
// Return -1 for down OK
// Return 0 for too flat
//===================================================================

double MA_Angle( int iPrevShift, int iCurShift, double fPrevMA, double fCurMA)
{
double fAngle, mFactor;
string Sym;
int ShiftDif;

mFactor = 100000.0;
Sym = StringSubstr(Symbol(),3,3);
if (Sym == "JPY") mFactor = 1000.0;
ShiftDif = iPrevShift-iCurShift;
mFactor /= ShiftDif;

fAngle = mFactor * (fCurMA - fPrevMA)/2.0;

return(fAngle);
}

bool CheckTrend(int cmd)
{
double maAngle;

double MACurrent=iMA(Symbol(),TrendTimeFrame,MaTrend_Period, 0, MODE_SMA, PRICE_CLOSE,CurShift);
double MAPrevious=iMA(Symbol(),TrendTimeFrame,MaTrend_Period, 0, MODE_SMA, PRICE_CLOSE,PrevShift);
maAngle = MA_Angle(PrevShift, CurShift, MAPrevious, MACurrent);
switch (cmd)
{
case OP_BUY : if (maAngle > Threshold) return(true);
break;
case OP_SELL : if (maAngle < -Threshold) return(true);
}
return(false);
}

bool CheckMFI14(int cmd)
{

double MFIcur, MFIprev;

MFIcur = iMFI(Symbol(),Signal_TimeFrame, MFI_Exit_Period, 1);
MFIprev = iMFI(Symbol(),Signal_TimeFrame, MFI_Exit_Period, 2);

switch (cmd)
{
case OP_BUY : if (MFIcur < 50 && MFIprev > 50) return(true);
break;
case OP_SELL : if (MFIcur > 50 && MFIprev < 50) return(true);
}

return(false);

}

bool CheckCCI50(int cmd)
{
double CCIcur, CCIprev;

CCIcur = iCCI(Symbol(), Signal_TimeFrame, 50, PRICE_CLOSE, 1);
CCIprev = iCCI(Symbol(), Signal_TimeFrame, 50, PRICE_CLOSE, 2);

switch (cmd)
{
case OP_BUY : if (CCIcur < 0 && CCIprev > 0) return(true);
break;
case OP_SELL : if (CCIcur > 0 && CCIprev < 0) return(true);
}

return(false);

}

//+------------------------------------------------------------------+
//| CheckExitCondition |
//| Uses OP_BUY as cmd to check exit sell |
//| Uses OP_SELL as cmd to check exit buy |
//| New exit strategy checks current MFI value for high or low |
//| threshold and for current still less than overbought value |
//| or greater than oversold value. |
//+------------------------------------------------------------------+
bool CheckExitCondition(int cmd)
{
double MFI, MFI_Cur;

MFI = iMFI(Symbol(), Signal_TimeFrame, myMFI_Period, 1);
MFI_Cur = iMFI(Symbol(), Signal_TimeFrame, myMFI_Period, 0);

switch (cmd)
{
case OP_BUY : if (useMFI14_Exit == 1) return (CheckMFI14(cmd));
if (useCCI50_Exit == 1) return(CheckCCI50(cmd));

// Original Exit Strategies

if ( MFI > MFI_Overbought_Value)
{
if (useNewExitStrategy == 1)
{
if (MFI_Cur < MFI_Overbought_Value || MFI_Cur >= MFI_High_OverBought_Exit ) return(true); else return(false);
}
else
return(true);
}
else if (use200SMA_Exit == 1)
{
if (CheckMA(OP_SELL)) return(true);
}
break;
case OP_SELL : if (useMFI14_Exit == 1) return (CheckMFI14(cmd));
if (useCCI50_Exit == 1) return(CheckCCI50(cmd));

// Original Exit Strategies

if (MFI < MFI_Oversold_Value)
{
if (useNewExitStrategy == 1)
{
if (MFI_Cur > MFI_Oversold_Value || MFI_Cur <= MFI_Low_OverSold_Exit ) return(true); else return(false);
}
else
return(true);
}
else if (use200SMA_Exit == 1)
{
if (CheckMA(OP_BUY)) return(true);
}
}

return (false);
}

bool CheckMA(int cmd)
{
SMA_Day3 = iMA(Symbol(),Signal_TimeFrame,MaTrend_Period, 0, MODE_SMA, PRICE_CLOSE, 1);
switch (cmd)
{
case OP_BUY : if (iClose(Symbol(),Signal_TimeFrame,1) > SMA_Day3) return(true);
break;
case OP_SELL : if (iClose(Symbol(),Signal_TimeFrame,1) < SMA_Day3) return (true);
}
return(false);
}

// Optional check of 4th bar back above 55 for buy
// or below 45 for sell to confirm trend
bool CheckMFI(int cmd)
{

MFI_Day_0 = iMFI(Symbol(), Signal_TimeFrame, myMFI_Period, 4);
MFI_Day_1 = iMFI(Symbol(), Signal_TimeFrame, myMFI_Period, 3);
MFI_Day_2 = iMFI(Symbol(), Signal_TimeFrame, myMFI_Period, 2);
MFI_Day_3 = iMFI(Symbol(), Signal_TimeFrame, myMFI_Period, 1);

switch (cmd)
{
case OP_BUY : if (MFI_Day_1 < BuyWhenMFIBelow && MFI_Day_2 < MFI_Day_1 && MFI_Day_3 < MFI_Day_2)
{
if (useMFI4BarsBack == 1)
{
if (MFI_Day_0 > BuyWhenAbove) return(true); else return(false);
}
else
return(true);
}
break;

case OP_SELL : if (MFI_Day_1 > SellWhenMFIAbove && MFI_Day_2 > MFI_Day_1 && MFI_Day_3 > MFI_Day_2)
{
if (useMFI4BarsBack == 1)
{
if (MFI_Day_0 < SellWhenBelow) return(true); else return(false);
}
else
return(true);
}
}

return(false);
}

//+------------------------------------------------------------------+
//| CheckEntryCondition |
//+------------------------------------------------------------------+
bool CheckEntryCondition(int cmd)
{
bool rule1, rule2, rule3;

rule1 = true;
rule2 = true;
rule3 = true;

rule1 = CheckMA(cmd);
if (rule1)
{
rule2 = CheckMFI(cmd);
if(rule2)
{
if (useMaAngleFilter == 1) rule3 = CheckTrend(cmd);
if (rule3) return(true);
}

}
return (false);
}

int start()
{

//+------------------------------------------------------------------+
//| Check for Open Position |
//+------------------------------------------------------------------+

HandleOpenPositions();

// Check if any open positions were not closed

TradesInThisSymbol = CheckOpenPositions();

// Only allow 1 trade per Symbol

if(TradesInThisSymbol > 0) {
return(0);}

// Check if last trade stopped out

if (useDelay == 1)
{
if (LastTradeClosedToday()) return(0);
}

MM_OrderLotSize = GetLots();

if(CheckEntryCondition(OP_BUY))
{
OpenBuyOrder(MM_OrderLotSize, StopLoss,TakeProfit, Slippage, setup, MagicNumber, Green);
return(0);
}

if(CheckEntryCondition(OP_SELL))
{
OpenSellOrder(MM_OrderLotSize, StopLoss,TakeProfit, Slippage, setup, MagicNumber, Red);
}

return(0);
}

double GetLots()
{
// variables used for money management
double MM_MinLotSize=0;
double MM_MaxLotSize=0;
double MM_LotStep=0;
double MM_Decimals=0;
int MM_AcctLeverage=0;
int MM_CurrencyLotSize=0;

double OrderLotSize;

//----- Money Management & Lot Sizing Stuff.

MM_AcctLeverage = AccountLeverage();
MM_MinLotSize = MarketInfo(Symbol(),MODE_MINLOT);
MM_MaxLotSize = MarketInfo(Symbol(),MODE_MAXLOT);
MM_LotStep = MarketInfo(Symbol(),MODE_LOTSTEP);
MM_CurrencyLotSize = MarketInfo(Symbol(),MODE_LOTSIZE);

if(MM_LotStep == 0.01) {MM_Decimals = 2;}
if(MM_LotStep == 0.1) {MM_Decimals = 1;}

if (UseMoneyMgmt == true)
{
OrderLotSize = AccountEquity() * (RiskPercent * 0.01) / (MM_CurrencyLotSize / MM_AcctLeverage);
if(BrokerPermitsFractionalLots == true)
OrderLotSize = StrToDouble(DoubleToStr(OrderLotSize,MM_Decimals));
else
OrderLotSize = MathRound(MM_OrderLotSize);
}
else
{
OrderLotSize = LotSize;
}

if (OrderLotSize < MM_MinLotSize) {OrderLotSize = MM_MinLotSize;}
if (OrderLotSize > MM_MaxLotSize) {OrderLotSize = MM_MaxLotSize;}
return(OrderLotSize);

}

//+------------------------------------------------------------------+
//| OpenBuyOrder |
//| If Stop Loss or TakeProfit are used the values are calculated |
//| for each trade |
//+------------------------------------------------------------------+
int OpenBuyOrder(double mLots, double mStopLoss, double mTakeProfit, int mSlippage, string mComment, int mMagic, color mColor)
{
int err,ticket, digits;
double myPrice, myBid, myStopLoss = 0, myTakeProfit = 0;

myPrice = MarketInfo(Symbol(), MODE_ASK);
myBid = MarketInfo(Symbol(), MODE_BID);
myStopLoss = StopLong(myBid,mStopLoss);
myTakeProfit = TakeLong(myBid,mTakeProfit);
// Normalize all price / stoploss / takeprofit to the proper # of digits.
digits = MarketInfo(Symbol( ), MODE_DIGITS) ;
if (digits > 0)
{
myPrice = NormalizeDouble( myPrice, digits);
myStopLoss = NormalizeDouble( myStopLoss, digits);
myTakeProfit = NormalizeDouble( myTakeProfit, digits);
}
ticket=OrderSend(Symbol(),OP_BUY,mLots,myPrice,mSlippage,myStopLoss,myTakeProfit,mComment,mMagic,0,mColor);
if (ticket > 0)
{
if (OrderSelect( ticket,SELECT_BY_TICKET, MODE_TRADES) )
{
Print("BUY order opened : ", OrderOpenPrice( ));
// ModifyOrder(ticket,OrderOpenPrice( ), OrderStopLoss(), myTakeProfit);
}
}
else
{
err = GetLastError();
if(err==0)
{
return(ticket);
}
else
{
if(err==4 || err==137 ||err==146 || err==136) //Busy errors
{
Sleep(5000);
}
else //normal error
{
Print("Error opening BUY order [" + setup + "]: (" + err + ") " + ErrorDescription(err));
}
}
}

return(ticket);
}

//+------------------------------------------------------------------+
//| OpenSellOrder |
//| If Stop Loss or TakeProfit are used the values are calculated |
//| for each trade |
//+------------------------------------------------------------------+
void OpenSellOrder(double mLots, double mStopLoss, double mTakeProfit, int mSlippage, string mComment, int mMagic, color mColor)
{
int err, ticket, digits;
double myPrice, myAsk, myStopLoss = 0, myTakeProfit = 0;

myPrice = MarketInfo(Symbol( ), MODE_BID);
myAsk = MarketInfo(Symbol( ), MODE_ASK);
myStopLoss = StopShort(myAsk,mStopLoss);
myTakeProfit = TakeShort(myAsk,mTakeProfit);

// Normalize all price / stoploss / takeprofit to the proper # of digits.
digits = MarketInfo(Symbol( ), MODE_DIGITS) ;
if (digits > 0)
{
myPrice = NormalizeDouble( myPrice, digits);
myStopLoss = NormalizeDouble( myStopLoss, digits);
myTakeProfit = NormalizeDouble( myTakeProfit, digits);
}
ticket=OrderSend(Symbol(),OP_SELL,mLots,myPrice,mSlippage,myStopLoss,myTakeProfit,mComment,mMagic,0,mColor);
if (ticket > 0)
{
if (OrderSelect( ticket,SELECT_BY_TICKET, MODE_TRADES) )
{
Print("Sell order opened : ", OrderOpenPrice());
// ModifyOrder(ticket,OrderOpenPrice( ), OrderStopLoss(), myTakeProfit);
}
}
else
{
err = GetLastError();
if(err==0)
{
return;
}
else
{
if(err==4 || err==137 ||err==146 || err==136) //Busy errors
{
Sleep(5000);
}
else //normal error
{
Print("Error opening Sell order [" + mComment + "]: (" + err + ") " + ErrorDescription(err));
}
}
}

return;
}

double StopLong(double price,int stop)
{
if(stop==0)
return(0);
else
return(price-(stop*Point));
}

double StopShort(double price,int stop)
{
if(stop==0)
return(0);
else
return(price+(stop*Point));
}

double TakeLong(double price,int take)
{
if(take==0)
return(0);
else
return(price+(take*Point));
}

double TakeShort(double price,int take)
{
if(take==0)
return(0);
else
return(price-(take*Point));
}

//+------------------------------------------------------------------+
//| Handle Open Positions |
//| Check if any open positions need to be closed or modified |
//+------------------------------------------------------------------+
int HandleOpenPositions()
{
int cnt;

for(cnt=OrdersTotal()-1;cnt>=0;cnt--)
{
dummyResult=OrderSelect (cnt, SELECT_BY_POS, MODE_TRADES);
if ( OrderSymbol() != Symbol()) continue;
if ( OrderMagicNumber() != MagicNumber) continue;

if(OrderType() == OP_BUY)
{

if (CheckExitCondition(OP_BUY))
{
CloseOrder(OrderTicket(),OrderLots(),OP_BUY);
}
else
{
if (UseTrailingStop)
{
HandleTrailingStop(OP_BUY,OrderTicket(),OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit());
}
}
}

if(OrderType() == OP_SELL)
{
if (CheckExitCondition(OP_SELL))
{
CloseOrder(OrderTicket(),OrderLots(),OP_SELL);
}
else
{
if (UseTrailingStop)
{
HandleTrailingStop(OP_SELL,OrderTicket(),OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit());
}
}
}
}
return(0);
}

//+------------------------------------------------------------------+
//| Check Open Position Controls |
//+------------------------------------------------------------------+

int CheckOpenPositions()
{
int cnt, total;
int NumTrades;

NumTrades = 0;
total=OrdersTotal();
for(cnt=OrdersTotal()-1;cnt>=0;cnt--)
{
dummyResult=OrderSelect (cnt, SELECT_BY_POS, MODE_TRADES);
if ( OrderSymbol() != Symbol()) continue;
if ( OrderMagicNumber() != MagicNumber) continue;

if(OrderType() == OP_BUY ) NumTrades++;
if(OrderType() == OP_SELL ) NumTrades++;

}
return (NumTrades);
}

int CloseOrder(int ticket,double numLots,int cmd)
{
int CloseCnt, err, digits;
double myPrice;

if (cmd == OP_BUY) myPrice = MarketInfo(Symbol( ), MODE_BID);
if (cmd == OP_SELL) myPrice = MarketInfo(Symbol( ), MODE_ASK);
digits = MarketInfo(Symbol( ), MODE_DIGITS) ;
if (digits > 0) myPrice = NormalizeDouble( myPrice, digits);
// try to close 3 Times

CloseCnt = 0;
while (CloseCnt < 3)
{
if (!OrderClose(ticket,numLots,myPrice,Slippage,Violet))
{
err=GetLastError();
Print(CloseCnt," Error closing order : (", err , ") " + ErrorDescription(err));
if (err > 0) CloseCnt++;
}
else
{
CloseCnt = 3;
}
}
return(0);
}

int ModifyOrder(int ord_ticket,double op, double price,double tp, color mColor)
{
int CloseCnt, err;

CloseCnt=0;
while (CloseCnt < 3)
{
if (OrderModify(ord_ticket,op,price,tp,0,mColor))
{
CloseCnt = 3;
}
else
{
err=GetLastError();
Print(CloseCnt," Error modifying order : (", err , ") " + ErrorDescription(err));
if (err>0) CloseCnt++;
}
}
return(0);
}

double ValidStopLoss(int type, double price, double SL)
{

double minstop, pp;
double newSL;

pp = MarketInfo(Symbol(), MODE_POINT);
minstop = MarketInfo(Symbol(),MODE_STOPLEVEL);
newSL = SL;
if (type == OP_BUY)
{
if((price - SL) < minstop*pp) newSL = price - minstop*pp;
}
if (type == OP_SELL)
{
if((SL-price) < minstop*pp) newSL = price + minstop*pp;
}

return(newSL);
}

//+------------------------------------------------------------------+
//| HandleTrailingStop |
//| Type 1 moves the stoploss without delay. |
//| Type 2 waits for price to move the amount of the trailStop |
//| before moving stop loss then moves like type 1 |
//| Type 3 uses up to 3 levels for trailing stop |
//| Level 1 Move stop to 1st level |
//| Level 2 Move stop to 2nd level |
//| Level 3 Trail like type 1 by fixed amount other than 1 |
//| Type 4 Move stop to breakeven + Lockin, no trail |
//| Type 5 uses steps for 1, every step pip move moves stop 1 pip |
//| Type 6 Uses EMA to set trailing stop |
//+------------------------------------------------------------------+
int HandleTrailingStop(int type, int ticket, double op, double os, double tp)
{
switch (TrailingStopType)
{
case 1 : Immediate_TrailingStop (type, ticket, op, os, tp);
break;
case 2 : Delayed_TrailingStop (type, ticket, op, os, tp);
break;
case 3 : ThreeLevel_TrailingStop (type, ticket, op, os, tp);
break;
case 4 : BreakEven_TrailingStop (type, ticket, op, os, tp);
break;
case 5 : eTrailingStop (type, ticket, op, os, tp);
break;
case 6 : EMA_TrailingStop (type, ticket, op, os, tp);
break;
case 7 : pSAR_TrailingStop (type, ticket, op, os, tp);
break;
case 8 : BlutoParabolicSAR (type, ticket, op, os, tp);
break;
}
return(0);
}

//+------------------------------------------------------------------+
//| BreakEvenExpert_v1.mq4 |
//| Copyright © 2006, Forex-TSD.com |
//| Written by IgorAD,[email protected] |
//| http://finance.groups.yahoo.com/group/TrendLaboratory |
//+------------------------------------------------------------------+
void BreakEven_TrailingStop(int type, int ticket, double op, double os, double tp)
{

int digits;
double pBid, pAsk, pp, BuyStop, SellStop;

pp = MarketInfo(Symbol(), MODE_POINT);
digits = MarketInfo(Symbol(), MODE_DIGITS);

if (type==OP_BUY)
{
pBid = MarketInfo(Symbol(), MODE_BID);
if ( pBid-op > pp*BreakEven )
{
BuyStop = op + LockInPips * pp;
if (digits > 0) BuyStop = NormalizeDouble( BuyStop, digits);
BuyStop = ValidStopLoss(OP_BUY,pBid, BuyStop);
if (digits > 0) BuyStop = NormalizeDouble( BuyStop, digits);
if (os < BuyStop) ModifyOrder(ticket,op,BuyStop,tp,LightGreen);
return;
}
}
if (type==OP_SELL)
{
pAsk = MarketInfo(Symbol(), MODE_ASK);
if ( op - pAsk > pp*BreakEven )
{
SellStop = op - LockInPips * pp;
if (digits > 0) SellStop = NormalizeDouble( SellStop, digits);
SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);
if (digits > 0) SellStop = NormalizeDouble( SellStop, digits);
if (os > SellStop) ModifyOrder(ticket,op,SellStop,tp,DarkOrange);
return;
}
}
}

//+------------------------------------------------------------------+
//| e-Trailing.mq4 |
//| Êèì Èãîðü Â. aka KimIV |
//| http://www.kimiv.ru |
//| |
//| 12.09.2005 Àâòîìàòè÷åñêèé Trailing Stop âñåõ îòêðûòûõ ïîçèöèé |
//| Âåøàòü òîëüêî íà îäèí ãðàôèê |
//+------------------------------------------------------------------+
void eTrailingStop(int type, int ticket, double op, double os, double tp)
{

int digits;
double pBid, pAsk, pp, BuyStop, SellStop;

pp = MarketInfo(Symbol(), MODE_POINT);
digits = MarketInfo(Symbol(), MODE_DIGITS) ;
if (type==OP_BUY)
{
pBid = MarketInfo(Symbol(), MODE_BID);
if ((pBid-op)>eTrailingStop*pp)
{
if (os<pBid-(eTrailingStop+eTrailingStep-1)*pp)
{
BuyStop = pBid-eTrailingStop*pp;
if (digits > 0) BuyStop = NormalizeDouble( BuyStop, digits);
BuyStop = ValidStopLoss(OP_BUY, pBid, BuyStop);
if (digits > 0) BuyStop = NormalizeDouble( BuyStop, digits);
ModifyOrder(ticket,op,BuyStop,tp,LightGreen);
return;
}
}
}
if (type==OP_SELL)
{
pAsk = MarketInfo(Symbol(), MODE_ASK);
if (op - pAsk > eTrailingStop*pp)
{
if (os > pAsk + (eTrailingStop + eTrailingStep-1)*pp || os==0)
{
SellStop = pAsk + eTrailingStop * pp;
if (digits > 0) SellStop = NormalizeDouble( SellStop, digits);
SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);
if (digits > 0) SellStop = NormalizeDouble( SellStop, digits);
ModifyOrder(ticket,op,SellStop,tp,DarkOrange);
return;
}
}
}
}

//+------------------------------------------------------------------+
//| EMATrailingStop_v1.mq4 |
//| Copyright © 2006, Forex-TSD.com |
//| Written by IgorAD,[email protected] |
//| http://finance.groups.yahoo.com/group/TrendLaboratory |
//+------------------------------------------------------------------+
void EMA_TrailingStop(int type, int ticket, double op, double os, double tp)
{
int digits;
double pBid, pAsk, pp, BuyStop, SellStop, ema;

pp = MarketInfo(Symbol(), MODE_POINT);
digits = MarketInfo(Symbol(), MODE_DIGITS) ;
ema = iMA(Symbol(),EMATimeFrame,EMAPeriod,0,MODE_EMA,Price,EMAShift);

if (type==OP_BUY)
{
BuyStop = ema;
pBid = MarketInfo(Symbol(),MODE_BID);
if(os == 0 && InitialStop>0 ) BuyStop = pBid-InitialStop*pp;
if (digits > 0) BuyStop = NormalizeDouble(SellStop, digits);
BuyStop = ValidStopLoss(OP_BUY, pBid, BuyStop);
if (digits > 0) BuyStop = NormalizeDouble(BuyStop, digits);
Print("MA=",ema," BuyStop=",BuyStop);
if ((op <= BuyStop && BuyStop > os) || os==0)
{
ModifyOrder(ticket,op,BuyStop,tp,LightGreen);
return;
}
}

if (type==OP_SELL)
{
SellStop = ema;
pAsk = MarketInfo(Symbol(),MODE_ASK);
if (os==0 && InitialStop > 0) SellStop = pAsk+InitialStop*pp;
if (digits > 0) SellStop = NormalizeDouble(SellStop, digits);
SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);
if (digits > 0) SellStop = NormalizeDouble(SellStop, digits);
Print("MA=",ema," SellStop=",SellStop);
if( (op >= SellStop && os > SellStop) || os==0)
{
ModifyOrder(ticket,op,SellStop,tp,DarkOrange);
return;
}
}
}

//+------------------------------------------------------------------+
//| b-TrailingSAR.mqh |
//| Êèì Èãîðü Â. aka KimIV |
//| http://www.kimiv.ru |
//| |
//| 21.11.2005 Áèáëèîòåêà ôóíêöèé òðàëà ïî ïàðàáîëèêó. |
//| Äëÿ èñïîëüçîâàíèÿ äîáàâèòü ñòðîêó â ìîäóëå start |
//| if (UseTrailing) TrailingPositions(); |
//+------------------------------------------------------------------+
void pSAR_TrailingStop(int type, int ticket, double op, double os, double tp)
{
int digits;
double pBid, pAsk, pp, BuyStop, SellStop, spr;
double sar1, sar2;

pp = MarketInfo(Symbol(), MODE_POINT);
digits = MarketInfo(Symbol(), MODE_DIGITS) ;
pBid = MarketInfo(Symbol(), MODE_BID);
pAsk = MarketInfo(Symbol(), MODE_ASK);
sar1=iSAR(NULL, 0, StepParabolic, MaxParabolic, 1);
sar2=iSAR(NULL, 0, StepParabolic, MaxParabolic, 2);
spr = pAsk - pBid;
if (digits > 0) spr = NormalizeDouble(spr, digits);

if (type==OP_BUY)
{
pBid = MarketInfo(Symbol(), MODE_BID);
if (sar2 < sar1)
{
BuyStop = sar1-Interval*pp;
if (digits > 0) BuyStop = NormalizeDouble(BuyStop, digits);
BuyStop = ValidStopLoss(OP_BUY, pBid, BuyStop);
if (digits > 0) BuyStop = NormalizeDouble(BuyStop, digits);
if (os<BuyStop) ModifyOrder(ticket,op,BuyStop,tp,LightGreen);
}
}
if (type==OP_SELL)
{
if (sar2 > sar1)
{
SellStop = sar1 + Interval * pp + spr;
if (digits > 0) SellStop = NormalizeDouble(SellStop, digits);
SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);
if (digits > 0) SellStop = NormalizeDouble(SellStop, digits);
if (os>SellStop || os==0) ModifyOrder(ticket,op,SellStop,tp,DarkOrange);
}
}
}

// Manage Paraolic SAR
void BlutoParabolicSAR(int type, int ticket, double op, double os, double tp)
{
double pSar1 = 0, pSar2 = 0;
int digits;
double pBid, pAsk, pp;

pp = MarketInfo(Symbol(), MODE_POINT);
digits = MarketInfo(Symbol( ), MODE_DIGITS);

// Added pSar1 and pSar2 for faster backtesting
pSar1 = iSAR(NULL,Signal_TimeFrame,SarStep,SarMax,1);
pSar2 = iSAR(NULL,Signal_TimeFrame,SarStep,SarMax,2);

if (type == OP_BUY)
{
pBid = MarketInfo(Symbol(), MODE_BID);
if ( (pSar1> os) && (pBid > pSar1) && (op < pSar1) && (pSar1 > pSar2))
{
if (digits > 0)pSar1 = NormalizeDouble(pSar1, digits);
ModifyOrder(ticket,op,pSar1,tp,Blue);
Print("Order # ",ticket," updated at ",Hour(),":",Minute(),":",Seconds());
return;
}
}
if (type == OP_SELL)
{
pAsk = MarketInfo(Symbol(), MODE_ASK);
if ((pSar1 < os) && (pAsk < pSar1) && (op > pSar1) && (pSar1 < pSar2))
{
ModifyOrder(ticket,op,pSar1,tp,Blue);
Print("Order # ",ticket," updated at ",Hour(),":",Minute(),":",Seconds());
return;
}
}
}

//+------------------------------------------------------------------+
//| ThreeLevel_TrailingStop.mq4 |
//| Copyright © 2006, Forex-TSD.com |
//| Written by MrPip,[email protected] |
//| |
//| Uses up to 3 levels for trailing stop |
//| Level 1 Move stop to 1st level |
//| Level 2 Move stop to 2nd level |
//| Level 3 Trail like type 1 by fixed amount other than 1 |
//+------------------------------------------------------------------+
void ThreeLevel_TrailingStop(int type, int ticket, double op, double os, double tp)
{

int digits;
double pBid, pAsk, pp, BuyStop, SellStop;

pp = MarketInfo(Symbol(), MODE_POINT);
digits = MarketInfo(Symbol(), MODE_DIGITS) ;

if (type == OP_BUY)
{
pBid = MarketInfo(Symbol(), MODE_BID);
if (pBid - op > FirstMove * pp)
{
BuyStop = op + FirstMove*pp - FirstStopLoss * pp;
if (digits > 0) BuyStop = NormalizeDouble(BuyStop, digits);
BuyStop = ValidStopLoss(OP_BUY, pBid, BuyStop);
if (digits > 0) BuyStop = NormalizeDouble(BuyStop, digits);
if (os < BuyStop) ModifyOrder(ticket,op,BuyStop,tp,LightGreen);
}

if (pBid - op > SecondMove * pp)
{
BuyStop = op + SecondMove*pp - SecondStopLoss * pp;
if (digits > 0) BuyStop = NormalizeDouble(BuyStop, digits);
BuyStop = ValidStopLoss(OP_BUY, pBid, BuyStop);
if (digits > 0) BuyStop = NormalizeDouble(BuyStop, digits);
if (os < BuyStop) ModifyOrder(ticket,op,BuyStop,tp,LightGreen);
}

if (pBid - op > ThirdMove * pp)
{
BuyStop = pBid - ThirdMove*pp;
if (digits > 0) BuyStop = NormalizeDouble(BuyStop, digits);
BuyStop = ValidStopLoss(OP_BUY, pBid, BuyStop);
if (digits > 0) BuyStop = NormalizeDouble(BuyStop, digits);
if (os < BuyStop) ModifyOrder(ticket,op,BuyStop,tp,LightGreen);
}
}

if (type == OP_SELL)
{
pAsk = MarketInfo(Symbol(), MODE_ASK);
if (op - pAsk > FirstMove * pp)
{
SellStop = op - FirstMove * pp + FirstStopLoss * pp;
if (digits > 0) SellStop = NormalizeDouble(SellStop, digits);
SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);
if (digits > 0) SellStop = NormalizeDouble(SellStop, digits);
if (os > SellStop) ModifyOrder(ticket,op,SellStop,tp,DarkOrange);
}
if (op - pAsk > SecondMove * pp)
{
SellStop = op - SecondMove * pp + SecondStopLoss * pp;
if (digits > 0) SellStop = NormalizeDouble(SellStop, digits);
SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);
if (digits > 0) SellStop = NormalizeDouble(SellStop, digits);
if (os > SellStop) ModifyOrder(ticket,op,SellStop,tp,DarkOrange);
}
if (op - pAsk > ThirdMove * pp)
{
SellStop = pAsk + ThirdMove * pp;
if (digits > 0) SellStop = NormalizeDouble(SellStop, digits);
SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);
if (digits > 0) SellStop = NormalizeDouble(SellStop, digits);
if (os > SellStop) ModifyOrder(ticket,op,SellStop,tp,DarkOrange);
}
}

}

//+------------------------------------------------------------------+
//| Immediate_TrailingStop.mq4 |
//| Copyright © 2006, Forex-TSD.com |
//| Written by MrPip,[email protected] |
//| |
//| Moves the stoploss without delay. |
//+------------------------------------------------------------------+
void Immediate_TrailingStop(int type, int ticket, double op, double os, double tp)
{

int digits;
double pt, pBid, pAsk, pp, BuyStop, SellStop;

pp = MarketInfo(Symbol(), MODE_POINT);
digits = MarketInfo(Symbol( ), MODE_DIGITS);

if (type==OP_BUY)
{
pBid = MarketInfo(Symbol(), MODE_BID);
pt = StopLoss * pp;
if(pBid-os > pt)
{
BuyStop = pBid - pt;
if (digits > 0) BuyStop = NormalizeDouble( BuyStop, digits);
BuyStop = ValidStopLoss(OP_BUY,pBid, BuyStop);
if (digits > 0) BuyStop = NormalizeDouble( BuyStop, digits);
if (os < BuyStop) ModifyOrder(ticket,op,BuyStop,tp,LightGreen);
return;
}
}
if (type==OP_SELL)
{
pAsk = MarketInfo(Symbol(), MODE_ASK);
pt = StopLoss * pp;
if(os - pAsk > pt)
{
SellStop = pAsk + pt;
if (digits > 0) SellStop = NormalizeDouble( SellStop, digits);
SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);
if (digits > 0) SellStop = NormalizeDouble( SellStop, digits);
if (os > SellStop) ModifyOrder(ticket,op,SellStop,tp,DarkOrange);
return;
}
}
}

//+------------------------------------------------------------------+
//| Delayed_TrailingStop.mq4 |
//| Copyright © 2006, Forex-TSD.com |
//| Written by MrPip,[email protected] |
//| |
//| Waits for price to move the amount of the TrailingStop |
//| Moves the stoploss pip for pip after delay. |
//+------------------------------------------------------------------+
void Delayed_TrailingStop(int type, int ticket, double op, double os, double tp)
{
int digits;
double pt, pBid, pAsk, pp, BuyStop, SellStop;

pp = MarketInfo(Symbol(), MODE_POINT);
pt = TrailingStop * pp;
digits = MarketInfo(Symbol(), MODE_DIGITS);

if (type==OP_BUY)
{
pBid = MarketInfo(Symbol(), MODE_BID);
BuyStop = pBid - pt;
if (digits > 0) BuyStop = NormalizeDouble( BuyStop, digits);
BuyStop = ValidStopLoss(OP_BUY,pBid, BuyStop);
if (digits > 0) BuyStop = NormalizeDouble( BuyStop, digits);
if (pBid-op > pt && os < BuyStop) ModifyOrder(ticket,op,BuyStop,tp,LightGreen);
return;
}
if (type==OP_SELL)
{
pAsk = MarketInfo(Symbol(), MODE_ASK);
pt = TrailingStop * pp;
SellStop = pAsk + pt;
if (digits > 0) SellStop = NormalizeDouble( SellStop, digits);
SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);
if (digits > 0) SellStop = NormalizeDouble( SellStop, digits);
if (op - pAsk > pt && os > SellStop) ModifyOrder(ticket,op,SellStop,tp,DarkOrange);
return;
}
}

int func_Symbol2Val(string symbol)
{
string mySymbol = StringSubstr(symbol,0,6);

if(mySymbol=="AUDCAD") return(1);
if(mySymbol=="AUDJPY") return(2);
if(mySymbol=="AUDNZD") return(3);
if(mySymbol=="AUDUSD") return(4);
if(mySymbol=="CHFJPY") return(5);
if(mySymbol=="EURAUD") return(6);
if(mySymbol=="EURCAD") return(7);
if(mySymbol=="EURCHF") return(8);
if(mySymbol=="EURGBP") return(9);
if(mySymbol=="EURJPY") return(10);
if(mySymbol=="EURUSD") return(11);
if(mySymbol=="GBPCHF") return(12);
if(mySymbol=="GBPJPY") return(13);
if(mySymbol=="GBPUSD") return(14);
if(mySymbol=="NZDJPY") return(15);
if(mySymbol=="NZDUSD") return(16);
if(mySymbol=="USDCAD") return(17);
if(mySymbol=="USDCHF") return(18);
if(mySymbol=="USDJPY") return(19);
Comment("unexpected Symbol");
return(999);
}

//+------------------------------------------------------------------+
//| Time frame interval appropriation function |
//+------------------------------------------------------------------+

int func_TimeFrame_Const2Val(int Constant ) {
switch(Constant) {
case 1: // M1
return(1);
case 5: // M5
return(2);
case 15:
return(3);
case 30:
return(4);
case 60:
return(5);
case 240:
return(6);
case 1440:
return(7);
case 10080:
return(8);
case 43200:
return(9);
}
return(0);
}

//+------------------------------------------------------------------+
//| Time frame string appropriation function |
//+------------------------------------------------------------------+

string func_TimeFrame_Val2String(int Value ) {
switch(Value) {
case 1: // M1
return("PERIOD_M1");
case 2: // M1
return("PERIOD_M5");
case 3:
return("PERIOD_M15");
case 4:
return("PERIOD_M30");
case 5:
return("PERIOD_H1");
case 6:
return("PERIOD_H4");
case 7:
return("PERIOD_D1");
case 8:
return("PERIOD_W1");
case 9:
return("PERIOD_MN1");
default:
return("undefined " + Value);
}
}

 

 

 

 

 

 

 

 

 

 

 

相关资源

暂无评论

暂无评论...