0
0FXTrader0
I would like to start this thread where traders can paste there code (mt4 EA's only) no links or attachments. Below is scalping algo I like to run on a discretionary basis long only or short only.
//+------------------------------------------------------------------+
//| GONNA SCALPING |
//| https://5d3071208c5e2.site123.me/ |
//+------------------------------------------------------------------+
#property copyright "AHARON TZADIK"
#property link "https://5d3071208c5e2.site123.me/"
#property version "1.00"
#property strict
//--------------------------------------------------------------- 2 --
//--------------------------------------------------------------- 3 --
extern bool Exit=FALSE;//Enable Exit strategy
bool USEMOVETOBREAKEVEN=true;//Enable "no loss"
double WHENTOMOVETOBE=30; //When to move break even
double PIPSTOMOVESL=30; //How much pips to move sl
extern double Lots=0.01; //Lots size
extern double IncreaseFactor=0.001; //IncreaseFactor
extern double TrailingStop=40; //TrailingStop
extern double Stop_Loss=200; //Stop Loss
extern int MagicNumber=1234; //MagicNumber
input double Take_Profit=200; //TakeProfit
extern int FastMA=1; //FastMA
extern int SlowMA=5; //SlowMA
extern double Mom_Sell=0.3; //Momentum_Sell
extern double Mom_Buy=0.3; //Momentum_Buy
input bool UseEquityStop = true; //Use Equity Stop
input double TotalEquityRisk = 1.0; //Total Equity Risk
input int Max_Trades=5;
double AccountEquityHighAmt,PrevEquity;
string EAName="R_O_B_O_T "; // EA name , to be displayed on the screen
#define DECISION_BUY 1
#define DECISION_SELL 0
#define DECISION_UNKNOWN -1
int err;
double BidPrev = 0;
double AskPrev = 0;
double CHOCurrent;
double CHOPrevious;
double StopLossIndex = 0;
double TakeProfitIndex = 0;
int ToSell=0;
int ToBuy =0;
int FoundOpenedOrder = false;
int Decision;
int PrevDecision;
//int cnt;
datetime PauseTo;
static datetime Old_Time=0;
double CHOCurrentExit,CHOPreviousExit,RSICurrentExit,RSIPreviousExit;
// Variables to assess the quality of modeling
double pipe;
// Variables for the storage information (data) about the market
double ModeLow;
double ModeHigh;
double ModeTime;
double ModeBid;
double ModeAsk;
double ModePoint;
double ModeDigits;
double ModeSpread;
double ModeStopLevel;
double ModeLotSize;
double ModeTickValue;
double ModeTickSize;
double ModeSwapLong;
double ModeSwapShort;
double ModeStarting;
double ModeExpiration;
double ModeTradeAllowed;
double ModeMinLot;
double ModeLotStep;
// ------ Stochastic Indicator ---
double STOCHCurrent;
double STOCHPrevious;
double STOCHSigCurrent;
double STOCHSigPrevious;
int STOCH_Status;
//------- CCI Indicator -------
double CCICurrent;
double CCIPrevious;
int CCI_Status;
//------- RSI Indicator -------
double RSICurrent;
double RSIPrevious;
int RSI_Status;
int MA_Status;
double ATRCurrent;
double ATRPrevious;
int ATR_Status;
int ROC_Status;
double OSMACurrent;
int CandleStatus;
int OSMA_Status;
int MACDStatus;
int FIBOStatus;
int SR_Status;
//int MACD_Status
double MomentCurrent;
double MomentPrevious;
//------------ PivotPoint --------------
int total=0;
double
Lot,Dmax,Dmin,// Amount of lots in a selected order
Lts, // Amount of lots in an opened order
Min_Lot, // Minimal amount of lots
Step, // Step of lot size change
Free, // Current free margin
One_Lot, // Price of one lot
Price, // Price of a selected order,
pips,
MA_1,MA_2,MACD_SIGNAL;
int Type,freeze_level,Spread;
//--- price levels for orders and positions
double priceopen,stoploss,takeprofit;
//--- ticket of the current order
int orderticket;
//--------------------------------------------------------------- 3 --
int
Period_MA_2, Period_MA_3, // Calculation periods of MA for other timefr.
Period_MA_02, Period_MA_03, // Calculation periods of supp. MAs
K2,K3,T,L;
//---
//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
MA_Status = DECISION_UNKNOWN;
ROC_Status = DECISION_UNKNOWN;
CCI_Status = DECISION_UNKNOWN;
RSI_Status = DECISION_UNKNOWN;
STOCH_Status = DECISION_UNKNOWN;
Decision = DECISION_UNKNOWN;
PrevDecision = DECISION_UNKNOWN;
CandleStatus = DECISION_UNKNOWN;
SR_Status = DECISION_UNKNOWN;
OSMA_Status = DECISION_UNKNOWN;
MACDStatus = DECISION_UNKNOWN;
FIBOStatus = DECISION_UNKNOWN;
//--------------------------------------------------------------- 5 --
//--------------------------------------------------------------- 5 --
switch(Period()) // Calculating coefficient for..
{
// .. different timeframes
case 1:
L=PERIOD_M5;
T=PERIOD_M15;
break;// Timeframe M1
case 5:
L=PERIOD_M1;
T=PERIOD_M15;
break;// Timeframe M5
case 15:
L=PERIOD_M5;
T=PERIOD_M30;
break;// Timeframe M15
case 30:
L=PERIOD_M15;
T=PERIOD_H1;
break;// Timeframe M30
case 60:
L=PERIOD_M30;
T=PERIOD_H4;
break;// Timeframe H1
case 240:
L=PERIOD_H1;
T=PERIOD_D1;
break;// Timeframe H4
case 1440:
L=PERIOD_H4;
T=PERIOD_W1;
break;// Timeframe D1
case 10080:
L=PERIOD_D1;
T=PERIOD_MN1;
break;// Timeframe W1
case 43200:
L=PERIOD_W1;
T=PERIOD_D1;
break;// Timeframe MN
}
double ticksize=MarketInfo(Symbol(),MODE_TICKSIZE);
if(ticksize==0.00001 || ticksize==0.001)
pips=ticksize*10;
else
pips=ticksize;
return(INIT_SUCCEEDED);
//--- distance from the activation price, within which it is not allowed to modify orders and positions
freeze_level=(int)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_FREEZE_LEVEL);
if(freeze_level!=0)
{
PrintFormat("SYMBOL_TRADE_FREEZE_LEVEL=%d: order or position modification is not allowed,"+
" if there are %d points to the activation price",freeze_level,freeze_level);
}
//---
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void OnTick(void)
{
double CurrentPairProfit=CalculateProfit();
Comment(EAName); // Show EA Name on screen
// Check for New Bar (Compatible with both MQL4 and MQL5)
static datetime dtBarCurrent=WRONG_VALUE;
datetime dtBarPrevious=dtBarCurrent;
dtBarCurrent=(datetime) SeriesInfoInteger(_Symbol,_Period,SERIES_LASTBAR_DATE);
bool NewBarFlag=(dtBarCurrent!=dtBarPrevious);
if(NewBarFlag)
{
if(UseEquityStop)
{
if(CurrentPairProfit<0.0 && MathAbs(CurrentPairProfit)>TotalEquityRisk/100.0*AccountEquityHigh())
{
CloseThisSymbolAll();
Print("Closed All due to Stop Out");
}
}
if(Exit)
{
stop();
}
if(USEMOVETOBREAKEVEN)
{MOVETOBREAKEVEN();}
Trail1();
int ticket=0;
// initial data checks
// it is important to make sure that the expert works with a normal
// chart and the user did not make any mistakes setting external
// variables (Lots, StopLoss, TakeProfit,
// TrailingStop) in our case, we check TakeProfit
// on a chart of less than 100 bars
//---
if(Bars<100)
{
Print("bars less than 100");
return;
}
if(Take_Profit<10)
{
Print("TakeProfit less than 10");
return;
}
//--- to simplify the coding and speed up access data are put into internal variables
HideTestIndicators(true);
//+------------------------------------------------------------------+
double MA_1_t=iMA(NULL,L,FastMA,0,MODE_LWMA,PRICE_TYPICAL,0); // МА_1
double MA_2_t=iMA(NULL,L,SlowMA,0,MODE_LWMA,PRICE_TYPICAL,0); // МА_2
//----------------------------------------------------------------------------
double MomLevel=MathAbs(100-iMomentum(NULL,T,14,PRICE_CLOSE,1));
double MomLevel1=MathAbs(100 - iMomentum(NULL,T,14,PRICE_CLOSE,2));
double MomLevel2=MathAbs(100 - iMomentum(NULL,T,14,PRICE_CLOSE,3));
//----------------------------------------------------------------------------
HideTestIndicators(false);
//--------------------------------------------------------------------------------------------------
// if(getOpenOrders()==0)
if(CountTrades()<Max_Trades)
{
//--- no opened orders identified
if(AccountFreeMargin()<(1000*Lots))
{
Print("We have no money. Free Margin = ",AccountFreeMargin());
return;
}
//--- check for long position (BUY) possibility
//+------------------------------------------------------------------+
//| BUY BUY BUY |
//+------------------------------------------------------------------+
if(Trade1()==1)
// if(MA_1_t>MA_2_t)
// if(MomLevel<Mom_Buy || MomLevel1<Mom_Buy || MomLevel2<Mom_Buy)
{
if((CheckVolumeValue(LotsOptimized(Lots)))==TRUE)
if((CheckMoneyForTrade(Symbol(),LotsOptimized(Lots),OP_BUY))==TRUE)
if((CheckStopLoss_Takeprofit(OP_BUY,NDTP(Bid-Stop_Loss*pips),NDTP(Bid+Take_Profit*pips)))==TRUE)
ticket=OrderSend(Symbol(),OP_BUY,LotsOptimized(Lots),ND(Ask),3,NDTP(Bid-Stop_Loss*pips),NDTP(Bid+Take_Profit*pips),"Long 1",MagicNumber,0,PaleGreen);
if(ticket>0)
{
if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES))
Print("BUY order opened : ",OrderOpenPrice());
Alert("we just got a buy signal on the ",_Period,"M",_Symbol);
SendNotification("we just got a buy signal on the1 "+(string)_Period+"M"+_Symbol);
SendMail("Order sent successfully","we just got a buy signal on the1 "+(string)_Period+"M"+_Symbol);
}
else
Print("Error opening BUY order : ",GetLastError());
return;
}
//--- check for short position (SELL) possibility
//+------------------------------------------------------------------+
//| SELL SELL SELL |
//+------------------------------------------------------------------+
if(Trade1()==2)
// if(MA_1_t<MA_2_t)
// if(MomLevel<Mom_Sell || MomLevel1<Mom_Sell || MomLevel2<Mom_Sell)
{
if((CheckVolumeValue(LotsOptimized(Lots)))==TRUE)
if((CheckMoneyForTrade(Symbol(),LotsOptimized(Lots),OP_SELL))==TRUE)
if((CheckStopLoss_Takeprofit(OP_SELL,NDTP(Ask+Stop_Loss*pips),NDTP(Ask-Take_Profit*pips)))==TRUE)
ticket=OrderSend(Symbol(),OP_SELL,LotsOptimized(Lots),ND(Bid),3,NDTP(Ask+Stop_Loss*pips),NDTP(Ask-Take_Profit*pips),"Short 1",MagicNumber,0,Red);
if(ticket>0)
{
if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES))
Print("SELL order opened : ",OrderOpenPrice());
Alert("we just got a sell signal on the ",_Period,"M",_Symbol);
SendMail("Order sent successfully","we just got a sell signal on the "+(string)_Period+"M"+_Symbol);
}
else
Print("Error opening SELL order : ",GetLastError());
}
//--- exit from the "no opened orders" block
return;
}
}
}
//+------------------------------------------------------------------+
//| stop |
//+------------------------------------------------------------------+
//-----------------------------------------------------------------------------+
int stop()
{
total=0;
HideTestIndicators(true);
double MA_1_t=iMA(NULL,L,FastMA,0,MODE_LWMA,PRICE_TYPICAL,0); // МА_1
double MA_2_t=iMA(NULL,L,SlowMA,0,MODE_LWMA,PRICE_TYPICAL,0); // МА_2
//+------------------------------------------------------------------+
double middleBB=iBands(Symbol(),0,20, 2,0,0,MODE_MAIN,1);//middle
double lowerBB=iBands(Symbol(),0,20, 2,0,0,MODE_LOWER,1);//lower
double upperBB=iBands(Symbol(),0,20, 2,0,0,MODE_UPPER,1);//upper
//+------------------------------------------------------------------+
double MacdMAIN=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,1);
double MacdSIGNAL=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,1);
double MacdMAIN0=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,1);
double MacdSIGNAL0=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,1);
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
// DALYN GUPPY MMA
//----------------------------------------------------------------------------
double MA_3=iMA(NULL,L,3,0,MODE_EMA,PRICE_TYPICAL,0); // МА_3 DALYN GUPPY MMA
double MA_5=iMA(NULL,L,5,0,MODE_EMA,PRICE_TYPICAL,0); // МА_5 DALYN GUPPY MMA
double MA_8=iMA(NULL,L,8,0,MODE_EMA,PRICE_TYPICAL,0); // МА_8 DALYN GUPPY MMA
double MA_10=iMA(NULL,L,10,0,MODE_EMA,PRICE_TYPICAL,0); // МА_10 DALYN GUPPY MMA
double MA_12=iMA(NULL,L,12,0,MODE_EMA,PRICE_TYPICAL,0); // МА_12 DALYN GUPPY MMA
double MA_15=iMA(NULL,L,15,0,MODE_EMA,PRICE_TYPICAL,0); // МА_15 DALYN GUPPY MMA
double MA_30=iMA(NULL,L,30,0,MODE_EMA,PRICE_TYPICAL,0); // МА_30 DALYN GUPPY MMA
double MA_35=iMA(NULL,L,35,0,MODE_EMA,PRICE_TYPICAL,0); // МА_35 DALYN GUPPY MMA
double MA_40=iMA(NULL,L,40,0,MODE_EMA,PRICE_TYPICAL,0); // МА_40 DALYN GUPPY MMA
double MA_45=iMA(NULL,L,45,0,MODE_EMA,PRICE_TYPICAL,0); // МА_45 DALYN GUPPY MMA
double MA_50=iMA(NULL,L,50,0,MODE_EMA,PRICE_TYPICAL,0); // МА_50 DALYN GUPPY MMA
double MA_60=iMA(NULL,L,60,0,MODE_EMA,PRICE_TYPICAL,0); // МА_60 DALYN GUPPY MMA
//-----------------------------------------------------------------------------------
HideTestIndicators(false);
for(int trade=OrdersTotal()-1; trade>=0; trade--)
{
if(OrderSelect(trade,SELECT_BY_POS,MODE_TRADES))
{
if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=MagicNumber)
continue;
if(OrderSymbol()==Symbol() || OrderMagicNumber()==MagicNumber)
{
if(OrderType()==OP_BUY)
{
//--- should it be closed?
if(((MA_3==MA_5 && MA_5==MA_8 && MA_8==MA_10 && MA_10==MA_12 && MA_12==MA_15)
||(MA_30==MA_35 && MA_35==MA_40 && MA_40==MA_45 && MA_45==MA_50 && MA_50==MA_60))
||(Close[1]<=lowerBB))
if(!OrderClose(OrderTicket(),OrderLots(),OrderClosePrice(),3,Red))
Print("Did not close");
break;
Print(" CLOSE BY EXIT STRATEGY ");
//--- check for trailing stop
}
else // go to short position
{
//--- should it be closed?
if(((MA_3==MA_5 && MA_5==MA_8 && MA_8==MA_10 && MA_10==MA_12 && MA_12==MA_15)
||(MA_30==MA_35 && MA_35==MA_40 && MA_40==MA_45 && MA_45==MA_50 && MA_50==MA_60))
||(Close[1]<=lowerBB))
if(!OrderClose(OrderTicket(),OrderLots(),OrderClosePrice(),3,Red))
Print("Did not close");
break;
Print(" CLOSE BY EXIT STRATEGY ");
//--- check for trailing stop
}
}
}
}
return(0);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Trailing stop loss |
//+------------------------------------------------------------------+
// --------------- ----------------------------------------------------------- ------------------------
void Trail1()
{
total=OrdersTotal();
//--- it is important to enter the market correctly, but it is more important to exit it correctly...
for(int cnt=0; cnt<total; cnt++)
{
if(!OrderSelect(cnt,SELECT_BY_POS,MODE_TRADES))
continue;
if(OrderMagicNumber()!=MagicNumber)
continue;
if(OrderType()<=OP_SELL && // check for opened position
OrderSymbol()==Symbol()) // check for symbol
{
//--- long position is opened
if(OrderType()==OP_BUY)
{
//--- check for trailing stop
if(TrailingStop>0)
{
if(Bid-OrderOpenPrice()>pips*TrailingStop)
{
if(OrderStopLoss()<Bid-pips*TrailingStop)
{
RefreshRates();
stoploss=Bid-(pips*TrailingStop);
takeprofit=OrderTakeProfit();
double StopLevel=MarketInfo(Symbol(),MODE_STOPLEVEL)+MarketInfo(Symbol(),MODE_SPREAD);
if(stoploss<StopLevel*pips)
stoploss=StopLevel*pips;
string symbol=OrderSymbol();
double point=SymbolInfoDouble(symbol,SYMBOL_POINT);
if(MathAbs(OrderStopLoss()-stoploss)>point)
if((pips*TrailingStop)>(int)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_FREEZE_LEVEL)*pips)
//--- modify order and exit
if(CheckStopLoss_Takeprofit(OP_BUY,stoploss,takeprofit))
if(OrderModifyCheck(OrderTicket(),OrderOpenPrice(),stoploss,takeprofit))
if(!OrderModify(OrderTicket(),OrderOpenPrice(),stoploss,takeprofit,0,Green))
Print("OrderModify error ",GetLastError());
return;
}
}
}
}
else // go to short position
{
//--- check for trailing stop
if(TrailingStop>0)
{
if((OrderOpenPrice()-Ask)>(pips*TrailingStop))
{
if((OrderStopLoss()>(Ask+pips*TrailingStop)) || (OrderStopLoss()==0))
{
RefreshRates();
stoploss=Ask+(pips*TrailingStop);
takeprofit=OrderTakeProfit();
double StopLevel=MarketInfo(Symbol(),MODE_STOPLEVEL)+MarketInfo(Symbol(),MODE_SPREAD);
if(stoploss<StopLevel*pips)
stoploss=StopLevel*pips;
if(takeprofit<StopLevel*pips)
takeprofit=StopLevel*pips;
string symbol=OrderSymbol();
double point=SymbolInfoDouble(symbol,SYMBOL_POINT);
if(MathAbs(OrderStopLoss()-stoploss)>point)
if((pips*TrailingStop)>(int)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_FREEZE_LEVEL)*pips)
//--- modify order and exit
if(CheckStopLoss_Takeprofit(OP_SELL,stoploss,takeprofit))
if(OrderModifyCheck(OrderTicket(),OrderOpenPrice(),stoploss,takeprofit))
if(!OrderModify(OrderTicket(),OrderOpenPrice(),stoploss,takeprofit,0,Red))
Print("OrderModify error ",GetLastError());
return;
}
}
}
}
}
}
}
//+------------------------------------------------------------------+
//+---------------------------------------------------------------------------+
//| MOVE TO BREAK EVEN |
//+---------------------------------------------------------------------------+
void MOVETOBREAKEVEN()
{
for(int b=OrdersTotal()-1; b>=0; b--)
{
if(OrderSelect(b,SELECT_BY_POS,MODE_TRADES))
if(OrderMagicNumber()!=MagicNumber)
continue;
if(OrderSymbol()==Symbol())
if(OrderType()==OP_BUY)
if(Bid-OrderOpenPrice()>WHENTOMOVETOBE*pips)
if(OrderOpenPrice()>OrderStopLoss())
if(CheckStopLoss_Takeprofit(OP_SELL,OrderOpenPrice()+(PIPSTOMOVESL*pips),OrderTakeProfit()))
if(OrderModifyCheck(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()+(PIPSTOMOVESL*pips),OrderTakeProfit()))
if(!OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()+(PIPSTOMOVESL*pips),OrderTakeProfit(),0,CLR_NONE))
Print("eror");
}
for(int s=OrdersTotal()-1; s>=0; s--)
{
if(OrderSelect(s,SELECT_BY_POS,MODE_TRADES))
if(OrderMagicNumber()!=MagicNumber)
continue;
if(OrderSymbol()==Symbol())
if(OrderType()==OP_SELL)
if(OrderOpenPrice()-Ask>WHENTOMOVETOBE*pips)
if(OrderOpenPrice()<OrderStopLoss())
if(CheckStopLoss_Takeprofit(OP_SELL,OrderOpenPrice()-(PIPSTOMOVESL*pips),OrderTakeProfit()))
if(OrderModifyCheck(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()-(PIPSTOMOVESL*pips),OrderTakeProfit()))
if(!OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()-(PIPSTOMOVESL*pips),OrderTakeProfit(),0,CLR_NONE))
Print("eror");
}
}
//+------------------------------------------------------------------+
// NormalizeDouble |
//+------------------------------------------------------------------+
double NDTP(double val)
{
RefreshRates();
double SPREAD=MarketInfo(Symbol(),MODE_SPREAD);
double StopLevel=MarketInfo(Symbol(),MODE_STOPLEVEL);
if(val<StopLevel*pips+SPREAD*pips)
val=StopLevel*pips+SPREAD*pips;
return(NormalizeDouble(val, Digits));
// return(val);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
double ND(double val)
{
return(NormalizeDouble(val, Digits));
}
//+------------------------------------------------------------------+
//| Checking the new values of levels before order modification |
//+------------------------------------------------------------------+
bool OrderModifyCheck(int ticket,double price,double sl,double tp)
{
//--- select order by ticket
if(OrderSelect(ticket,SELECT_BY_TICKET))
{
//--- point size and name of the symbol, for which a pending order was placed
string symbol=OrderSymbol();
double point=SymbolInfoDouble(symbol,SYMBOL_POINT);
//--- check if there are changes in the Open price
bool PriceOpenChanged=true;
int type=OrderType();
if(!(type==OP_BUY || type==OP_SELL))
{
PriceOpenChanged=(MathAbs(OrderOpenPrice()-price)>point);
}
//--- check if there are changes in the StopLoss level
bool StopLossChanged=(MathAbs(OrderStopLoss()-sl)>point);
//--- check if there are changes in the Takeprofit level
bool TakeProfitChanged=(MathAbs(OrderTakeProfit()-tp)>point);
//--- if there are any changes in levels
if(PriceOpenChanged || StopLossChanged || TakeProfitChanged)
return(true); // order can be modified
//--- there are no changes in the Open, StopLoss and Takeprofit levels
else
//--- notify about the error
PrintFormat("Order #%d already has levels of Open=%.5f SL=%.5f TP=%.5f",
ticket,OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit());
}
//--- came to the end, no changes for the order
return(false); // no point in modifying
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
bool CheckStopLoss_Takeprofit(ENUM_ORDER_TYPE type,double SL,double TP)
{
//--- get the SYMBOL_TRADE_STOPS_LEVEL level
int stops_level=(int)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL);
if(stops_level!=0)
{
PrintFormat("SYMBOL_TRADE_STOPS_LEVEL=%d: StopLoss and TakeProfit must"+
" not be nearer than %d points from the closing price",stops_level,stops_level);
}
//---
bool SL_check=false,TP_check=false;
//--- check only two order types
switch(type)
{
//--- Buy operation
case ORDER_TYPE_BUY:
{
//--- check the StopLoss
SL_check=(Bid-SL>stops_level*_Point);
if(!SL_check)
PrintFormat("For order %s StopLoss=%.5f must be less than %.5f"+
" (Bid=%.5f - SYMBOL_TRADE_STOPS_LEVEL=%d points)",
EnumToString(type),SL,Bid-stops_level*_Point,Bid,stops_level);
//--- check the TakeProfit
TP_check=(TP-Bid>stops_level*_Point);
if(!TP_check)
PrintFormat("For order %s TakeProfit=%.5f must be greater than %.5f"+
" (Bid=%.5f + SYMBOL_TRADE_STOPS_LEVEL=%d points)",
EnumToString(type),TP,Bid+stops_level*_Point,Bid,stops_level);
//--- return the result of checking
return(SL_check&&TP_check);
}
//--- Sell operation
case ORDER_TYPE_SELL:
{
//--- check the StopLoss
SL_check=(SL-Ask>stops_level*_Point);
if(!SL_check)
PrintFormat("For order %s StopLoss=%.5f must be greater than %.5f "+
" (Ask=%.5f + SYMBOL_TRADE_STOPS_LEVEL=%d points)",
EnumToString(type),SL,Ask+stops_level*_Point,Ask,stops_level);
//--- check the TakeProfit
TP_check=(Ask-TP>stops_level*_Point);
if(!TP_check)
PrintFormat("For order %s TakeProfit=%.5f must be less than %.5f "+
" (Ask=%.5f - SYMBOL_TRADE_STOPS_LEVEL=%d points)",
EnumToString(type),TP,Ask-stops_level*_Point,Ask,stops_level);
//--- return the result of checking
return(TP_check&&SL_check);
}
break;
}
//--- a slightly different function is required for pending orders
return false;
}
//+------------------------------------------------------------------+
////////////////////////////////////////////////////////////////////////////////////
int getOpenOrders()
{
int Orders=0;
for(int i=0; i<OrdersTotal(); i++)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false)
{
continue;
}
if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=MagicNumber)
{
continue;
}
Orders++;
}
return(Orders);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Calculate optimal lot size buy |
//+------------------------------------------------------------------+
double LotsOptimized1Mxs(double llots)
{
double lots=llots;
//--- minimal allowed volume for trade operations
double minlot=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MIN);
if(lots<minlot)
{ lots=minlot; }
//--- maximal allowed volume of trade operations
double maxlot=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MAX);
if(lots>maxlot)
{ lots=maxlot; }
//--- get minimal step of volume changing
double volume_step=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_STEP);
int ratio=(int)MathRound(lots/volume_step);
if(MathAbs(ratio*volume_step-lots)>0.0000001)
{ lots=ratio*volume_step;}
if(((AccountStopoutMode()==1) &&
(AccountFreeMarginCheck(Symbol(),OP_BUY,lots)>AccountStopoutLevel()))
|| ((AccountStopoutMode()==0) &&
((AccountEquity()/(AccountEquity()-AccountFreeMarginCheck(Symbol(),OP_BUY,lots))*100)>AccountStopoutLevel())))
return(lots);
/* else Print("StopOut level Not enough money for ",OP_SELL," ",lot," ",Symbol());*/
return(0);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Calculate optimal lot size buy |
//+------------------------------------------------------------------+
double LotsOptimizedMxs(double llots)
{
double lots=llots;
//--- minimal allowed volume for trade operations
double minlot=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MIN);
if(lots<minlot)
{
lots=minlot;
Print("Volume is less than the minimal allowed ,we use",minlot);
}
//--- maximal allowed volume of trade operations
double maxlot=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MAX);
if(lots>maxlot)
{
lots=maxlot;
Print("Volume is greater than the maximal allowed,we use",maxlot);
}
//--- get minimal step of volume changing
double volume_step=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_STEP);
int ratio=(int)MathRound(lots/volume_step);
if(MathAbs(ratio*volume_step-lots)>0.0000001)
{
lots=ratio*volume_step;
Print("Volume is not a multiple of the minimal step ,we use the closest correct volume ",ratio*volume_step);
}
return(lots);
}
//+------------------------------------------------------------------+
//| Check the correctness of the order volume |
//+------------------------------------------------------------------+
bool CheckVolumeValue(double volume/*,string &description*/)
{
double lot=volume;
int orders=OrdersHistoryTotal(); // history orders total
int losses=0; // number of losses orders without a break
//--- select lot size
//--- maximal allowed volume of trade operations
double max_volume=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MAX);
if(lot>max_volume)
Print("Volume is greater than the maximal allowed ,we use",max_volume);
// return(false);
//--- minimal allowed volume for trade operations
double minlot=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MIN);
if(lot<minlot)
Print("Volume is less than the minimal allowed ,we use",minlot);
// return(false);
//--- get minimal step of volume changing
double volume_step=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_STEP);
int ratio=(int)MathRound(lot/volume_step);
if(MathAbs(ratio*volume_step-lot)>0.0000001)
{
Print("Volume is not a multiple of the minimal step ,we use, the closest correct volume is %.2f",
volume_step,ratio*volume_step);
// return(false);
}
// description="Correct volume value";
return(true);
}
//+------------------------------------------------------------------+
bool CheckMoneyForTrade(string symb,double lots,int type)
{
double free_margin=AccountFreeMarginCheck(symb,type,lots);
//-- if there is not enough money
if(free_margin>0)
{
if((AccountStopoutMode()==1) &&
(AccountFreeMarginCheck(symb,type,lots)<AccountStopoutLevel()))
{
Print("StopOut level Not enough money ", type," ",lots," ",Symbol());
return(false);
}
if(AccountEquity()-AccountFreeMarginCheck(Symbol(),type,lots)==0)
{
Print("StopOut level Not enough money ", type," ",lots," ",Symbol());
return(false);
}
if((AccountStopoutMode()==0) &&
((AccountEquity()/(AccountEquity()-AccountFreeMarginCheck(Symbol(),type,lots))*100)<AccountStopoutLevel()))
{
Print("StopOut level Not enough money ", type," ",lots," ",Symbol());
return(false);
}
}
else
if(free_margin<0)
{
string oper=(type==OP_BUY)? "Buy":"Sell";
Print("Not enough money for ",oper," ",lots," ",symb," Error code=",GetLastError());
return(false);
}
//--- checking successful
return(true);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Calculate optimal lot size buy |
//+------------------------------------------------------------------+
double LotsOptimized(double llots)
{
double lot=llots;
int orders=OrdersHistoryTotal(); // history orders total
int losses=0; // number of losses orders without a break
//--- calcuulate number of losses orders without a break
if(IncreaseFactor>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())
continue;
//---
if(OrderProfit()>0)
break;
if(OrderProfit()<0)
losses++;
}
if(losses>1)
// lot=NormalizeDouble(lot+lot*losses/IncreaseFactor,1);
lot=AccountFreeMargin()*IncreaseFactor/1000.0;
}
//--- minimal allowed volume for trade operations
double minlot=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MIN);
if(lot<minlot)
{
lot=minlot;
Print("Volume is less than the minimal allowed ,we use",minlot);
}
// lot=minlot;
//--- maximal allowed volume of trade operations
double maxlot=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MAX);
if(lot>maxlot)
{
lot=maxlot;
Print("Volume is greater than the maximal allowed,we use",maxlot);
}
// lot=maxlot;
//--- get minimal step of volume changing
double volume_step=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_STEP);
int ratio=(int)MathRound(lot/volume_step);
if(MathAbs(ratio*volume_step-lot)>0.0000001)
{
lot=ratio*volume_step;
Print("Volume is not a multiple of the minimal step ,we use the closest correct volume ",ratio*volume_step);
}
return(lot);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Ask Stochastic |
//+------------------------------------------------------------------+
int CheckStochastic()
{
//CHOCurrent = iCustom(NULL,0,"CHO",CHOTime,3,0,1,0);
// CHOPrevious = iCustom(NULL,0,"CHO",CHOTime,3,0,1,1);
// STOCHASTIC VALUE
STOCHCurrent = iStochastic(NULL,0,5,3,3,MODE_SMA,0,MODE_MAIN,0);
STOCHPrevious = iStochastic(NULL,0,5,3,3,MODE_SMA,0,MODE_MAIN,1);
// STOCH_Status = DECISION_UNKNOWN;
if(STOCHCurrent>50 && STOCHCurrent<88)
{
if(CHOCurrent>10)
{
STOCH_Status = DECISION_BUY;
}
else
if(CHOCurrent<-10)
{
STOCH_Status = DECISION_SELL;
}
}
else
if(STOCHCurrent<=12)
{
STOCH_Status = DECISION_SELL;
}
else
if(STOCHCurrent>=88)
{
STOCH_Status = DECISION_BUY;
}
else
if(STOCHCurrent<50 && STOCHCurrent>12)
{
if(CHOCurrent>10)
{
STOCH_Status = DECISION_BUY;
}
else
if(CHOCurrent<-10)
{
STOCH_Status = DECISION_SELL;
}
}
return (0);
}
//-------------------------------------------------------------------
//+------------------------------------------------------------------+
//| Ask CCI |
//+------------------------------------------------------------------+
int CheckCCI()
{
// CCI VALUE
CCICurrent = iCCI(NULL,0,20,PRICE_TYPICAL,0);
CCIPrevious = iCCI(NULL,0,20,PRICE_TYPICAL,1);
// CCI_Status = DECISION_UNKNOWN;
if((CCICurrent>CCIPrevious)&&(CCICurrent<75))
{
CCI_Status = DECISION_BUY;
}
else
if((CCICurrent<CCIPrevious)&&(CCICurrent>=-75))
{
CCI_Status = DECISION_SELL;
}
return (0);
}
//-------------------------------------------------------------------
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int CheckMA()
{
double MA_1_t=iMA(NULL,L,FastMA,0,MODE_LWMA,PRICE_TYPICAL,1); // МА_1
double MA_2_t=iMA(NULL,L,SlowMA,0,MODE_LWMA,PRICE_TYPICAL,1); // МА_2
ATR_Status = DECISION_UNKNOWN;
if(MA_1_t>MA_2_t)
{
MA_Status = DECISION_BUY;
}
else
if(MA_1_t<MA_2_t)
{
MA_Status = DECISION_SELL;
}
return (0);
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int CheckATR()
{
ATRCurrent = iATR(NULL,0,12,1);
ATRPrevious = iATR(NULL,0,12,0);
ATR_Status = DECISION_UNKNOWN;
if(ATRCurrent>ATRPrevious)
{
RSI_Status = DECISION_BUY;
}
else
if(ATRCurrent<ATRPrevious)
{
ATR_Status = DECISION_SELL;
}
return (0);
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int CheckOSMA()
{
OSMACurrent = iOsMA(NULL,0,12,26,9,PRICE_OPEN,1);
OSMA_Status = DECISION_UNKNOWN;
if(OSMACurrent>0)
{
OSMA_Status = DECISION_BUY;
}
else
if(OSMACurrent<0)
{
OSMA_Status = DECISION_SELL;
}
return (0);
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int CheckMACD()
{
double MacdMAIN0=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,1);
double MacdSIGNAL0=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,1);
MACDStatus = DECISION_UNKNOWN;
if((MacdMAIN0>0 && MacdMAIN0>MacdSIGNAL0) || (MacdMAIN0<0 && MacdMAIN0>MacdSIGNAL0))
{
MACDStatus = DECISION_BUY;
}
else
if((MacdMAIN0>0 && MacdMAIN0<MacdSIGNAL0) || (MacdMAIN0<0 && MacdMAIN0<MacdSIGNAL0))
{
MACDStatus = DECISION_SELL;
}
return (0);
}
//-------------------------------------------------------------------
//+------------------------------------------------------------------+
//| Trading |
//+------------------------------------------------------------------+
int Trade1()
{
// begin to trade
// Looking for open orders
//--------------------------------------------------------------------------------------------------
double MomLevel=MathAbs(100-iMomentum(NULL,0,14,PRICE_CLOSE,1));
double MomLevel1=MathAbs(100 - iMomentum(NULL,0,14,PRICE_CLOSE,2));
double MomLevel2=MathAbs(100 - iMomentum(NULL,0,14,PRICE_CLOSE,3));
double MomLevel3=MathAbs(100 - iMomentum(NULL,0,14,PRICE_CLOSE,0));
//--------------------------------------------------------------------------------------------------
ToSell=0;
ToBuy =0;
//FindSymbolOrder();
CheckCCI();
CheckMA();
CheckStochastic();
CheckATR();
CheckOSMA();
CheckMACD();
//+--------------------------------------------------------------------------+
if(ATR_Status==DECISION_BUY)
{
ToBuy=ToBuy+1;
ATR_Status=DECISION_UNKNOWN;
}
else
if(ATR_Status==DECISION_SELL)
{
ToSell=ToSell+1;
ATR_Status=DECISION_UNKNOWN;
}
//+--------------------------------------------------------------------------+
if(OSMA_Status==DECISION_BUY)
{
ToBuy=ToBuy+1;
OSMA_Status=DECISION_UNKNOWN;
}
else
if(OSMA_Status==DECISION_SELL)
{
ToSell=ToSell+1;
OSMA_Status=DECISION_UNKNOWN;
}
//+--------------------------------------------------------------------------+
if(MACDStatus==DECISION_BUY)
{
ToBuy=ToBuy+1;
MACDStatus=DECISION_UNKNOWN;
}
else
if(MACDStatus==DECISION_SELL)
{
ToSell=ToSell+1;
MACDStatus=DECISION_UNKNOWN;
}
//+--------------------------------------------------------------------------+
if(CCI_Status==DECISION_BUY)
{
ToBuy=ToBuy+1;
CCI_Status=DECISION_UNKNOWN;
}
else
if(CCI_Status==DECISION_SELL)
{
ToSell=ToSell+1;
CCI_Status=DECISION_UNKNOWN;
}
//+--------------------------------------------------------------------------+
//+--------------------------------------------------------------------------+
if(MA_Status==DECISION_BUY)
{
ToBuy=ToBuy+1;
MA_Status=DECISION_UNKNOWN;
}
else
if(MA_Status==DECISION_SELL)
{
ToSell=ToSell+1;
MA_Status=DECISION_UNKNOWN;
}
//+--------------------------------------------------------------------------+
if(RSI_Status==DECISION_BUY)
{
ToBuy=ToBuy+1;
RSI_Status=DECISION_UNKNOWN;
}
else
if(RSI_Status==DECISION_SELL)
{
ToSell=ToSell+1;
RSI_Status=DECISION_UNKNOWN;
}
//+--------------------------------------------------------------------------+
if(STOCH_Status==DECISION_BUY)
{
ToBuy=ToBuy+1;
STOCH_Status=DECISION_UNKNOWN;
}
else
if(STOCH_Status==DECISION_SELL)
{
ToSell=ToSell+1;
STOCH_Status=DECISION_UNKNOWN;
}
//+--------------------------------------------------------------------------+
//-----------------------------------------------------------------
if(ToSell>ToBuy&&(MomLevel<Mom_Sell || MomLevel1<Mom_Sell || MomLevel2<Mom_Sell))
{
Decision = DECISION_SELL ;
return(2);
}
else
if(ToSell<ToBuy &&(MomLevel<Mom_Buy || MomLevel1<Mom_Buy || MomLevel2<Mom_Buy))
{
Decision = DECISION_BUY ;
return(1);
}
else
{
Decision = DECISION_UNKNOWN;
}
return(0);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int CountTrades()
{
int count=0;
for(int trade=OrdersTotal()-1; trade>=0; trade--)
{
if(!OrderSelect(trade,SELECT_BY_POS,MODE_TRADES))
Print("Error");
if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=MagicNumber)
continue;
if(OrderSymbol()==Symbol() && OrderMagicNumber()==MagicNumber)
if(OrderType()==OP_SELL || OrderType()==OP_BUY)
count++;
}
return (count);
}
//+------------------------------------------------------------------+
double AccountEquityHigh()
{
if(CountTrades()==0)
AccountEquityHighAmt=AccountEquity();
if(AccountEquityHighAmt<PrevEquity)
AccountEquityHighAmt=PrevEquity;
else
AccountEquityHighAmt=AccountEquity();
PrevEquity=AccountEquity();
return (AccountEquityHighAmt);
}
//+------------------------------------------------------------------+
double CalculateProfit()
{
double Profit=0;
for(int cnt=OrdersTotal()-1; cnt>=0; cnt--)
{
if(!OrderSelect(cnt,SELECT_BY_POS,MODE_TRADES))
Print("Error");
if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=MagicNumber)
continue;
if(OrderSymbol()==Symbol() && OrderMagicNumber()==MagicNumber)
if(OrderType()==OP_BUY || OrderType()==OP_SELL)
Profit+=OrderProfit();
}
return (Profit);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CloseThisSymbolAll()
{
double CurrentPairProfit=CalculateProfit();
for(int trade=OrdersTotal()-1; trade>=0; trade--)
{
if(!OrderSelect(trade,SELECT_BY_POS,MODE_TRADES))
Print("Error");
if(OrderSymbol()==Symbol())
{
if(OrderSymbol()==Symbol() && OrderMagicNumber()==MagicNumber)
{
if(OrderType() == OP_BUY)
if(!OrderClose(OrderTicket(), OrderLots(), Bid, 3, Blue))
Print("Error");
if(OrderType() == OP_SELL)
if(!OrderClose(OrderTicket(), OrderLots(), Ask, 3, Red))
Print("Error");
}
Sleep(1000);
if(UseEquityStop)
{
if(CurrentPairProfit>0.0 && MathAbs(CurrentPairProfit)>TotalEquityRisk/100.0*AccountEquityHigh())
{
return;
}
}
}
}
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| GONNA SCALPING |
//| https://5d3071208c5e2.site123.me/ |
//+------------------------------------------------------------------+
#property copyright "AHARON TZADIK"
#property link "https://5d3071208c5e2.site123.me/"
#property version "1.00"
#property strict
//--------------------------------------------------------------- 2 --
//--------------------------------------------------------------- 3 --
extern bool Exit=FALSE;//Enable Exit strategy
bool USEMOVETOBREAKEVEN=true;//Enable "no loss"
double WHENTOMOVETOBE=30; //When to move break even
double PIPSTOMOVESL=30; //How much pips to move sl
extern double Lots=0.01; //Lots size
extern double IncreaseFactor=0.001; //IncreaseFactor
extern double TrailingStop=40; //TrailingStop
extern double Stop_Loss=200; //Stop Loss
extern int MagicNumber=1234; //MagicNumber
input double Take_Profit=200; //TakeProfit
extern int FastMA=1; //FastMA
extern int SlowMA=5; //SlowMA
extern double Mom_Sell=0.3; //Momentum_Sell
extern double Mom_Buy=0.3; //Momentum_Buy
input bool UseEquityStop = true; //Use Equity Stop
input double TotalEquityRisk = 1.0; //Total Equity Risk
input int Max_Trades=5;
double AccountEquityHighAmt,PrevEquity;
string EAName="R_O_B_O_T "; // EA name , to be displayed on the screen
#define DECISION_BUY 1
#define DECISION_SELL 0
#define DECISION_UNKNOWN -1
int err;
double BidPrev = 0;
double AskPrev = 0;
double CHOCurrent;
double CHOPrevious;
double StopLossIndex = 0;
double TakeProfitIndex = 0;
int ToSell=0;
int ToBuy =0;
int FoundOpenedOrder = false;
int Decision;
int PrevDecision;
//int cnt;
datetime PauseTo;
static datetime Old_Time=0;
double CHOCurrentExit,CHOPreviousExit,RSICurrentExit,RSIPreviousExit;
// Variables to assess the quality of modeling
double pipe;
// Variables for the storage information (data) about the market
double ModeLow;
double ModeHigh;
double ModeTime;
double ModeBid;
double ModeAsk;
double ModePoint;
double ModeDigits;
double ModeSpread;
double ModeStopLevel;
double ModeLotSize;
double ModeTickValue;
double ModeTickSize;
double ModeSwapLong;
double ModeSwapShort;
double ModeStarting;
double ModeExpiration;
double ModeTradeAllowed;
double ModeMinLot;
double ModeLotStep;
// ------ Stochastic Indicator ---
double STOCHCurrent;
double STOCHPrevious;
double STOCHSigCurrent;
double STOCHSigPrevious;
int STOCH_Status;
//------- CCI Indicator -------
double CCICurrent;
double CCIPrevious;
int CCI_Status;
//------- RSI Indicator -------
double RSICurrent;
double RSIPrevious;
int RSI_Status;
int MA_Status;
double ATRCurrent;
double ATRPrevious;
int ATR_Status;
int ROC_Status;
double OSMACurrent;
int CandleStatus;
int OSMA_Status;
int MACDStatus;
int FIBOStatus;
int SR_Status;
//int MACD_Status
double MomentCurrent;
double MomentPrevious;
//------------ PivotPoint --------------
int total=0;
double
Lot,Dmax,Dmin,// Amount of lots in a selected order
Lts, // Amount of lots in an opened order
Min_Lot, // Minimal amount of lots
Step, // Step of lot size change
Free, // Current free margin
One_Lot, // Price of one lot
Price, // Price of a selected order,
pips,
MA_1,MA_2,MACD_SIGNAL;
int Type,freeze_level,Spread;
//--- price levels for orders and positions
double priceopen,stoploss,takeprofit;
//--- ticket of the current order
int orderticket;
//--------------------------------------------------------------- 3 --
int
Period_MA_2, Period_MA_3, // Calculation periods of MA for other timefr.
Period_MA_02, Period_MA_03, // Calculation periods of supp. MAs
K2,K3,T,L;
//---
//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
MA_Status = DECISION_UNKNOWN;
ROC_Status = DECISION_UNKNOWN;
CCI_Status = DECISION_UNKNOWN;
RSI_Status = DECISION_UNKNOWN;
STOCH_Status = DECISION_UNKNOWN;
Decision = DECISION_UNKNOWN;
PrevDecision = DECISION_UNKNOWN;
CandleStatus = DECISION_UNKNOWN;
SR_Status = DECISION_UNKNOWN;
OSMA_Status = DECISION_UNKNOWN;
MACDStatus = DECISION_UNKNOWN;
FIBOStatus = DECISION_UNKNOWN;
//--------------------------------------------------------------- 5 --
//--------------------------------------------------------------- 5 --
switch(Period()) // Calculating coefficient for..
{
// .. different timeframes
case 1:
L=PERIOD_M5;
T=PERIOD_M15;
break;// Timeframe M1
case 5:
L=PERIOD_M1;
T=PERIOD_M15;
break;// Timeframe M5
case 15:
L=PERIOD_M5;
T=PERIOD_M30;
break;// Timeframe M15
case 30:
L=PERIOD_M15;
T=PERIOD_H1;
break;// Timeframe M30
case 60:
L=PERIOD_M30;
T=PERIOD_H4;
break;// Timeframe H1
case 240:
L=PERIOD_H1;
T=PERIOD_D1;
break;// Timeframe H4
case 1440:
L=PERIOD_H4;
T=PERIOD_W1;
break;// Timeframe D1
case 10080:
L=PERIOD_D1;
T=PERIOD_MN1;
break;// Timeframe W1
case 43200:
L=PERIOD_W1;
T=PERIOD_D1;
break;// Timeframe MN
}
double ticksize=MarketInfo(Symbol(),MODE_TICKSIZE);
if(ticksize==0.00001 || ticksize==0.001)
pips=ticksize*10;
else
pips=ticksize;
return(INIT_SUCCEEDED);
//--- distance from the activation price, within which it is not allowed to modify orders and positions
freeze_level=(int)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_FREEZE_LEVEL);
if(freeze_level!=0)
{
PrintFormat("SYMBOL_TRADE_FREEZE_LEVEL=%d: order or position modification is not allowed,"+
" if there are %d points to the activation price",freeze_level,freeze_level);
}
//---
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void OnTick(void)
{
double CurrentPairProfit=CalculateProfit();
Comment(EAName); // Show EA Name on screen
// Check for New Bar (Compatible with both MQL4 and MQL5)
static datetime dtBarCurrent=WRONG_VALUE;
datetime dtBarPrevious=dtBarCurrent;
dtBarCurrent=(datetime) SeriesInfoInteger(_Symbol,_Period,SERIES_LASTBAR_DATE);
bool NewBarFlag=(dtBarCurrent!=dtBarPrevious);
if(NewBarFlag)
{
if(UseEquityStop)
{
if(CurrentPairProfit<0.0 && MathAbs(CurrentPairProfit)>TotalEquityRisk/100.0*AccountEquityHigh())
{
CloseThisSymbolAll();
Print("Closed All due to Stop Out");
}
}
if(Exit)
{
stop();
}
if(USEMOVETOBREAKEVEN)
{MOVETOBREAKEVEN();}
Trail1();
int ticket=0;
// initial data checks
// it is important to make sure that the expert works with a normal
// chart and the user did not make any mistakes setting external
// variables (Lots, StopLoss, TakeProfit,
// TrailingStop) in our case, we check TakeProfit
// on a chart of less than 100 bars
//---
if(Bars<100)
{
Print("bars less than 100");
return;
}
if(Take_Profit<10)
{
Print("TakeProfit less than 10");
return;
}
//--- to simplify the coding and speed up access data are put into internal variables
HideTestIndicators(true);
//+------------------------------------------------------------------+
double MA_1_t=iMA(NULL,L,FastMA,0,MODE_LWMA,PRICE_TYPICAL,0); // МА_1
double MA_2_t=iMA(NULL,L,SlowMA,0,MODE_LWMA,PRICE_TYPICAL,0); // МА_2
//----------------------------------------------------------------------------
double MomLevel=MathAbs(100-iMomentum(NULL,T,14,PRICE_CLOSE,1));
double MomLevel1=MathAbs(100 - iMomentum(NULL,T,14,PRICE_CLOSE,2));
double MomLevel2=MathAbs(100 - iMomentum(NULL,T,14,PRICE_CLOSE,3));
//----------------------------------------------------------------------------
HideTestIndicators(false);
//--------------------------------------------------------------------------------------------------
// if(getOpenOrders()==0)
if(CountTrades()<Max_Trades)
{
//--- no opened orders identified
if(AccountFreeMargin()<(1000*Lots))
{
Print("We have no money. Free Margin = ",AccountFreeMargin());
return;
}
//--- check for long position (BUY) possibility
//+------------------------------------------------------------------+
//| BUY BUY BUY |
//+------------------------------------------------------------------+
if(Trade1()==1)
// if(MA_1_t>MA_2_t)
// if(MomLevel<Mom_Buy || MomLevel1<Mom_Buy || MomLevel2<Mom_Buy)
{
if((CheckVolumeValue(LotsOptimized(Lots)))==TRUE)
if((CheckMoneyForTrade(Symbol(),LotsOptimized(Lots),OP_BUY))==TRUE)
if((CheckStopLoss_Takeprofit(OP_BUY,NDTP(Bid-Stop_Loss*pips),NDTP(Bid+Take_Profit*pips)))==TRUE)
ticket=OrderSend(Symbol(),OP_BUY,LotsOptimized(Lots),ND(Ask),3,NDTP(Bid-Stop_Loss*pips),NDTP(Bid+Take_Profit*pips),"Long 1",MagicNumber,0,PaleGreen);
if(ticket>0)
{
if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES))
Print("BUY order opened : ",OrderOpenPrice());
Alert("we just got a buy signal on the ",_Period,"M",_Symbol);
SendNotification("we just got a buy signal on the1 "+(string)_Period+"M"+_Symbol);
SendMail("Order sent successfully","we just got a buy signal on the1 "+(string)_Period+"M"+_Symbol);
}
else
Print("Error opening BUY order : ",GetLastError());
return;
}
//--- check for short position (SELL) possibility
//+------------------------------------------------------------------+
//| SELL SELL SELL |
//+------------------------------------------------------------------+
if(Trade1()==2)
// if(MA_1_t<MA_2_t)
// if(MomLevel<Mom_Sell || MomLevel1<Mom_Sell || MomLevel2<Mom_Sell)
{
if((CheckVolumeValue(LotsOptimized(Lots)))==TRUE)
if((CheckMoneyForTrade(Symbol(),LotsOptimized(Lots),OP_SELL))==TRUE)
if((CheckStopLoss_Takeprofit(OP_SELL,NDTP(Ask+Stop_Loss*pips),NDTP(Ask-Take_Profit*pips)))==TRUE)
ticket=OrderSend(Symbol(),OP_SELL,LotsOptimized(Lots),ND(Bid),3,NDTP(Ask+Stop_Loss*pips),NDTP(Ask-Take_Profit*pips),"Short 1",MagicNumber,0,Red);
if(ticket>0)
{
if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES))
Print("SELL order opened : ",OrderOpenPrice());
Alert("we just got a sell signal on the ",_Period,"M",_Symbol);
SendMail("Order sent successfully","we just got a sell signal on the "+(string)_Period+"M"+_Symbol);
}
else
Print("Error opening SELL order : ",GetLastError());
}
//--- exit from the "no opened orders" block
return;
}
}
}
//+------------------------------------------------------------------+
//| stop |
//+------------------------------------------------------------------+
//-----------------------------------------------------------------------------+
int stop()
{
total=0;
HideTestIndicators(true);
double MA_1_t=iMA(NULL,L,FastMA,0,MODE_LWMA,PRICE_TYPICAL,0); // МА_1
double MA_2_t=iMA(NULL,L,SlowMA,0,MODE_LWMA,PRICE_TYPICAL,0); // МА_2
//+------------------------------------------------------------------+
double middleBB=iBands(Symbol(),0,20, 2,0,0,MODE_MAIN,1);//middle
double lowerBB=iBands(Symbol(),0,20, 2,0,0,MODE_LOWER,1);//lower
double upperBB=iBands(Symbol(),0,20, 2,0,0,MODE_UPPER,1);//upper
//+------------------------------------------------------------------+
double MacdMAIN=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,1);
double MacdSIGNAL=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,1);
double MacdMAIN0=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,1);
double MacdSIGNAL0=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,1);
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
// DALYN GUPPY MMA
//----------------------------------------------------------------------------
double MA_3=iMA(NULL,L,3,0,MODE_EMA,PRICE_TYPICAL,0); // МА_3 DALYN GUPPY MMA
double MA_5=iMA(NULL,L,5,0,MODE_EMA,PRICE_TYPICAL,0); // МА_5 DALYN GUPPY MMA
double MA_8=iMA(NULL,L,8,0,MODE_EMA,PRICE_TYPICAL,0); // МА_8 DALYN GUPPY MMA
double MA_10=iMA(NULL,L,10,0,MODE_EMA,PRICE_TYPICAL,0); // МА_10 DALYN GUPPY MMA
double MA_12=iMA(NULL,L,12,0,MODE_EMA,PRICE_TYPICAL,0); // МА_12 DALYN GUPPY MMA
double MA_15=iMA(NULL,L,15,0,MODE_EMA,PRICE_TYPICAL,0); // МА_15 DALYN GUPPY MMA
double MA_30=iMA(NULL,L,30,0,MODE_EMA,PRICE_TYPICAL,0); // МА_30 DALYN GUPPY MMA
double MA_35=iMA(NULL,L,35,0,MODE_EMA,PRICE_TYPICAL,0); // МА_35 DALYN GUPPY MMA
double MA_40=iMA(NULL,L,40,0,MODE_EMA,PRICE_TYPICAL,0); // МА_40 DALYN GUPPY MMA
double MA_45=iMA(NULL,L,45,0,MODE_EMA,PRICE_TYPICAL,0); // МА_45 DALYN GUPPY MMA
double MA_50=iMA(NULL,L,50,0,MODE_EMA,PRICE_TYPICAL,0); // МА_50 DALYN GUPPY MMA
double MA_60=iMA(NULL,L,60,0,MODE_EMA,PRICE_TYPICAL,0); // МА_60 DALYN GUPPY MMA
//-----------------------------------------------------------------------------------
HideTestIndicators(false);
for(int trade=OrdersTotal()-1; trade>=0; trade--)
{
if(OrderSelect(trade,SELECT_BY_POS,MODE_TRADES))
{
if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=MagicNumber)
continue;
if(OrderSymbol()==Symbol() || OrderMagicNumber()==MagicNumber)
{
if(OrderType()==OP_BUY)
{
//--- should it be closed?
if(((MA_3==MA_5 && MA_5==MA_8 && MA_8==MA_10 && MA_10==MA_12 && MA_12==MA_15)
||(MA_30==MA_35 && MA_35==MA_40 && MA_40==MA_45 && MA_45==MA_50 && MA_50==MA_60))
||(Close[1]<=lowerBB))
if(!OrderClose(OrderTicket(),OrderLots(),OrderClosePrice(),3,Red))
Print("Did not close");
break;
Print(" CLOSE BY EXIT STRATEGY ");
//--- check for trailing stop
}
else // go to short position
{
//--- should it be closed?
if(((MA_3==MA_5 && MA_5==MA_8 && MA_8==MA_10 && MA_10==MA_12 && MA_12==MA_15)
||(MA_30==MA_35 && MA_35==MA_40 && MA_40==MA_45 && MA_45==MA_50 && MA_50==MA_60))
||(Close[1]<=lowerBB))
if(!OrderClose(OrderTicket(),OrderLots(),OrderClosePrice(),3,Red))
Print("Did not close");
break;
Print(" CLOSE BY EXIT STRATEGY ");
//--- check for trailing stop
}
}
}
}
return(0);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Trailing stop loss |
//+------------------------------------------------------------------+
// --------------- ----------------------------------------------------------- ------------------------
void Trail1()
{
total=OrdersTotal();
//--- it is important to enter the market correctly, but it is more important to exit it correctly...
for(int cnt=0; cnt<total; cnt++)
{
if(!OrderSelect(cnt,SELECT_BY_POS,MODE_TRADES))
continue;
if(OrderMagicNumber()!=MagicNumber)
continue;
if(OrderType()<=OP_SELL && // check for opened position
OrderSymbol()==Symbol()) // check for symbol
{
//--- long position is opened
if(OrderType()==OP_BUY)
{
//--- check for trailing stop
if(TrailingStop>0)
{
if(Bid-OrderOpenPrice()>pips*TrailingStop)
{
if(OrderStopLoss()<Bid-pips*TrailingStop)
{
RefreshRates();
stoploss=Bid-(pips*TrailingStop);
takeprofit=OrderTakeProfit();
double StopLevel=MarketInfo(Symbol(),MODE_STOPLEVEL)+MarketInfo(Symbol(),MODE_SPREAD);
if(stoploss<StopLevel*pips)
stoploss=StopLevel*pips;
string symbol=OrderSymbol();
double point=SymbolInfoDouble(symbol,SYMBOL_POINT);
if(MathAbs(OrderStopLoss()-stoploss)>point)
if((pips*TrailingStop)>(int)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_FREEZE_LEVEL)*pips)
//--- modify order and exit
if(CheckStopLoss_Takeprofit(OP_BUY,stoploss,takeprofit))
if(OrderModifyCheck(OrderTicket(),OrderOpenPrice(),stoploss,takeprofit))
if(!OrderModify(OrderTicket(),OrderOpenPrice(),stoploss,takeprofit,0,Green))
Print("OrderModify error ",GetLastError());
return;
}
}
}
}
else // go to short position
{
//--- check for trailing stop
if(TrailingStop>0)
{
if((OrderOpenPrice()-Ask)>(pips*TrailingStop))
{
if((OrderStopLoss()>(Ask+pips*TrailingStop)) || (OrderStopLoss()==0))
{
RefreshRates();
stoploss=Ask+(pips*TrailingStop);
takeprofit=OrderTakeProfit();
double StopLevel=MarketInfo(Symbol(),MODE_STOPLEVEL)+MarketInfo(Symbol(),MODE_SPREAD);
if(stoploss<StopLevel*pips)
stoploss=StopLevel*pips;
if(takeprofit<StopLevel*pips)
takeprofit=StopLevel*pips;
string symbol=OrderSymbol();
double point=SymbolInfoDouble(symbol,SYMBOL_POINT);
if(MathAbs(OrderStopLoss()-stoploss)>point)
if((pips*TrailingStop)>(int)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_FREEZE_LEVEL)*pips)
//--- modify order and exit
if(CheckStopLoss_Takeprofit(OP_SELL,stoploss,takeprofit))
if(OrderModifyCheck(OrderTicket(),OrderOpenPrice(),stoploss,takeprofit))
if(!OrderModify(OrderTicket(),OrderOpenPrice(),stoploss,takeprofit,0,Red))
Print("OrderModify error ",GetLastError());
return;
}
}
}
}
}
}
}
//+------------------------------------------------------------------+
//+---------------------------------------------------------------------------+
//| MOVE TO BREAK EVEN |
//+---------------------------------------------------------------------------+
void MOVETOBREAKEVEN()
{
for(int b=OrdersTotal()-1; b>=0; b--)
{
if(OrderSelect(b,SELECT_BY_POS,MODE_TRADES))
if(OrderMagicNumber()!=MagicNumber)
continue;
if(OrderSymbol()==Symbol())
if(OrderType()==OP_BUY)
if(Bid-OrderOpenPrice()>WHENTOMOVETOBE*pips)
if(OrderOpenPrice()>OrderStopLoss())
if(CheckStopLoss_Takeprofit(OP_SELL,OrderOpenPrice()+(PIPSTOMOVESL*pips),OrderTakeProfit()))
if(OrderModifyCheck(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()+(PIPSTOMOVESL*pips),OrderTakeProfit()))
if(!OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()+(PIPSTOMOVESL*pips),OrderTakeProfit(),0,CLR_NONE))
Print("eror");
}
for(int s=OrdersTotal()-1; s>=0; s--)
{
if(OrderSelect(s,SELECT_BY_POS,MODE_TRADES))
if(OrderMagicNumber()!=MagicNumber)
continue;
if(OrderSymbol()==Symbol())
if(OrderType()==OP_SELL)
if(OrderOpenPrice()-Ask>WHENTOMOVETOBE*pips)
if(OrderOpenPrice()<OrderStopLoss())
if(CheckStopLoss_Takeprofit(OP_SELL,OrderOpenPrice()-(PIPSTOMOVESL*pips),OrderTakeProfit()))
if(OrderModifyCheck(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()-(PIPSTOMOVESL*pips),OrderTakeProfit()))
if(!OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()-(PIPSTOMOVESL*pips),OrderTakeProfit(),0,CLR_NONE))
Print("eror");
}
}
//+------------------------------------------------------------------+
// NormalizeDouble |
//+------------------------------------------------------------------+
double NDTP(double val)
{
RefreshRates();
double SPREAD=MarketInfo(Symbol(),MODE_SPREAD);
double StopLevel=MarketInfo(Symbol(),MODE_STOPLEVEL);
if(val<StopLevel*pips+SPREAD*pips)
val=StopLevel*pips+SPREAD*pips;
return(NormalizeDouble(val, Digits));
// return(val);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
double ND(double val)
{
return(NormalizeDouble(val, Digits));
}
//+------------------------------------------------------------------+
//| Checking the new values of levels before order modification |
//+------------------------------------------------------------------+
bool OrderModifyCheck(int ticket,double price,double sl,double tp)
{
//--- select order by ticket
if(OrderSelect(ticket,SELECT_BY_TICKET))
{
//--- point size and name of the symbol, for which a pending order was placed
string symbol=OrderSymbol();
double point=SymbolInfoDouble(symbol,SYMBOL_POINT);
//--- check if there are changes in the Open price
bool PriceOpenChanged=true;
int type=OrderType();
if(!(type==OP_BUY || type==OP_SELL))
{
PriceOpenChanged=(MathAbs(OrderOpenPrice()-price)>point);
}
//--- check if there are changes in the StopLoss level
bool StopLossChanged=(MathAbs(OrderStopLoss()-sl)>point);
//--- check if there are changes in the Takeprofit level
bool TakeProfitChanged=(MathAbs(OrderTakeProfit()-tp)>point);
//--- if there are any changes in levels
if(PriceOpenChanged || StopLossChanged || TakeProfitChanged)
return(true); // order can be modified
//--- there are no changes in the Open, StopLoss and Takeprofit levels
else
//--- notify about the error
PrintFormat("Order #%d already has levels of Open=%.5f SL=%.5f TP=%.5f",
ticket,OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit());
}
//--- came to the end, no changes for the order
return(false); // no point in modifying
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
bool CheckStopLoss_Takeprofit(ENUM_ORDER_TYPE type,double SL,double TP)
{
//--- get the SYMBOL_TRADE_STOPS_LEVEL level
int stops_level=(int)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL);
if(stops_level!=0)
{
PrintFormat("SYMBOL_TRADE_STOPS_LEVEL=%d: StopLoss and TakeProfit must"+
" not be nearer than %d points from the closing price",stops_level,stops_level);
}
//---
bool SL_check=false,TP_check=false;
//--- check only two order types
switch(type)
{
//--- Buy operation
case ORDER_TYPE_BUY:
{
//--- check the StopLoss
SL_check=(Bid-SL>stops_level*_Point);
if(!SL_check)
PrintFormat("For order %s StopLoss=%.5f must be less than %.5f"+
" (Bid=%.5f - SYMBOL_TRADE_STOPS_LEVEL=%d points)",
EnumToString(type),SL,Bid-stops_level*_Point,Bid,stops_level);
//--- check the TakeProfit
TP_check=(TP-Bid>stops_level*_Point);
if(!TP_check)
PrintFormat("For order %s TakeProfit=%.5f must be greater than %.5f"+
" (Bid=%.5f + SYMBOL_TRADE_STOPS_LEVEL=%d points)",
EnumToString(type),TP,Bid+stops_level*_Point,Bid,stops_level);
//--- return the result of checking
return(SL_check&&TP_check);
}
//--- Sell operation
case ORDER_TYPE_SELL:
{
//--- check the StopLoss
SL_check=(SL-Ask>stops_level*_Point);
if(!SL_check)
PrintFormat("For order %s StopLoss=%.5f must be greater than %.5f "+
" (Ask=%.5f + SYMBOL_TRADE_STOPS_LEVEL=%d points)",
EnumToString(type),SL,Ask+stops_level*_Point,Ask,stops_level);
//--- check the TakeProfit
TP_check=(Ask-TP>stops_level*_Point);
if(!TP_check)
PrintFormat("For order %s TakeProfit=%.5f must be less than %.5f "+
" (Ask=%.5f - SYMBOL_TRADE_STOPS_LEVEL=%d points)",
EnumToString(type),TP,Ask-stops_level*_Point,Ask,stops_level);
//--- return the result of checking
return(TP_check&&SL_check);
}
break;
}
//--- a slightly different function is required for pending orders
return false;
}
//+------------------------------------------------------------------+
////////////////////////////////////////////////////////////////////////////////////
int getOpenOrders()
{
int Orders=0;
for(int i=0; i<OrdersTotal(); i++)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false)
{
continue;
}
if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=MagicNumber)
{
continue;
}
Orders++;
}
return(Orders);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Calculate optimal lot size buy |
//+------------------------------------------------------------------+
double LotsOptimized1Mxs(double llots)
{
double lots=llots;
//--- minimal allowed volume for trade operations
double minlot=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MIN);
if(lots<minlot)
{ lots=minlot; }
//--- maximal allowed volume of trade operations
double maxlot=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MAX);
if(lots>maxlot)
{ lots=maxlot; }
//--- get minimal step of volume changing
double volume_step=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_STEP);
int ratio=(int)MathRound(lots/volume_step);
if(MathAbs(ratio*volume_step-lots)>0.0000001)
{ lots=ratio*volume_step;}
if(((AccountStopoutMode()==1) &&
(AccountFreeMarginCheck(Symbol(),OP_BUY,lots)>AccountStopoutLevel()))
|| ((AccountStopoutMode()==0) &&
((AccountEquity()/(AccountEquity()-AccountFreeMarginCheck(Symbol(),OP_BUY,lots))*100)>AccountStopoutLevel())))
return(lots);
/* else Print("StopOut level Not enough money for ",OP_SELL," ",lot," ",Symbol());*/
return(0);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Calculate optimal lot size buy |
//+------------------------------------------------------------------+
double LotsOptimizedMxs(double llots)
{
double lots=llots;
//--- minimal allowed volume for trade operations
double minlot=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MIN);
if(lots<minlot)
{
lots=minlot;
Print("Volume is less than the minimal allowed ,we use",minlot);
}
//--- maximal allowed volume of trade operations
double maxlot=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MAX);
if(lots>maxlot)
{
lots=maxlot;
Print("Volume is greater than the maximal allowed,we use",maxlot);
}
//--- get minimal step of volume changing
double volume_step=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_STEP);
int ratio=(int)MathRound(lots/volume_step);
if(MathAbs(ratio*volume_step-lots)>0.0000001)
{
lots=ratio*volume_step;
Print("Volume is not a multiple of the minimal step ,we use the closest correct volume ",ratio*volume_step);
}
return(lots);
}
//+------------------------------------------------------------------+
//| Check the correctness of the order volume |
//+------------------------------------------------------------------+
bool CheckVolumeValue(double volume/*,string &description*/)
{
double lot=volume;
int orders=OrdersHistoryTotal(); // history orders total
int losses=0; // number of losses orders without a break
//--- select lot size
//--- maximal allowed volume of trade operations
double max_volume=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MAX);
if(lot>max_volume)
Print("Volume is greater than the maximal allowed ,we use",max_volume);
// return(false);
//--- minimal allowed volume for trade operations
double minlot=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MIN);
if(lot<minlot)
Print("Volume is less than the minimal allowed ,we use",minlot);
// return(false);
//--- get minimal step of volume changing
double volume_step=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_STEP);
int ratio=(int)MathRound(lot/volume_step);
if(MathAbs(ratio*volume_step-lot)>0.0000001)
{
Print("Volume is not a multiple of the minimal step ,we use, the closest correct volume is %.2f",
volume_step,ratio*volume_step);
// return(false);
}
// description="Correct volume value";
return(true);
}
//+------------------------------------------------------------------+
bool CheckMoneyForTrade(string symb,double lots,int type)
{
double free_margin=AccountFreeMarginCheck(symb,type,lots);
//-- if there is not enough money
if(free_margin>0)
{
if((AccountStopoutMode()==1) &&
(AccountFreeMarginCheck(symb,type,lots)<AccountStopoutLevel()))
{
Print("StopOut level Not enough money ", type," ",lots," ",Symbol());
return(false);
}
if(AccountEquity()-AccountFreeMarginCheck(Symbol(),type,lots)==0)
{
Print("StopOut level Not enough money ", type," ",lots," ",Symbol());
return(false);
}
if((AccountStopoutMode()==0) &&
((AccountEquity()/(AccountEquity()-AccountFreeMarginCheck(Symbol(),type,lots))*100)<AccountStopoutLevel()))
{
Print("StopOut level Not enough money ", type," ",lots," ",Symbol());
return(false);
}
}
else
if(free_margin<0)
{
string oper=(type==OP_BUY)? "Buy":"Sell";
Print("Not enough money for ",oper," ",lots," ",symb," Error code=",GetLastError());
return(false);
}
//--- checking successful
return(true);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Calculate optimal lot size buy |
//+------------------------------------------------------------------+
double LotsOptimized(double llots)
{
double lot=llots;
int orders=OrdersHistoryTotal(); // history orders total
int losses=0; // number of losses orders without a break
//--- calcuulate number of losses orders without a break
if(IncreaseFactor>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())
continue;
//---
if(OrderProfit()>0)
break;
if(OrderProfit()<0)
losses++;
}
if(losses>1)
// lot=NormalizeDouble(lot+lot*losses/IncreaseFactor,1);
lot=AccountFreeMargin()*IncreaseFactor/1000.0;
}
//--- minimal allowed volume for trade operations
double minlot=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MIN);
if(lot<minlot)
{
lot=minlot;
Print("Volume is less than the minimal allowed ,we use",minlot);
}
// lot=minlot;
//--- maximal allowed volume of trade operations
double maxlot=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MAX);
if(lot>maxlot)
{
lot=maxlot;
Print("Volume is greater than the maximal allowed,we use",maxlot);
}
// lot=maxlot;
//--- get minimal step of volume changing
double volume_step=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_STEP);
int ratio=(int)MathRound(lot/volume_step);
if(MathAbs(ratio*volume_step-lot)>0.0000001)
{
lot=ratio*volume_step;
Print("Volume is not a multiple of the minimal step ,we use the closest correct volume ",ratio*volume_step);
}
return(lot);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Ask Stochastic |
//+------------------------------------------------------------------+
int CheckStochastic()
{
//CHOCurrent = iCustom(NULL,0,"CHO",CHOTime,3,0,1,0);
// CHOPrevious = iCustom(NULL,0,"CHO",CHOTime,3,0,1,1);
// STOCHASTIC VALUE
STOCHCurrent = iStochastic(NULL,0,5,3,3,MODE_SMA,0,MODE_MAIN,0);
STOCHPrevious = iStochastic(NULL,0,5,3,3,MODE_SMA,0,MODE_MAIN,1);
// STOCH_Status = DECISION_UNKNOWN;
if(STOCHCurrent>50 && STOCHCurrent<88)
{
if(CHOCurrent>10)
{
STOCH_Status = DECISION_BUY;
}
else
if(CHOCurrent<-10)
{
STOCH_Status = DECISION_SELL;
}
}
else
if(STOCHCurrent<=12)
{
STOCH_Status = DECISION_SELL;
}
else
if(STOCHCurrent>=88)
{
STOCH_Status = DECISION_BUY;
}
else
if(STOCHCurrent<50 && STOCHCurrent>12)
{
if(CHOCurrent>10)
{
STOCH_Status = DECISION_BUY;
}
else
if(CHOCurrent<-10)
{
STOCH_Status = DECISION_SELL;
}
}
return (0);
}
//-------------------------------------------------------------------
//+------------------------------------------------------------------+
//| Ask CCI |
//+------------------------------------------------------------------+
int CheckCCI()
{
// CCI VALUE
CCICurrent = iCCI(NULL,0,20,PRICE_TYPICAL,0);
CCIPrevious = iCCI(NULL,0,20,PRICE_TYPICAL,1);
// CCI_Status = DECISION_UNKNOWN;
if((CCICurrent>CCIPrevious)&&(CCICurrent<75))
{
CCI_Status = DECISION_BUY;
}
else
if((CCICurrent<CCIPrevious)&&(CCICurrent>=-75))
{
CCI_Status = DECISION_SELL;
}
return (0);
}
//-------------------------------------------------------------------
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int CheckMA()
{
double MA_1_t=iMA(NULL,L,FastMA,0,MODE_LWMA,PRICE_TYPICAL,1); // МА_1
double MA_2_t=iMA(NULL,L,SlowMA,0,MODE_LWMA,PRICE_TYPICAL,1); // МА_2
ATR_Status = DECISION_UNKNOWN;
if(MA_1_t>MA_2_t)
{
MA_Status = DECISION_BUY;
}
else
if(MA_1_t<MA_2_t)
{
MA_Status = DECISION_SELL;
}
return (0);
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int CheckATR()
{
ATRCurrent = iATR(NULL,0,12,1);
ATRPrevious = iATR(NULL,0,12,0);
ATR_Status = DECISION_UNKNOWN;
if(ATRCurrent>ATRPrevious)
{
RSI_Status = DECISION_BUY;
}
else
if(ATRCurrent<ATRPrevious)
{
ATR_Status = DECISION_SELL;
}
return (0);
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int CheckOSMA()
{
OSMACurrent = iOsMA(NULL,0,12,26,9,PRICE_OPEN,1);
OSMA_Status = DECISION_UNKNOWN;
if(OSMACurrent>0)
{
OSMA_Status = DECISION_BUY;
}
else
if(OSMACurrent<0)
{
OSMA_Status = DECISION_SELL;
}
return (0);
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int CheckMACD()
{
double MacdMAIN0=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,1);
double MacdSIGNAL0=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,1);
MACDStatus = DECISION_UNKNOWN;
if((MacdMAIN0>0 && MacdMAIN0>MacdSIGNAL0) || (MacdMAIN0<0 && MacdMAIN0>MacdSIGNAL0))
{
MACDStatus = DECISION_BUY;
}
else
if((MacdMAIN0>0 && MacdMAIN0<MacdSIGNAL0) || (MacdMAIN0<0 && MacdMAIN0<MacdSIGNAL0))
{
MACDStatus = DECISION_SELL;
}
return (0);
}
//-------------------------------------------------------------------
//+------------------------------------------------------------------+
//| Trading |
//+------------------------------------------------------------------+
int Trade1()
{
// begin to trade
// Looking for open orders
//--------------------------------------------------------------------------------------------------
double MomLevel=MathAbs(100-iMomentum(NULL,0,14,PRICE_CLOSE,1));
double MomLevel1=MathAbs(100 - iMomentum(NULL,0,14,PRICE_CLOSE,2));
double MomLevel2=MathAbs(100 - iMomentum(NULL,0,14,PRICE_CLOSE,3));
double MomLevel3=MathAbs(100 - iMomentum(NULL,0,14,PRICE_CLOSE,0));
//--------------------------------------------------------------------------------------------------
ToSell=0;
ToBuy =0;
//FindSymbolOrder();
CheckCCI();
CheckMA();
CheckStochastic();
CheckATR();
CheckOSMA();
CheckMACD();
//+--------------------------------------------------------------------------+
if(ATR_Status==DECISION_BUY)
{
ToBuy=ToBuy+1;
ATR_Status=DECISION_UNKNOWN;
}
else
if(ATR_Status==DECISION_SELL)
{
ToSell=ToSell+1;
ATR_Status=DECISION_UNKNOWN;
}
//+--------------------------------------------------------------------------+
if(OSMA_Status==DECISION_BUY)
{
ToBuy=ToBuy+1;
OSMA_Status=DECISION_UNKNOWN;
}
else
if(OSMA_Status==DECISION_SELL)
{
ToSell=ToSell+1;
OSMA_Status=DECISION_UNKNOWN;
}
//+--------------------------------------------------------------------------+
if(MACDStatus==DECISION_BUY)
{
ToBuy=ToBuy+1;
MACDStatus=DECISION_UNKNOWN;
}
else
if(MACDStatus==DECISION_SELL)
{
ToSell=ToSell+1;
MACDStatus=DECISION_UNKNOWN;
}
//+--------------------------------------------------------------------------+
if(CCI_Status==DECISION_BUY)
{
ToBuy=ToBuy+1;
CCI_Status=DECISION_UNKNOWN;
}
else
if(CCI_Status==DECISION_SELL)
{
ToSell=ToSell+1;
CCI_Status=DECISION_UNKNOWN;
}
//+--------------------------------------------------------------------------+
//+--------------------------------------------------------------------------+
if(MA_Status==DECISION_BUY)
{
ToBuy=ToBuy+1;
MA_Status=DECISION_UNKNOWN;
}
else
if(MA_Status==DECISION_SELL)
{
ToSell=ToSell+1;
MA_Status=DECISION_UNKNOWN;
}
//+--------------------------------------------------------------------------+
if(RSI_Status==DECISION_BUY)
{
ToBuy=ToBuy+1;
RSI_Status=DECISION_UNKNOWN;
}
else
if(RSI_Status==DECISION_SELL)
{
ToSell=ToSell+1;
RSI_Status=DECISION_UNKNOWN;
}
//+--------------------------------------------------------------------------+
if(STOCH_Status==DECISION_BUY)
{
ToBuy=ToBuy+1;
STOCH_Status=DECISION_UNKNOWN;
}
else
if(STOCH_Status==DECISION_SELL)
{
ToSell=ToSell+1;
STOCH_Status=DECISION_UNKNOWN;
}
//+--------------------------------------------------------------------------+
//-----------------------------------------------------------------
if(ToSell>ToBuy&&(MomLevel<Mom_Sell || MomLevel1<Mom_Sell || MomLevel2<Mom_Sell))
{
Decision = DECISION_SELL ;
return(2);
}
else
if(ToSell<ToBuy &&(MomLevel<Mom_Buy || MomLevel1<Mom_Buy || MomLevel2<Mom_Buy))
{
Decision = DECISION_BUY ;
return(1);
}
else
{
Decision = DECISION_UNKNOWN;
}
return(0);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int CountTrades()
{
int count=0;
for(int trade=OrdersTotal()-1; trade>=0; trade--)
{
if(!OrderSelect(trade,SELECT_BY_POS,MODE_TRADES))
Print("Error");
if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=MagicNumber)
continue;
if(OrderSymbol()==Symbol() && OrderMagicNumber()==MagicNumber)
if(OrderType()==OP_SELL || OrderType()==OP_BUY)
count++;
}
return (count);
}
//+------------------------------------------------------------------+
double AccountEquityHigh()
{
if(CountTrades()==0)
AccountEquityHighAmt=AccountEquity();
if(AccountEquityHighAmt<PrevEquity)
AccountEquityHighAmt=PrevEquity;
else
AccountEquityHighAmt=AccountEquity();
PrevEquity=AccountEquity();
return (AccountEquityHighAmt);
}
//+------------------------------------------------------------------+
double CalculateProfit()
{
double Profit=0;
for(int cnt=OrdersTotal()-1; cnt>=0; cnt--)
{
if(!OrderSelect(cnt,SELECT_BY_POS,MODE_TRADES))
Print("Error");
if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=MagicNumber)
continue;
if(OrderSymbol()==Symbol() && OrderMagicNumber()==MagicNumber)
if(OrderType()==OP_BUY || OrderType()==OP_SELL)
Profit+=OrderProfit();
}
return (Profit);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CloseThisSymbolAll()
{
double CurrentPairProfit=CalculateProfit();
for(int trade=OrdersTotal()-1; trade>=0; trade--)
{
if(!OrderSelect(trade,SELECT_BY_POS,MODE_TRADES))
Print("Error");
if(OrderSymbol()==Symbol())
{
if(OrderSymbol()==Symbol() && OrderMagicNumber()==MagicNumber)
{
if(OrderType() == OP_BUY)
if(!OrderClose(OrderTicket(), OrderLots(), Bid, 3, Blue))
Print("Error");
if(OrderType() == OP_SELL)
if(!OrderClose(OrderTicket(), OrderLots(), Ask, 3, Red))
Print("Error");
}
Sleep(1000);
if(UseEquityStop)
{
if(CurrentPairProfit>0.0 && MathAbs(CurrentPairProfit)>TotalEquityRisk/100.0*AccountEquityHigh())
{
return;
}
}
}
}
}
//+------------------------------------------------------------------+
Last edited by a moderator:
