Price Data Components
Indicators Used
Miscellaneous
0
Views
0
Downloads
0
Favorites
Сrossing of the two iMAs
ÿþ//+------------------------------------------------------------------+
//| !rossing of the two iMAs.mq5 |
//| Copyright © 2019, Vladimir Karputov |
//| http://wmua.ru/slesar/ |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2019, Vladimir Karputov"
#property link "http://wmua.ru/slesar/"
#property version "1.000"
/*
barabashkakvn Trading engine 3.109
*/
#include <Trade\PositionInfo.mqh>
#include <Trade\Trade.mqh>
#include <Trade\SymbolInfo.mqh>
#include <Trade\AccountInfo.mqh>
#include <Trade\DealInfo.mqh>
#include <Trade\OrderInfo.mqh>
#include <Expert\Money\MoneyFixedMargin.mqh>
//---
CPositionInfo m_position; // object of CPositionInfo class
CTrade m_trade; // object of CTrade class
CSymbolInfo m_symbol; // object of CSymbolInfo class
CAccountInfo m_account; // object of CAccountInfo class
CDealInfo m_deal; // object of CDealInfo class
COrderInfo m_order; // object of COrderInfo class
CMoneyFixedMargin *m_money; // object of CMoneyFixedMargin class
//+------------------------------------------------------------------+
//| Enum Lor or Risk |
//+------------------------------------------------------------------+
enum ENUM_LOT_OR_RISK
{
lots_min=0, // Lots Min
lot=1, // Constant lot
risk=2, // Risk in percent for a deal
};
//--- input parameters
input ushort InpStopLoss = 35; // Stop Loss, in pips (1.00045-1.00055=1 pips)
input ushort InpTakeProfit = 150; // Take Profit, in pips (1.00045-1.00055=1 pips)
input ushort InpTrailingStop = 25; // Trailing Stop (min distance from price to Stop Loss, in pips
input ushort InpTrailingStep = 5; // Trailing Step, in pips (1.00045-1.00055=1 pips)
input ENUM_LOT_OR_RISK InpLotOrRisk = risk; // Money management: Lot OR Risk
input double InpVolumeLotOrRisk = 3.0; // The value for "Money management"
input ulong InpDeviation = 10; // Deviation, in points (1.00045-1.00055=10 points)
//--- MA Fast
input int Inp_MA_Fast_ma_period = 6; // MA Fast: averaging period
input int Inp_MA_Fast_ma_shift = 0; // MA Fast: horizontal shift
input ENUM_MA_METHOD Inp_MA_Fast_ma_method = MODE_SMA; // MA Fast: smoothing type
input ENUM_APPLIED_PRICE Inp_MA_Fast_applied_price = PRICE_CLOSE; // MA Fast: type of price
//--- MA Slow
input int Inp_MA_Slow_ma_period = 30; // MA Slow: averaging period
input int Inp_MA_Slow_ma_shift = 0; // MA Slow: horizontal shift
input ENUM_MA_METHOD Inp_MA_Slow_ma_method = MODE_SMA; // MA Slow: smoothing type
input ENUM_APPLIED_PRICE Inp_MA_Slow_applied_price = PRICE_CLOSE; // MA Slow: type of price
//---
input bool InpOnlyOne = false; // Only one positions
input bool InpReverse = false; // Reverse
input bool InpCloseOpposite = false; // Close opposite
input bool InpPrintLog = false; // Print log
input ulong InpMagic = 298336880; // Magic number
//---
double m_stop_loss = 0.0; // Stop Loss -> double
double m_take_profit = 0.0; // Take Profit -> double
double m_trailing_stop = 0.0; // Trailing Stop -> double
double m_trailing_step = 0.0; // Trailing Step -> double
int handle_iMA_Fast; // variable for storing the handle of the iMA indicator
int handle_iMA_Slow; // variable for storing the handle of the iMA indicator
double m_adjusted_point; // point value adjusted for 3 or 5 points
datetime m_prev_bars = 0; // "0" -> D'1970.01.01 00:00';
//--- the tactic is this: for positions we strictly monitor the result ***
//+------------------------------------------------------------------+
//| Structure Positions |
//+------------------------------------------------------------------+
struct STRUCT_POSITION
{
ENUM_POSITION_TYPE pos_type; // position type
double volume; // position volume (if "0.0" -> the lot is "Money management")
double lot_coefficient; // lot coefficient
bool waiting_transaction; // waiting transaction, "true" -> it's forbidden to trade, we expect a transaction
ulong waiting_order_ticket; // waiting order ticket, ticket of the expected order
bool transaction_confirmed; // transaction confirmed, "true" -> transaction confirmed
//--- Constructor
STRUCT_POSITION()
{
pos_type = WRONG_VALUE;
volume = 0.0;
lot_coefficient = 0.0;
waiting_transaction = false;
waiting_order_ticket = 0;
transaction_confirmed = false;
}
};
STRUCT_POSITION SPosition[];
//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
//---
if(InpTrailingStop!=0 && InpTrailingStep==0)
{
string err_text=(TerminalInfoString(TERMINAL_LANGUAGE)=="Russian")?
""@59;8=3 =52>7<>65=: ?0@0<5B@ \"Trailing Step\" @025= =C;N!":
"Trailing is not possible: parameter \"Trailing Step\" is zero!";
//--- when testing, we will only output to the log about incorrect input parameters
if(MQLInfoInteger(MQL_TESTER))
{
Print(__FILE__," ",__FUNCTION__,", ERROR: ",err_text);
return(INIT_FAILED);
}
else // if the Expert Advisor is run on the chart, tell the user about the error
{
Alert(__FILE__," ",__FUNCTION__,", ERROR: ",err_text);
return(INIT_PARAMETERS_INCORRECT);
}
}
//---
if(!m_symbol.Name(Symbol())) // sets symbol name
{
Print(__FILE__," ",__FUNCTION__,", ERROR: CSymbolInfo.Name");
return(INIT_FAILED);
}
RefreshRates();
//---
m_trade.SetExpertMagicNumber(InpMagic);
m_trade.SetMarginMode();
m_trade.SetTypeFillingBySymbol(m_symbol.Name());
m_trade.SetDeviationInPoints(InpDeviation);
//--- tuning for 3 or 5 digits
int digits_adjust=1;
if(m_symbol.Digits()==3 || m_symbol.Digits()==5)
digits_adjust=10;
m_adjusted_point=m_symbol.Point()*digits_adjust;
m_stop_loss = InpStopLoss * m_adjusted_point;
m_take_profit = InpTakeProfit * m_adjusted_point;
m_trailing_stop = InpTrailingStop * m_adjusted_point;
m_trailing_step = InpTrailingStep * m_adjusted_point;
//--- check the input parameter "Lots"
string err_text="";
if(InpLotOrRisk==lot)
{
if(!CheckVolumeValue(InpVolumeLotOrRisk,err_text))
{
//--- when testing, we will only output to the log about incorrect input parameters
if(MQLInfoInteger(MQL_TESTER))
{
Print(__FILE__," ",__FUNCTION__,", ERROR: ",err_text);
return(INIT_FAILED);
}
else // if the Expert Advisor is run on the chart, tell the user about the error
{
Alert(__FILE__," ",__FUNCTION__,", ERROR: ",err_text);
return(INIT_PARAMETERS_INCORRECT);
}
}
}
else
if(InpLotOrRisk==risk)
{
if(m_money!=NULL)
delete m_money;
m_money=new CMoneyFixedMargin;
if(m_money!=NULL)
{
if(InpVolumeLotOrRisk<1 || InpVolumeLotOrRisk>100)
{
Print(__FILE__," ",__FUNCTION__,", ERROR: ");
Print("The value for \"Money management\" (",DoubleToString(InpVolumeLotOrRisk,2),") -> invalid parameters");
Print(" parameter must be in the range: from 1.00 to 100.00");
return(INIT_FAILED);
}
if(!m_money.Init(GetPointer(m_symbol),Period(),m_symbol.Point()*digits_adjust))
{
Print(__FILE__," ",__FUNCTION__,", ERROR: CMoneyFixedMargin.Init");
return(INIT_FAILED);
}
m_money.Percent(InpVolumeLotOrRisk);
}
else
{
Print(__FILE__," ",__FUNCTION__,", ERROR: Object CMoneyFixedMargin is NULL");
return(INIT_FAILED);
}
}
//--- create handle of the indicator iMA
handle_iMA_Fast=iMA(m_symbol.Name(),Period(),Inp_MA_Fast_ma_period,Inp_MA_Fast_ma_shift,
Inp_MA_Fast_ma_method,Inp_MA_Fast_applied_price);
//--- if the handle is not created
if(handle_iMA_Fast==INVALID_HANDLE)
{
//--- tell about the failure and output the error code
PrintFormat("Failed to create handle of the iMA indicator (\"Fast\") for the symbol %s/%s, error code %d",
m_symbol.Name(),
EnumToString(Period()),
GetLastError());
//--- the indicator is stopped early
return(INIT_FAILED);
}
//--- create handle of the indicator iMA
handle_iMA_Slow=iMA(m_symbol.Name(),Period(),Inp_MA_Slow_ma_period,Inp_MA_Slow_ma_shift,
Inp_MA_Slow_ma_method,Inp_MA_Slow_applied_price);
//--- if the handle is not created
if(handle_iMA_Slow==INVALID_HANDLE)
{
//--- tell about the failure and output the error code
PrintFormat("Failed to create handle of the iMA indicator (\"Slow\") for the symbol %s/%s, error code %d",
m_symbol.Name(),
EnumToString(Period()),
GetLastError());
//--- the indicator is stopped early
return(INIT_FAILED);
}
//---
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
//---
if(m_money!=NULL)
delete m_money;
}
//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick()
{
int size_need_position=ArraySize(SPosition);
if(size_need_position>0)
{
for(int i=size_need_position-1; i>=0; i--)
{
if(SPosition[i].waiting_transaction)
{
if(!SPosition[i].transaction_confirmed)
{
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", OK: ","transaction_confirmed: ",SPosition[i].transaction_confirmed);
return;
}
else
if(SPosition[i].transaction_confirmed)
{
ArrayRemove(SPosition,i,1);
return;
}
}
if(SPosition[i].pos_type==POSITION_TYPE_BUY)
{
if(InpCloseOpposite || InpOnlyOne)
{
int count_buys = 0;
double volume_buys = 0.0;
double volume_biggest_buys = 0.0;
int count_sells = 0;
double volume_sells = 0.0;
double volume_biggest_sells = 0.0;
CalculateAllPositions(count_buys,volume_buys,volume_biggest_buys,
count_sells,volume_sells,volume_biggest_sells);
if(InpCloseOpposite)
{
if(count_sells>0)
{
double level;
if(FreezeStopsLevels(level))
ClosePositions(POSITION_TYPE_SELL,level);
return;
}
}
if(InpOnlyOne)
{
if(count_buys+count_sells==0)
{
double level;
if(FreezeStopsLevels(level))
{
SPosition[i].waiting_transaction=true;
OpenPosition(i,level);
}
return;
}
else
ArrayRemove(SPosition,i,1);
return;
}
}
double level;
if(FreezeStopsLevels(level))
{
SPosition[i].waiting_transaction=true;
OpenPosition(i,level);
}
return;
}
if(SPosition[i].pos_type==POSITION_TYPE_SELL)
{
if(InpCloseOpposite || InpOnlyOne)
{
int count_buys = 0;
double volume_buys = 0.0;
double volume_biggest_buys = 0.0;
int count_sells = 0;
double volume_sells = 0.0;
double volume_biggest_sells = 0.0;
CalculateAllPositions(count_buys,volume_buys,volume_biggest_buys,
count_sells,volume_sells,volume_biggest_sells);
if(InpCloseOpposite)
{
if(count_buys>0)
{
double level;
if(FreezeStopsLevels(level))
ClosePositions(POSITION_TYPE_BUY,level);
return;
}
}
if(InpOnlyOne)
{
if(count_buys+count_sells==0)
{
double level;
if(FreezeStopsLevels(level))
{
SPosition[i].waiting_transaction=true;
OpenPosition(i,level);
}
return;
}
else
ArrayRemove(SPosition,i,1);
return;
}
}
double level;
if(FreezeStopsLevels(level))
{
SPosition[i].waiting_transaction=true;
OpenPosition(i,level);
}
return;
}
}
}
//--- we work only at the time of the birth of new bar
datetime time_0=iTime(m_symbol.Name(),Period(),0);
if(time_0==m_prev_bars)
return;
m_prev_bars=time_0;
double level;
if(!FreezeStopsLevels(level))
{
m_prev_bars=0;
return;
}
//--- trailing only at the time of the birth of new bar
if(FreezeStopsLevels(level))
Trailing(level);
//--- search for trading signals only at the time of the birth of new bar
if(!SearchTradingSignals())
{
m_prev_bars=0;
return;
}
//---
}
//+------------------------------------------------------------------+
//| TradeTransaction function |
//+------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction &trans,
const MqlTradeRequest &request,
const MqlTradeResult &result)
{
//--- get transaction type as enumeration value
ENUM_TRADE_TRANSACTION_TYPE type=trans.type;
//--- if transaction is result of addition of the transaction in history
if(type==TRADE_TRANSACTION_DEAL_ADD)
{
long deal_ticket =0;
long deal_order =0;
long deal_time =0;
long deal_time_msc =0;
long deal_type =-1;
long deal_entry =-1;
long deal_magic =0;
long deal_reason =-1;
long deal_position_id =0;
double deal_volume =0.0;
double deal_price =0.0;
double deal_commission =0.0;
double deal_swap =0.0;
double deal_profit =0.0;
string deal_symbol ="";
string deal_comment ="";
string deal_external_id ="";
if(HistoryDealSelect(trans.deal))
{
deal_ticket =HistoryDealGetInteger(trans.deal,DEAL_TICKET);
deal_order =HistoryDealGetInteger(trans.deal,DEAL_ORDER);
deal_time =HistoryDealGetInteger(trans.deal,DEAL_TIME);
deal_time_msc =HistoryDealGetInteger(trans.deal,DEAL_TIME_MSC);
deal_type =HistoryDealGetInteger(trans.deal,DEAL_TYPE);
deal_entry =HistoryDealGetInteger(trans.deal,DEAL_ENTRY);
deal_magic =HistoryDealGetInteger(trans.deal,DEAL_MAGIC);
deal_reason =HistoryDealGetInteger(trans.deal,DEAL_REASON);
deal_position_id =HistoryDealGetInteger(trans.deal,DEAL_POSITION_ID);
deal_volume =HistoryDealGetDouble(trans.deal,DEAL_VOLUME);
deal_price =HistoryDealGetDouble(trans.deal,DEAL_PRICE);
deal_commission =HistoryDealGetDouble(trans.deal,DEAL_COMMISSION);
deal_swap =HistoryDealGetDouble(trans.deal,DEAL_SWAP);
deal_profit =HistoryDealGetDouble(trans.deal,DEAL_PROFIT);
deal_symbol =HistoryDealGetString(trans.deal,DEAL_SYMBOL);
deal_comment =HistoryDealGetString(trans.deal,DEAL_COMMENT);
deal_external_id =HistoryDealGetString(trans.deal,DEAL_EXTERNAL_ID);
}
else
return;
ENUM_DEAL_ENTRY enum_deal_entry=(ENUM_DEAL_ENTRY)deal_entry;
if(deal_symbol==m_symbol.Name() && deal_magic==InpMagic)
{
if(deal_type==DEAL_TYPE_BUY || deal_type==DEAL_TYPE_SELL)
{
int size_need_position=ArraySize(SPosition);
if(size_need_position>0)
{
for(int i=0; i<size_need_position; i++)
{
if(SPosition[i].waiting_transaction)
if(SPosition[i].waiting_order_ticket==deal_order)
{
Print(__FUNCTION__," Transaction confirmed");
SPosition[i].transaction_confirmed=true;
break;
}
}
}
}
}
}
}
//+------------------------------------------------------------------+
//| Refreshes the symbol quotes data |
//+------------------------------------------------------------------+
bool RefreshRates()
{
//--- refresh rates
if(!m_symbol.RefreshRates())
{
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", ERROR: ","RefreshRates error");
return(false);
}
//--- protection against the return value of "zero"
if(m_symbol.Ask()==0 || m_symbol.Bid()==0)
{
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", ERROR: ","Ask == 0.0 OR Bid == 0.0");
return(false);
}
//---
return(true);
}
//+------------------------------------------------------------------+
//| Check the correctness of the position volume |
//+------------------------------------------------------------------+
bool CheckVolumeValue(double volume,string &error_description)
{
//--- minimal allowed volume for trade operations
double min_volume=m_symbol.LotsMin();
if(volume<min_volume)
{
if(TerminalInfoString(TERMINAL_LANGUAGE)=="Russian")
error_description=StringFormat(" 1J5< <5=LH5 <8=8<0;L=> 4>?CAB8<>3> SYMBOL_VOLUME_MIN=%.2f",min_volume);
else
error_description=StringFormat("Volume is less than the minimal allowed SYMBOL_VOLUME_MIN=%.2f",min_volume);
return(false);
}
//--- maximal allowed volume of trade operations
double max_volume=m_symbol.LotsMax();
if(volume>max_volume)
{
if(TerminalInfoString(TERMINAL_LANGUAGE)=="Russian")
error_description=StringFormat(" 1J5< 1>;LH5 <0:A8<0;L=> 4>?CAB8<>3> SYMBOL_VOLUME_MAX=%.2f",max_volume);
else
error_description=StringFormat("Volume is greater than the maximal allowed SYMBOL_VOLUME_MAX=%.2f",max_volume);
return(false);
}
//--- get minimal step of volume changing
double volume_step=m_symbol.LotsStep();
int ratio=(int)MathRound(volume/volume_step);
if(MathAbs(ratio*volume_step-volume)>0.0000001)
{
if(TerminalInfoString(TERMINAL_LANGUAGE)=="Russian")
error_description=StringFormat(" 1J5< =5 :@0B5= <8=8<0;L=><C H03C SYMBOL_VOLUME_STEP=%.2f, 1;8609H89 ?@028;L=K9 >1J5< %.2f",
volume_step,ratio*volume_step);
else
error_description=StringFormat("Volume is not a multiple of the minimal step SYMBOL_VOLUME_STEP=%.2f, the closest correct volume is %.2f",
volume_step,ratio*volume_step);
return(false);
}
error_description="Correct volume value";
return(true);
}
//+------------------------------------------------------------------+
//| Lot Check |
//+------------------------------------------------------------------+
double LotCheck(double lots,CSymbolInfo &symbol)
{
//--- calculate maximum volume
double volume=NormalizeDouble(lots,2);
double stepvol=symbol.LotsStep();
if(stepvol>0.0)
volume=stepvol*MathFloor(volume/stepvol);
//---
double minvol=symbol.LotsMin();
if(volume<minvol)
volume=0.0;
//---
double maxvol=symbol.LotsMax();
if(volume>maxvol)
volume=maxvol;
return(volume);
}
//+------------------------------------------------------------------+
//| Check Freeze and Stops levels |
//+------------------------------------------------------------------+
bool FreezeStopsLevels(double &level)
{
//--- check Freeze and Stops levels
/*
Type of order/position | Activation price | Check
------------------------|--------------------|--------------------------------------------
Buy Limit order | Ask | Ask-OpenPrice >= SYMBOL_TRADE_FREEZE_LEVEL
Buy Stop order | Ask | OpenPrice-Ask >= SYMBOL_TRADE_FREEZE_LEVEL
Sell Limit order | Bid | OpenPrice-Bid >= SYMBOL_TRADE_FREEZE_LEVEL
Sell Stop order | Bid | Bid-OpenPrice >= SYMBOL_TRADE_FREEZE_LEVEL
Buy position | Bid | TakeProfit-Bid >= SYMBOL_TRADE_FREEZE_LEVEL
| | Bid-StopLoss >= SYMBOL_TRADE_FREEZE_LEVEL
Sell position | Ask | Ask-TakeProfit >= SYMBOL_TRADE_FREEZE_LEVEL
| | StopLoss-Ask >= SYMBOL_TRADE_FREEZE_LEVEL
Buying is done at the Ask price | Selling is done at the Bid price
------------------------------------------------|----------------------------------
TakeProfit >= Bid | TakeProfit <= Ask
StopLoss <= Bid | StopLoss >= Ask
TakeProfit - Bid >= SYMBOL_TRADE_STOPS_LEVEL | Ask - TakeProfit >= SYMBOL_TRADE_STOPS_LEVEL
Bid - StopLoss >= SYMBOL_TRADE_STOPS_LEVEL | StopLoss - Ask >= SYMBOL_TRADE_STOPS_LEVEL
*/
if(!RefreshRates() || !m_symbol.Refresh())
return(false);
//--- FreezeLevel -> for pending order and modification
double freeze_level=m_symbol.FreezeLevel()*m_symbol.Point();
if(freeze_level==0.0)
freeze_level=(m_symbol.Ask()-m_symbol.Bid())*3.0;
//--- StopsLevel -> for TakeProfit and StopLoss
double stop_level=m_symbol.StopsLevel()*m_symbol.Point();
if(stop_level==0.0)
stop_level=(m_symbol.Ask()-m_symbol.Bid())*3.0;
if(freeze_level<=0.0 || stop_level<=0.0)
return(false);
level=(freeze_level>stop_level)?freeze_level:stop_level;
double spread=m_symbol.Spread()*m_symbol.Point()*3.0;
level=(level>spread)?level:spread;
//---
return(true);
}
//+------------------------------------------------------------------+
//| Open position |
//| double stop_loss |
//| -> pips * m_adjusted_point (if "0.0" -> the m_stop_loss) |
//| double take_profit |
//| -> pips * m_adjusted_point (if "0.0" -> the m_take_profit) |
//+------------------------------------------------------------------+
void OpenPosition(const int index,const double level)
{
/*
Buying is done at the Ask price | Selling is done at the Bid price
------------------------------------------------|----------------------------------
TakeProfit >= Bid | TakeProfit <= Ask
StopLoss <= Bid | StopLoss >= Ask
TakeProfit - Bid >= SYMBOL_TRADE_STOPS_LEVEL | Ask - TakeProfit >= SYMBOL_TRADE_STOPS_LEVEL
Bid - StopLoss >= SYMBOL_TRADE_STOPS_LEVEL | StopLoss - Ask >= SYMBOL_TRADE_STOPS_LEVEL
*/
//--- buy
if(SPosition[index].pos_type==POSITION_TYPE_BUY)
{
double sl=(m_stop_loss==0.0)?0.0:m_symbol.Ask()-m_stop_loss;
if(sl>0.0)
if(m_symbol.Bid()-sl<level)
sl=m_symbol.Bid()-level;
double tp=(m_take_profit==0.0)?0.0:m_symbol.Ask()+m_take_profit;
if(tp>0.0)
if(tp-m_symbol.Ask()<level)
tp=m_symbol.Ask()+level;
OpenBuy(index,sl,tp);
return;
}
//--- sell
if(SPosition[index].pos_type==POSITION_TYPE_SELL)
{
double sl=(m_stop_loss==0.0)?0.0:m_symbol.Bid()+m_stop_loss;
if(sl>0.0)
if(sl-m_symbol.Ask()<level)
sl=m_symbol.Ask()+level;
double tp=(m_take_profit==0.0)?0.0:m_symbol.Bid()-m_take_profit;
if(tp>0.0)
if(m_symbol.Bid()-tp<level)
tp=m_symbol.Bid()-level;
OpenSell(index,sl,tp);
return;
}
}
//+------------------------------------------------------------------+
//| Open Buy position |
//+------------------------------------------------------------------+
void OpenBuy(const int index,double sl,double tp)
{
sl=m_symbol.NormalizePrice(sl);
tp=m_symbol.NormalizePrice(tp);
double long_lot=0.0;
if(SPosition[index].volume>0.0)
long_lot=SPosition[index].volume;
else
{
if(InpLotOrRisk==risk)
{
long_lot=m_money.CheckOpenLong(m_symbol.Ask(),sl);
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", OK: ","sl=",DoubleToString(sl,m_symbol.Digits()),
", CheckOpenLong: ",DoubleToString(long_lot,2),
", Balance: ", DoubleToString(m_account.Balance(),2),
", Equity: ", DoubleToString(m_account.Equity(),2),
", FreeMargin: ", DoubleToString(m_account.FreeMargin(),2));
if(long_lot==0.0)
{
ArrayRemove(SPosition,index,1);
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", ERROR: ","CMoneyFixedMargin.CheckOpenLong returned the value of 0.0");
return;
}
}
else
if(InpLotOrRisk==lot)
long_lot=InpVolumeLotOrRisk;
else
if(InpLotOrRisk==lots_min)
long_lot=m_symbol.LotsMin();
else
{
ArrayRemove(SPosition,index,1);
return;
}
}
if(SPosition[index].lot_coefficient>0.0)
{
long_lot=LotCheck(long_lot*SPosition[index].lot_coefficient,
m_symbol);
if(long_lot==0)
{
ArrayRemove(SPosition,index,1);
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", ERROR: ","LotCheck returned the 0.0");
return;
}
}
if(m_symbol.LotsLimit()>0.0)
{
int count_buys = 0;
double volume_buys = 0.0;
double volume_biggest_buys = 0.0;
int count_sells = 0;
double volume_sells = 0.0;
double volume_biggest_sells = 0.0;
CalculateAllPositions(count_buys,volume_buys,volume_biggest_buys,
count_sells,volume_sells,volume_biggest_sells);
if(volume_buys+volume_sells+long_lot>m_symbol.LotsLimit())
{
ArrayRemove(SPosition,index,1);
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", ERROR: ","#0 Buy, Volume Buy (",DoubleToString(volume_buys,2),
") + Volume Sell (",DoubleToString(volume_sells,2),
") + Volume long (",DoubleToString(long_lot,2),
") > Lots Limit (",DoubleToString(m_symbol.LotsLimit(),2),")");
return;
}
}
//--- check volume before OrderSend to avoid "not enough money" error (CTrade)
double free_margin_check=m_account.FreeMarginCheck(m_symbol.Name(),
ORDER_TYPE_BUY,
long_lot,
m_symbol.Ask());
double margin_check=m_account.MarginCheck(m_symbol.Name(),
ORDER_TYPE_BUY,
long_lot,
m_symbol.Ask());
if(free_margin_check>margin_check)
{
if(m_trade.Buy(long_lot,m_symbol.Name(),
m_symbol.Ask(),sl,tp)) // CTrade::Buy -> "true"
{
if(m_trade.ResultDeal()==0)
{
if(m_trade.ResultRetcode()==10009) // trade order went to the exchange
{
SPosition[index].waiting_transaction=true;
SPosition[index].waiting_order_ticket=m_trade.ResultOrder();
}
else
{
SPosition[index].waiting_transaction=false;
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", ERROR: ","#1 Buy -> false. Result Retcode: ",m_trade.ResultRetcode(),
", description of result: ",m_trade.ResultRetcodeDescription());
}
if(InpPrintLog)
PrintResultTrade(m_trade,m_symbol);
}
else
{
if(m_trade.ResultRetcode()==10009)
{
SPosition[index].waiting_transaction=true;
SPosition[index].waiting_order_ticket=m_trade.ResultOrder();
}
else
{
SPosition[index].waiting_transaction=false;
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", OK: ","#2 Buy -> true. Result Retcode: ",m_trade.ResultRetcode(),
", description of result: ",m_trade.ResultRetcodeDescription());
}
if(InpPrintLog)
PrintResultTrade(m_trade,m_symbol);
}
}
else
{
SPosition[index].waiting_transaction=false;
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", ERROR: ","#3 Buy -> false. Result Retcode: ",m_trade.ResultRetcode(),
", description of result: ",m_trade.ResultRetcodeDescription());
if(InpPrintLog)
PrintResultTrade(m_trade,m_symbol);
}
}
else
{
ArrayRemove(SPosition,index,1);
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", ERROR: ","CAccountInfo.FreeMarginCheck returned the value ",DoubleToString(free_margin_check,2));
return;
}
//---
}
//+------------------------------------------------------------------+
//| Open Sell position |
//+------------------------------------------------------------------+
void OpenSell(const int index,double sl,double tp)
{
sl=m_symbol.NormalizePrice(sl);
tp=m_symbol.NormalizePrice(tp);
double short_lot=0.0;
if(SPosition[index].volume>0.0)
short_lot=SPosition[index].volume;
else
{
if(InpLotOrRisk==risk)
{
short_lot=m_money.CheckOpenShort(m_symbol.Bid(),sl);
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", OK: ","sl=",DoubleToString(sl,m_symbol.Digits()),
", CheckOpenLong: ",DoubleToString(short_lot,2),
", Balance: ", DoubleToString(m_account.Balance(),2),
", Equity: ", DoubleToString(m_account.Equity(),2),
", FreeMargin: ", DoubleToString(m_account.FreeMargin(),2));
if(short_lot==0.0)
{
ArrayRemove(SPosition,index,1);
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", ERROR: ","CMoneyFixedMargin.CheckOpenShort returned the value of \"0.0\"");
return;
}
}
else
if(InpLotOrRisk==lot)
short_lot=InpVolumeLotOrRisk;
else
if(InpLotOrRisk==lots_min)
short_lot=m_symbol.LotsMin();
else
{
ArrayRemove(SPosition,index,1);
return;
}
}
if(SPosition[index].lot_coefficient>0.0)
{
short_lot=LotCheck(short_lot*SPosition[index].lot_coefficient,m_symbol);
if(short_lot==0)
{
ArrayRemove(SPosition,index,1);
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", ERROR: ","LotCheck returned the 0.0");
return;
}
}
if(m_symbol.LotsLimit()>0.0)
{
int count_buys = 0;
double volume_buys = 0.0;
double volume_biggest_buys = 0.0;
int count_sells = 0;
double volume_sells = 0.0;
double volume_biggest_sells = 0.0;
CalculateAllPositions(count_buys,volume_buys,volume_biggest_buys,
count_sells,volume_sells,volume_biggest_sells);
if(volume_buys+volume_sells+short_lot>m_symbol.LotsLimit())
{
ArrayRemove(SPosition,index,1);
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", ERROR: ","#0 Buy, Volume Buy (",DoubleToString(volume_buys,2),
") + Volume Sell (",DoubleToString(volume_sells,2),
") + Volume short (",DoubleToString(short_lot,2),
") > Lots Limit (",DoubleToString(m_symbol.LotsLimit(),2),")");
return;
}
}
//--- check volume before OrderSend to avoid "not enough money" error (CTrade)
double free_margin_check=m_account.FreeMarginCheck(m_symbol.Name(),
ORDER_TYPE_SELL,
short_lot,
m_symbol.Bid());
double margin_check=m_account.MarginCheck(m_symbol.Name(),
ORDER_TYPE_SELL,
short_lot,
m_symbol.Bid());
if(free_margin_check>margin_check)
{
if(m_trade.Sell(short_lot,m_symbol.Name(),
m_symbol.Bid(),sl,tp)) // CTrade::Sell -> "true"
{
if(m_trade.ResultDeal()==0)
{
if(m_trade.ResultRetcode()==10009) // trade order went to the exchange
{
SPosition[index].waiting_transaction=true;
SPosition[index].waiting_order_ticket=m_trade.ResultOrder();
}
else
{
SPosition[index].waiting_transaction=false;
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", ERROR: ","#1 Sell -> false. Result Retcode: ",m_trade.ResultRetcode(),
", description of result: ",m_trade.ResultRetcodeDescription());
}
if(InpPrintLog)
PrintResultTrade(m_trade,m_symbol);
}
else
{
if(m_trade.ResultRetcode()==10009)
{
SPosition[index].waiting_transaction=true;
SPosition[index].waiting_order_ticket=m_trade.ResultOrder();
}
else
{
SPosition[index].waiting_transaction=false;
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", OK: ","#2 Sell -> true. Result Retcode: ",m_trade.ResultRetcode(),
", description of result: ",m_trade.ResultRetcodeDescription());
}
if(InpPrintLog)
PrintResultTrade(m_trade,m_symbol);
}
}
else
{
SPosition[index].waiting_transaction=false;
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", ERROR: ","#3 Sell -> false. Result Retcode: ",m_trade.ResultRetcode(),
", description of result: ",m_trade.ResultRetcodeDescription());
if(InpPrintLog)
PrintResultTrade(m_trade,m_symbol);
}
}
else
{
ArrayRemove(SPosition,index,1);
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", ERROR: ","CAccountInfo.FreeMarginCheck returned the value ",DoubleToString(free_margin_check,2));
return;
}
//---
}
//+------------------------------------------------------------------+
//| Print CTrade result |
//+------------------------------------------------------------------+
void PrintResultTrade(CTrade &trade,CSymbolInfo &symbol)
{
Print(__FILE__," ",__FUNCTION__,", Symbol: ",symbol.Name()+", "+
"Code of request result: "+IntegerToString(trade.ResultRetcode())+", "+
"Code of request result as a string: "+trade.ResultRetcodeDescription());
Print("Deal ticket: "+IntegerToString(trade.ResultDeal())+", "+
"Order ticket: "+IntegerToString(trade.ResultOrder())+", "+
"Order retcode external: "+IntegerToString(trade.ResultRetcodeExternal())+", "+
"Volume of deal or order: "+DoubleToString(trade.ResultVolume(),2));
Print("Price, confirmed by broker: "+DoubleToString(trade.ResultPrice(),symbol.Digits())+", "+
"Current bid price: "+DoubleToString(symbol.Bid(),symbol.Digits())+" (the requote): "+DoubleToString(trade.ResultBid(),symbol.Digits())+", "+
"Current ask price: "+DoubleToString(symbol.Ask(),symbol.Digits())+" (the requote): "+DoubleToString(trade.ResultAsk(),symbol.Digits()));
Print("Broker comment: "+trade.ResultComment());
}
//+------------------------------------------------------------------+
//| Get value of buffers |
//+------------------------------------------------------------------+
bool iGetArray(const int handle,const int buffer,const int start_pos,
const int count,double &arr_buffer[])
{
bool result=true;
if(!ArrayIsDynamic(arr_buffer))
{
if(InpPrintLog)
PrintFormat("ERROR! EA: %s, FUNCTION: %s, this a no dynamic array!",__FILE__,__FUNCTION__);
return(false);
}
ArrayFree(arr_buffer);
//--- reset error code
ResetLastError();
//--- fill a part of the iBands array with values from the indicator buffer
int copied=CopyBuffer(handle,buffer,start_pos,count,arr_buffer);
if(copied!=count)
{
//--- if the copying fails, tell the error code
if(InpPrintLog)
PrintFormat("ERROR! EA: %s, FUNCTION: %s, amount to copy: %d, copied: %d, error code %d",
__FILE__,__FUNCTION__,count,copied,GetLastError());
//--- quit with zero result - it means that the indicator is considered as not calculated
return(false);
}
return(result);
}
//+------------------------------------------------------------------+
//| Trailing |
//| InpTrailingStop: min distance from price to Stop Loss |
//+------------------------------------------------------------------+
void Trailing(const double stop_level)
{
/*
Buying is done at the Ask price | Selling is done at the Bid price
------------------------------------------------|----------------------------------
TakeProfit >= Bid | TakeProfit <= Ask
StopLoss <= Bid | StopLoss >= Ask
TakeProfit - Bid >= SYMBOL_TRADE_STOPS_LEVEL | Ask - TakeProfit >= SYMBOL_TRADE_STOPS_LEVEL
Bid - StopLoss >= SYMBOL_TRADE_STOPS_LEVEL | StopLoss - Ask >= SYMBOL_TRADE_STOPS_LEVEL
*/
if(InpTrailingStop==0)
return;
for(int i=PositionsTotal()-1; i>=0; i--) // returns the number of open positions
if(m_position.SelectByIndex(i))
if(m_position.Symbol()==m_symbol.Name() && m_position.Magic()==InpMagic)
{
double price_current = m_position.PriceCurrent();
double price_open = m_position.PriceOpen();
double stop_loss = m_position.StopLoss();
double take_profit = m_position.TakeProfit();
double ask = m_symbol.Ask();
double bid = m_symbol.Bid();
//---
if(m_position.PositionType()==POSITION_TYPE_BUY)
{
if(price_current-price_open>m_trailing_stop+m_trailing_step)
if(stop_loss<price_current-(m_trailing_stop+m_trailing_step))
if(m_trailing_stop>=stop_level && (take_profit-bid>=stop_level || take_profit==0.0))
{
if(!m_trade.PositionModify(m_position.Ticket(),
m_symbol.NormalizePrice(price_current-m_trailing_stop),
take_profit))
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", ERROR: ","Modify BUY ",m_position.Ticket(),
" Position -> false. Result Retcode: ",m_trade.ResultRetcode(),
", description of result: ",m_trade.ResultRetcodeDescription());
if(InpPrintLog)
{
RefreshRates();
m_position.SelectByIndex(i);
PrintResultModify(m_trade,m_symbol,m_position);
}
continue;
}
}
else
{
if(price_open-price_current>m_trailing_stop+m_trailing_step)
if((stop_loss>(price_current+(m_trailing_stop+m_trailing_step))) || (stop_loss==0))
if(m_trailing_stop>=stop_level && ask-take_profit>=stop_level)
{
if(!m_trade.PositionModify(m_position.Ticket(),
m_symbol.NormalizePrice(price_current+m_trailing_stop),
take_profit))
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", ERROR: ","Modify SELL ",m_position.Ticket(),
" Position -> false. Result Retcode: ",m_trade.ResultRetcode(),
", description of result: ",m_trade.ResultRetcodeDescription());
if(InpPrintLog)
{
RefreshRates();
m_position.SelectByIndex(i);
PrintResultModify(m_trade,m_symbol,m_position);
}
}
}
}
}
//+------------------------------------------------------------------+
//| Print CTrade result |
//+------------------------------------------------------------------+
void PrintResultModify(CTrade &trade,CSymbolInfo &symbol,CPositionInfo &position)
{
Print("File: ",__FILE__,", symbol: ",symbol.Name());
Print("Code of request result: "+IntegerToString(trade.ResultRetcode()));
Print("code of request result as a string: "+trade.ResultRetcodeDescription());
Print("Deal ticket: "+IntegerToString(trade.ResultDeal()));
Print("Order ticket: "+IntegerToString(trade.ResultOrder()));
Print("Volume of deal or order: "+DoubleToString(trade.ResultVolume(),2));
Print("Price, confirmed by broker: "+DoubleToString(trade.ResultPrice(),symbol.Digits()));
Print("Current bid price: "+DoubleToString(symbol.Bid(),symbol.Digits())+" (the requote): "+DoubleToString(trade.ResultBid(),symbol.Digits()));
Print("Current ask price: "+DoubleToString(symbol.Ask(),symbol.Digits())+" (the requote): "+DoubleToString(trade.ResultAsk(),symbol.Digits()));
Print("Broker comment: "+trade.ResultComment());
Print("Freeze Level: "+DoubleToString(symbol.FreezeLevel(),0),", Stops Level: "+DoubleToString(symbol.StopsLevel(),0));
Print("Price of position opening: "+DoubleToString(position.PriceOpen(),symbol.Digits()));
Print("Price of position's Stop Loss: "+DoubleToString(position.StopLoss(),symbol.Digits()));
Print("Price of position's Take Profit: "+DoubleToString(position.TakeProfit(),symbol.Digits()));
Print("Current price by position: "+DoubleToString(position.PriceCurrent(),symbol.Digits()));
}
//+------------------------------------------------------------------+
//| Close positions |
//+------------------------------------------------------------------+
void ClosePositions(const ENUM_POSITION_TYPE pos_type,const double level)
{
/*
Buying is done at the Ask price | Selling is done at the Bid price
------------------------------------------------|----------------------------------
TakeProfit >= Bid | TakeProfit <= Ask
StopLoss <= Bid | StopLoss >= Ask
TakeProfit - Bid >= SYMBOL_TRADE_STOPS_LEVEL | Ask - TakeProfit >= SYMBOL_TRADE_STOPS_LEVEL
Bid - StopLoss >= SYMBOL_TRADE_STOPS_LEVEL | StopLoss - Ask >= SYMBOL_TRADE_STOPS_LEVEL
*/
for(int i=PositionsTotal()-1; i>=0; i--) // returns the number of current positions
if(m_position.SelectByIndex(i)) // selects the position by index for further access to its properties
if(m_position.Symbol()==m_symbol.Name() && m_position.Magic()==InpMagic)
if(m_position.PositionType()==pos_type)
{
if(m_position.PositionType()==POSITION_TYPE_BUY)
{
bool take_profit_level=(m_position.TakeProfit()!=0.0 && m_position.TakeProfit()-m_position.PriceCurrent()>=level) || m_position.TakeProfit()==0.0;
bool stop_loss_level=(m_position.StopLoss()!=0.0 && m_position.PriceCurrent()-m_position.StopLoss()>=level) || m_position.StopLoss()==0.0;
if(take_profit_level && stop_loss_level)
if(!m_trade.PositionClose(m_position.Ticket())) // close a position by the specified m_symbol
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", ERROR: ","CTrade.PositionClose ",m_position.Ticket());
}
if(m_position.PositionType()==POSITION_TYPE_SELL)
{
bool take_profit_level=(m_position.TakeProfit()!=0.0 && m_position.PriceCurrent()-m_position.TakeProfit()>=level) || m_position.TakeProfit()==0.0;
bool stop_loss_level=(m_position.StopLoss()!=0.0 && m_position.StopLoss()-m_position.PriceCurrent()>=level) || m_position.StopLoss()==0.0;
if(!m_trade.PositionClose(m_position.Ticket())) // close a position by the specified m_symbol
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", ERROR: ","CTrade.PositionClose ",m_position.Ticket());
}
}
}
//+------------------------------------------------------------------+
//| Calculate all positions |
//+------------------------------------------------------------------+
void CalculateAllPositions(int &count_buys,double &volume_buys,double &volume_biggest_buys,
int &count_sells,double &volume_sells,double &volume_biggest_sells)
{
count_buys = 0;
volume_buys = 0.0;
volume_biggest_buys = 0.0;
count_sells = 0;
volume_sells = 0.0;
volume_biggest_sells = 0.0;
for(int i=PositionsTotal()-1; i>=0; i--)
if(m_position.SelectByIndex(i)) // selects the position by index for further access to its properties
if(m_position.Symbol()==m_symbol.Name() && m_position.Magic()==InpMagic)
{
if(m_position.PositionType()==POSITION_TYPE_BUY)
{
count_buys++;
volume_buys+=m_position.Volume();
if(m_position.Volume()>volume_biggest_buys)
volume_biggest_buys=m_position.Volume();
continue;
}
else
if(m_position.PositionType()==POSITION_TYPE_SELL)
{
count_sells++;
volume_sells+=m_position.Volume();
if(m_position.Volume()>volume_biggest_sells)
volume_biggest_sells=m_position.Volume();
}
}
}
//+------------------------------------------------------------------+
//| Search trading signals |
//+------------------------------------------------------------------+
bool SearchTradingSignals(void)
{
if(IsPositionExists())
return(true);
double ma_fast[],ma_slow[];
ArraySetAsSeries(ma_fast,true);
ArraySetAsSeries(ma_slow,true);
int start_pos=0,count=3;
if(!iGetArray(handle_iMA_Fast,0,start_pos,count,ma_fast) ||
!iGetArray(handle_iMA_Slow,0,start_pos,count,ma_slow))
{
return(false);
}
int size_need_position=ArraySize(SPosition);
if(size_need_position>0)
{
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", Size SPosition: ",IntegerToString(size_need_position));
return(true);
}
if(ma_fast[2]<ma_slow[2] && ma_fast[1]>ma_slow[1])
{
if(!InpReverse)
{
ArrayResize(SPosition,size_need_position+1);
SPosition[size_need_position].pos_type=POSITION_TYPE_BUY;
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", OK: ","Signal BUY");
return(true);
}
else
{
ArrayResize(SPosition,size_need_position+1);
SPosition[size_need_position].pos_type=POSITION_TYPE_SELL;
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", OK: ","Signal SELL");
return(true);
}
}
if(ma_fast[2]>ma_slow[2] && ma_fast[1]<ma_slow[1])
{
if(!InpReverse)
{
ArrayResize(SPosition,size_need_position+1);
SPosition[size_need_position].pos_type=POSITION_TYPE_SELL;
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", OK: ","Signal SELL");
return(true);
}
else
{
ArrayResize(SPosition,size_need_position+1);
SPosition[size_need_position].pos_type=POSITION_TYPE_BUY;
if(InpPrintLog)
Print(__FILE__," ",__FUNCTION__,", OK: ","Signal BUY");
return(true);
}
}
//---
return(true);
}
//+------------------------------------------------------------------+
//| Is position exists |
//+------------------------------------------------------------------+
bool IsPositionExists(void)
{
for(int i=PositionsTotal()-1; i>=0; i--)
if(m_position.SelectByIndex(i)) // selects the position by index for further access to its properties
if(m_position.Symbol()==m_symbol.Name() && m_position.Magic()==InpMagic)
return(true);
//---
return(false);
}
//+------------------------------------------------------------------+
Comments