796 lines
69 KiB
MQL5
796 lines
69 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| EA AlligatorAndStochastic.mq5 |
|
|
//| Copyright © 2018, Vladimir Karputov |
|
|
//| http://wmua.ru/slesar/ |
|
|
//+------------------------------------------------------------------+
|
|
#property version "1.011"
|
|
//---
|
|
#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; // trade position object
|
|
CTrade m_trade; // trading object
|
|
CSymbolInfo m_symbol; // symbol info object
|
|
CAccountInfo m_account; // account info wrapper
|
|
CDealInfo m_deal; // deals object
|
|
COrderInfo m_order; // pending orders object
|
|
CMoneyFixedMargin *m_money;
|
|
//--- input parameters
|
|
input int Inp_Alligator_jaw_period = 13; // Alligator: period for the calculation of jaws
|
|
input int Inp_Alligator_jaw_shift = 8; // Alligator: horizontal shift of jaws
|
|
input int Inp_Alligator_teeth_period = 8; // Alligator: period for the calculation of teeth
|
|
input int Inp_Alligator_teeth_shift = 5; // Alligator: horizontal shift of teeth
|
|
input int Inp_Alligator_lips_period = 5; // Alligator: period for the calculation of lips
|
|
input int Inp_Alligator_lips_shift = 3; // Alligator: horizontal shift of lips
|
|
input ENUM_MA_METHOD Inp_Alligator_ma_method = MODE_SMMA; // Alligator: type of smoothing
|
|
input ENUM_APPLIED_PRICE Inp_Alligator_applied_price= PRICE_MEDIAN;// Alligator: type of price
|
|
//---
|
|
input int Inp_Stochastic_Kperiod = 5; // Stochastic: K-period (number of bars for calculations)
|
|
input int Inp_Stochastic_Dperiod = 3; // Stochastic: D-period (period of first smoothing)
|
|
input int Inp_Stochastic_slowing = 3; // Stochastic: final smoothing
|
|
input ENUM_MA_METHOD Inp_Stochastic_ma_method = MODE_SMA; // Stochastic: type of smoothing
|
|
input ENUM_STO_PRICE Inp_Stochastic_price_field = STO_LOWHIGH; // Stochastic: stochastic calculation method
|
|
//---
|
|
input datetime Inp_time_open_start = D'1970.01.01 03:14:00'; // Time to open positions (start)
|
|
input datetime Inp_time_open_end = D'1970.01.01 10:30:00'; // Time to open positions (end)
|
|
input datetime Inp_time_close_start = D'1970.01.01 19:59:00'; // Time to close positions (start)
|
|
input datetime Inp_time_close_end = D'1970.01.01 21:59:00'; // Time to close positions (end)
|
|
//---
|
|
input bool InpIncreasePosition = true; // Increase position
|
|
input ushort InpStopLoss = 50; // Stop Loss (in pips)
|
|
input ushort InpTakeProfit = 50; // Take Profit (in pips)
|
|
input ushort InpTrailingStop = 15; // Trailing Stop (in pips)
|
|
input ushort InpTrailingStep = 5; // Trailing Step (in pips)
|
|
input double InpLots = 0; // Lots (or "Lots">0 and "Risk"==0 or "Lots"==0 and "Risk">0)
|
|
input double Risk = 5; // Risk (or "Lots">0 and "Risk"==0 or "Lots"==0 and "Risk">0)
|
|
input ulong m_magic = 461619162; // magic number
|
|
//---
|
|
ulong m_slippage=10; // slippage
|
|
|
|
double ExtStopLoss=0.0;
|
|
double ExtTakeProfit=0.0;
|
|
double ExtTrailingStop=0.0;
|
|
double ExtTrailingStep=0.0;
|
|
|
|
int handle_iStochastic; // variable for storing the handle of the iStochastic indicator
|
|
int handle_iAlligator; // variable for storing the handle of the iAlligator indicator
|
|
int handle_iCustom; // variable for storing the handle of the iCustom indicator
|
|
|
|
double m_adjusted_point; // point value adjusted for 3 or 5 points
|
|
//---
|
|
MqlDateTime SOpenStart;
|
|
MqlDateTime SOpenEnd;
|
|
MqlDateTime SCloseStart;
|
|
MqlDateTime SCloseEnd;
|
|
long open_start;
|
|
long open_end;
|
|
long close_start;
|
|
long close_end;
|
|
//+------------------------------------------------------------------+
|
|
//| Expert initialization function |
|
|
//+------------------------------------------------------------------+
|
|
int OnInit()
|
|
{
|
|
//--- check input parameters
|
|
TimeToStruct(Inp_time_open_start,SOpenStart);
|
|
TimeToStruct(Inp_time_open_end,SOpenEnd);
|
|
TimeToStruct(Inp_time_close_start,SCloseStart);
|
|
TimeToStruct(Inp_time_close_end,SCloseEnd);
|
|
open_start = SOpenStart.hour*3600+SOpenStart.min*60+SOpenStart.sec;
|
|
open_end = SOpenEnd.hour*3600+SOpenEnd.min*60+SOpenEnd.sec;
|
|
close_start = SCloseStart.hour*3600+SCloseStart.min*60+SCloseStart.sec;
|
|
close_end = SCloseEnd.hour*3600+SCloseEnd.min*60+SCloseEnd.sec;
|
|
if(open_start>=open_end)
|
|
{
|
|
Print(__FUNCTION__,
|
|
" ERROR: \"Time to open positions start\" (",TimeToString(Inp_time_open_start,TIME_SECONDS),
|
|
") >= \"Time to open positions end\" (",TimeToString(Inp_time_open_end,TIME_SECONDS),")");
|
|
return(INIT_PARAMETERS_INCORRECT);
|
|
}
|
|
if(close_start>=close_end)
|
|
{
|
|
Print(__FUNCTION__,
|
|
" ERROR: \"Time to close positions start\" (",TimeToString(Inp_time_close_start,TIME_SECONDS),
|
|
") >= \"Time to close positions end\" (",TimeToString(Inp_time_close_end,TIME_SECONDS),")");
|
|
return(INIT_PARAMETERS_INCORRECT);
|
|
}
|
|
if(open_end>=close_start)
|
|
{
|
|
Print(__FUNCTION__,
|
|
" ERROR: \"Time to open positions end\" (",TimeToString(Inp_time_open_end,TIME_SECONDS),
|
|
") >= \"Time to close positions start\" (",TimeToString(Inp_time_close_start,TIME_SECONDS),")");
|
|
return(INIT_PARAMETERS_INCORRECT);
|
|
}
|
|
//--- print time's
|
|
Print("\"Time to open positions start\": ",TimeToString(Inp_time_open_start,TIME_SECONDS));
|
|
Print("\"Time to open positions end\" : ",TimeToString(Inp_time_open_end,TIME_SECONDS));
|
|
Print("\"Time to close positions start\": ",TimeToString(Inp_time_close_start,TIME_SECONDS));
|
|
Print("\"Time to close positions end\" : ",TimeToString(Inp_time_close_end,TIME_SECONDS));
|
|
Print("//---");
|
|
//--- create timer
|
|
EventSetTimer(60);
|
|
//---
|
|
if(InpTrailingStop!=0 && InpTrailingStep==0)
|
|
{
|
|
Alert(__FUNCTION__," ERROR: Trailing is not possible: the parameter \"Trailing Step\" is zero!");
|
|
return(INIT_PARAMETERS_INCORRECT);
|
|
}
|
|
//---
|
|
if(!m_symbol.Name(Symbol())) // sets symbol name
|
|
return(INIT_FAILED);
|
|
RefreshRates();
|
|
//---
|
|
m_trade.SetExpertMagicNumber(m_magic);
|
|
m_trade.SetMarginMode();
|
|
m_trade.SetTypeFillingBySymbol(m_symbol.Name());
|
|
m_trade.SetDeviationInPoints(m_slippage);
|
|
//--- 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;
|
|
|
|
ExtStopLoss = InpStopLoss * m_adjusted_point;
|
|
ExtTakeProfit = InpTakeProfit * m_adjusted_point;
|
|
ExtTrailingStop = InpTrailingStop * m_adjusted_point;
|
|
ExtTrailingStep = InpTrailingStep * m_adjusted_point;
|
|
//---
|
|
if(!LotsOrRisk(InpLots,Risk,digits_adjust))
|
|
return(INIT_PARAMETERS_INCORRECT);
|
|
//---
|
|
if(m_money!=NULL)
|
|
delete m_money;
|
|
m_money=new CMoneyFixedMargin;
|
|
if(m_money!=NULL)
|
|
{
|
|
if(!m_money.Init(GetPointer(m_symbol),Period(),m_symbol.Point()*digits_adjust))
|
|
return(INIT_FAILED);
|
|
m_money.Percent(Risk);
|
|
}
|
|
else
|
|
{
|
|
Print(__FUNCTION__,", ERROR: Object CMoneyFixedMargin is NULL");
|
|
return(INIT_FAILED);
|
|
}
|
|
//--- create handle of the indicator iStochastic
|
|
handle_iStochastic=iStochastic(m_symbol.Name(),Period(),
|
|
Inp_Stochastic_Kperiod,Inp_Stochastic_Dperiod,Inp_Stochastic_slowing
|
|
,Inp_Stochastic_ma_method,Inp_Stochastic_price_field);
|
|
//--- if the handle is not created
|
|
if(handle_iStochastic==INVALID_HANDLE)
|
|
{
|
|
//--- tell about the failure and output the error code
|
|
PrintFormat("Failed to create handle of the iStochastic indicator 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 iAlligator
|
|
handle_iAlligator=iAlligator(m_symbol.Name(),Period(),
|
|
Inp_Alligator_jaw_period,Inp_Alligator_jaw_shift,
|
|
Inp_Alligator_teeth_period,Inp_Alligator_teeth_shift,
|
|
Inp_Alligator_lips_period,Inp_Alligator_lips_shift,
|
|
Inp_Alligator_ma_method,Inp_Alligator_applied_price);
|
|
//--- if the handle is not created
|
|
if(handle_iAlligator==INVALID_HANDLE)
|
|
{
|
|
//--- tell about the failure and output the error code
|
|
PrintFormat("Failed to create handle of the iAlligator indicator 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 iCustom
|
|
// MQL5\Shared Projects\AlligatorAndStochastic\AlligatorAndStochastic rectangles.mq5
|
|
handle_iCustom=iCustom(m_symbol.Name(),Period(),"Shared Projects\\AlligatorAndStochastic\\AlligatorAndStochastic rectangles",
|
|
Inp_Alligator_jaw_period,
|
|
Inp_Alligator_jaw_shift,
|
|
Inp_Alligator_teeth_period,
|
|
Inp_Alligator_teeth_shift,
|
|
Inp_Alligator_lips_period,
|
|
Inp_Alligator_lips_shift,
|
|
Inp_Alligator_ma_method,
|
|
Inp_Alligator_applied_price,
|
|
Inp_Stochastic_Kperiod,
|
|
Inp_Stochastic_Dperiod,
|
|
Inp_Stochastic_slowing,
|
|
Inp_Stochastic_ma_method,
|
|
Inp_Stochastic_price_field,
|
|
Inp_time_open_start,
|
|
Inp_time_open_end,
|
|
Inp_time_close_start,
|
|
Inp_time_close_end);
|
|
//--- if the handle is not created
|
|
if(handle_iCustom==INVALID_HANDLE)
|
|
{
|
|
//--- tell about the failure and output the error code
|
|
PrintFormat("Failed to create handle of the iCustom indicator 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)
|
|
{
|
|
//--- destroy timer
|
|
EventKillTimer();
|
|
//---
|
|
if(m_money!=NULL)
|
|
delete m_money;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Expert tick function |
|
|
//+------------------------------------------------------------------+
|
|
void OnTick()
|
|
{
|
|
//--- we work only at the time of the birth of new bar
|
|
static datetime PrevBars=0;
|
|
datetime time_0=Time(0);
|
|
|
|
MqlDateTime STime;
|
|
TimeToStruct(PrevBars,STime);
|
|
long time = STime.hour*3600+STime.min*60+STime.sec;
|
|
bool open_time = (time>=open_start && time<open_end);
|
|
bool close_time = (time>=close_start && time<close_end);
|
|
if(time>open_end && time<close_end)
|
|
Trailing();
|
|
|
|
if(time_0==PrevBars)
|
|
return;
|
|
PrevBars=time_0;
|
|
|
|
if(!RefreshRates())
|
|
{
|
|
PrevBars=0;
|
|
return;
|
|
}
|
|
|
|
int count_buys=0;
|
|
int count_sells=0;
|
|
CalculatePositions(count_buys,count_sells);
|
|
double StochasticMain = iStochasticGet(MAIN_LINE,0);
|
|
double AlligatorJaw = iAlligatorGet(GATORJAW_LINE,0);
|
|
double AlligatorTeeth = iAlligatorGet(GATORTEETH_LINE,0);
|
|
double AlligatorLips = iAlligatorGet(GATORLIPS_LINE,0);
|
|
|
|
if(open_time/* && count_buys+count_sells==0*/)
|
|
{
|
|
if(StochasticMain>80.0 &&
|
|
(m_symbol.Ask()>AlligatorJaw && m_symbol.Ask()>AlligatorTeeth && m_symbol.Ask()>AlligatorLips) &&
|
|
((!InpIncreasePosition && count_sells==0) || (InpIncreasePosition)))
|
|
{
|
|
//--- защита: если уже был противоположный вход - то не открываем
|
|
if(count_buys==0)
|
|
{
|
|
double sl=(InpStopLoss==0)?0.0:m_symbol.Bid()+ExtStopLoss;
|
|
double tp=(InpTakeProfit==0)?0.0:m_symbol.Bid()-ExtTakeProfit;
|
|
OpenSell(sl,tp);
|
|
}
|
|
return;
|
|
}
|
|
if(StochasticMain<20.0 &&
|
|
(m_symbol.Bid()<AlligatorJaw && m_symbol.Bid()<AlligatorTeeth && m_symbol.Bid()<AlligatorLips) &&
|
|
((!InpIncreasePosition && count_buys==0) || (InpIncreasePosition)))
|
|
{
|
|
//--- защита: если уже был противоположный вход - то не открываем
|
|
if(count_sells==0)
|
|
{
|
|
double sl=(InpStopLoss==0)?0.0:m_symbol.Ask()-ExtStopLoss;
|
|
double tp=(InpTakeProfit==0)?0.0:m_symbol.Ask()+ExtTakeProfit;
|
|
OpenBuy(sl,tp);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
//---
|
|
if(close_time)
|
|
{
|
|
if(count_buys>0 && StochasticMain>80.0)
|
|
ClosePositions(POSITION_TYPE_BUY);
|
|
if(count_sells>0 && StochasticMain<20.0)
|
|
ClosePositions(POSITION_TYPE_SELL);
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Timer function |
|
|
//+------------------------------------------------------------------+
|
|
void OnTimer()
|
|
{
|
|
//---
|
|
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| TradeTransaction function |
|
|
//+------------------------------------------------------------------+
|
|
void OnTradeTransaction(const MqlTradeTransaction &trans,
|
|
const MqlTradeRequest &request,
|
|
const MqlTradeResult &result)
|
|
{
|
|
double res=0.0;
|
|
int losses=0.0;
|
|
//--- 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;
|
|
if(deal_symbol==m_symbol.Name() && deal_magic==m_magic)
|
|
{
|
|
if(deal_entry==DEAL_ENTRY_IN)
|
|
{
|
|
int d=0;
|
|
}
|
|
if(deal_entry==DEAL_ENTRY_OUT)
|
|
{
|
|
if(deal_profit>0)
|
|
{
|
|
res=InpLots;
|
|
losses=0;
|
|
}
|
|
else
|
|
{
|
|
res=deal_volume*1.63;
|
|
losses++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Refreshes the symbol quotes data |
|
|
//+------------------------------------------------------------------+
|
|
bool RefreshRates(void)
|
|
{
|
|
//--- refresh rates
|
|
if(!m_symbol.RefreshRates())
|
|
{
|
|
Print("RefreshRates error");
|
|
return(false);
|
|
}
|
|
//--- protection against the return value of "zero"
|
|
if(m_symbol.Ask()==0 || m_symbol.Bid()==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)
|
|
{
|
|
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)
|
|
{
|
|
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)
|
|
{
|
|
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);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Lots or risk in percent for a deal from a free margin |
|
|
//+------------------------------------------------------------------+
|
|
bool LotsOrRisk(const double lots,const double risk,const int digits_adjust)
|
|
{
|
|
if(lots<0.0 && risk<0.0)
|
|
{
|
|
Print(__FUNCTION__,", ERROR: Parameter (\"lots\" or \"risk\") can't be less than zero");
|
|
return(false);
|
|
}
|
|
if(lots==0.0 && risk==0.0)
|
|
{
|
|
Print(__FUNCTION__,", ERROR: Trade is impossible: You have set \"lots\" == 0.0 and \"risk\" == 0.0");
|
|
return(false);
|
|
}
|
|
if(lots>0.0 && risk>0.0)
|
|
{
|
|
Print(__FUNCTION__,", ERROR: Trade is impossible: You have set \"lots\" > 0.0 and \"risk\" > 0.0");
|
|
return(false);
|
|
}
|
|
if(lots>0.0)
|
|
{
|
|
string err_text="";
|
|
if(!CheckVolumeValue(lots,err_text))
|
|
{
|
|
Print(__FUNCTION__,", ERROR: ",err_text);
|
|
return(false);
|
|
}
|
|
}
|
|
else
|
|
if(risk>0.0)
|
|
{
|
|
if(m_money!=NULL)
|
|
delete m_money;
|
|
m_money=new CMoneyFixedMargin;
|
|
if(m_money!=NULL)
|
|
{
|
|
if(!m_money.Init(GetPointer(m_symbol),Period(),m_symbol.Point()*digits_adjust))
|
|
return(false);
|
|
m_money.Percent(risk);
|
|
}
|
|
else
|
|
{
|
|
Print(__FUNCTION__,", ERROR: Object CMoneyFixedMargin is NULL");
|
|
return(false);
|
|
}
|
|
}
|
|
//---
|
|
return(true);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get Time for specified bar index |
|
|
//+------------------------------------------------------------------+
|
|
datetime Time(const int index,string symbol=NULL,ENUM_TIMEFRAMES timeframe=PERIOD_CURRENT)
|
|
{
|
|
if(symbol==NULL)
|
|
symbol=m_symbol.Name();
|
|
if(timeframe==0)
|
|
timeframe=Period();
|
|
datetime Time[1];
|
|
datetime time=0; // datetime "0" -> D'1970.01.01 00:00:00'
|
|
int copied=CopyTime(symbol,timeframe,index,1,Time);
|
|
if(copied>0)
|
|
time=Time[0];
|
|
return(time);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get value of buffers for the iStochastic |
|
|
//| the buffer numbers are the following: |
|
|
//| 0 - MAIN_LINE, 1 - SIGNAL_LINE |
|
|
//+------------------------------------------------------------------+
|
|
double iStochasticGet(const int buffer,const int index)
|
|
{
|
|
double Stochastic[1];
|
|
//--- reset error code
|
|
ResetLastError();
|
|
//--- fill a part of the iStochasticBuffer array with values from the indicator buffer that has 0 index
|
|
if(CopyBuffer(handle_iStochastic,buffer,index,1,Stochastic)<0)
|
|
{
|
|
//--- if the copying fails, tell the error code
|
|
PrintFormat("Failed to copy data from the iStochastic indicator, error code %d",GetLastError());
|
|
//--- quit with zero result - it means that the indicator is considered as not calculated
|
|
return(0.0);
|
|
}
|
|
return(Stochastic[0]);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Get value of buffers for the iAlligator |
|
|
//| the buffer numbers are the following: |
|
|
//| 0 - GATORJAW_LINE, 1 - GATORTEETH_LINE, 2 - GATORLIPS_LINE |
|
|
//+------------------------------------------------------------------+
|
|
double iAlligatorGet(const int buffer,const int index)
|
|
{
|
|
double Alligator[1];
|
|
//--- reset error code
|
|
ResetLastError();
|
|
//--- fill a part of the iStochasticBuffer array with values from the indicator buffer that has 0 index
|
|
if(CopyBuffer(handle_iAlligator,buffer,index,1,Alligator)<0)
|
|
{
|
|
//--- if the copying fails, tell the error code
|
|
PrintFormat("Failed to copy data from the iAlligator indicator, error code %d",GetLastError());
|
|
//--- quit with zero result - it means that the indicator is considered as not calculated
|
|
return(0.0);
|
|
}
|
|
return(Alligator[0]);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Open Buy position |
|
|
//+------------------------------------------------------------------+
|
|
void OpenBuy(double sl,double tp)
|
|
{
|
|
sl=m_symbol.NormalizePrice(sl);
|
|
tp=m_symbol.NormalizePrice(tp);
|
|
|
|
double check_open_long_lot=0.0;
|
|
if(Risk>0.0)
|
|
{
|
|
check_open_long_lot=m_money.CheckOpenLong(m_symbol.Ask(),sl);
|
|
Print("sl=",DoubleToString(sl,m_symbol.Digits()),
|
|
", CheckOpenLong: ",DoubleToString(check_open_long_lot,2),
|
|
", Balance: ", DoubleToString(m_account.Balance(),2),
|
|
", Equity: ", DoubleToString(m_account.Equity(),2),
|
|
", FreeMargin: ", DoubleToString(m_account.FreeMargin(),2));
|
|
if(check_open_long_lot==0.0)
|
|
{
|
|
Print(__FUNCTION__,", ERROR: method CheckOpenLong returned the value of \"0.0\"");
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
check_open_long_lot=InpLots;
|
|
//--- check volume before OrderSend to avoid "not enough money" error (CTrade)
|
|
double check_volume_lot=m_trade.CheckVolume(m_symbol.Name(),check_open_long_lot,m_symbol.Ask(),ORDER_TYPE_BUY);
|
|
|
|
if(check_volume_lot!=0.0)
|
|
{
|
|
if(check_volume_lot>=check_open_long_lot)
|
|
{
|
|
if(m_trade.Buy(check_open_long_lot,NULL,m_symbol.Ask(),sl,tp))
|
|
{
|
|
if(m_trade.ResultDeal()==0)
|
|
{
|
|
Print("#1 Buy -> false. Result Retcode: ",m_trade.ResultRetcode(),
|
|
", description of result: ",m_trade.ResultRetcodeDescription());
|
|
PrintResult(m_trade,m_symbol);
|
|
}
|
|
else
|
|
{
|
|
Print("#2 Buy -> true. Result Retcode: ",m_trade.ResultRetcode(),
|
|
", description of result: ",m_trade.ResultRetcodeDescription());
|
|
PrintResult(m_trade,m_symbol);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Print("#3 Buy -> false. Result Retcode: ",m_trade.ResultRetcode(),
|
|
", description of result: ",m_trade.ResultRetcodeDescription());
|
|
PrintResult(m_trade,m_symbol);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string text="";
|
|
if(Risk>0.0)
|
|
text="< method CheckOpenLong ("+DoubleToString(check_open_long_lot,2)+")";
|
|
else
|
|
text="< Lots ("+DoubleToString(InpLots,2)+")";
|
|
Print(__FUNCTION__,", ERROR: method CheckVolume (",DoubleToString(check_volume_lot,2),") ",
|
|
text);
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Print(__FUNCTION__,", ERROR: method CheckVolume returned the value of \"0.0\"");
|
|
return;
|
|
}
|
|
//---
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Open Sell position |
|
|
//+------------------------------------------------------------------+
|
|
void OpenSell(double sl,double tp)
|
|
{
|
|
sl=m_symbol.NormalizePrice(sl);
|
|
tp=m_symbol.NormalizePrice(tp);
|
|
|
|
double check_open_short_lot=0.0;
|
|
if(Risk>0.0)
|
|
{
|
|
check_open_short_lot=m_money.CheckOpenShort(m_symbol.Bid(),sl);
|
|
Print("sl=",DoubleToString(sl,m_symbol.Digits()),
|
|
", CheckOpenLong: ",DoubleToString(check_open_short_lot,2),
|
|
", Balance: ", DoubleToString(m_account.Balance(),2),
|
|
", Equity: ", DoubleToString(m_account.Equity(),2),
|
|
", FreeMargin: ", DoubleToString(m_account.FreeMargin(),2));
|
|
if(check_open_short_lot==0.0)
|
|
{
|
|
Print(__FUNCTION__,", ERROR: method CheckOpenShort returned the value of \"0.0\"");
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
check_open_short_lot=InpLots;
|
|
//--- check volume before OrderSend to avoid "not enough money" error (CTrade)
|
|
double check_volume_lot=m_trade.CheckVolume(m_symbol.Name(),check_open_short_lot,m_symbol.Bid(),ORDER_TYPE_SELL);
|
|
|
|
if(check_volume_lot!=0.0)
|
|
{
|
|
if(check_volume_lot>=check_open_short_lot)
|
|
{
|
|
if(m_trade.Sell(check_open_short_lot,NULL,m_symbol.Bid(),sl,tp))
|
|
{
|
|
if(m_trade.ResultDeal()==0)
|
|
{
|
|
Print("#1 Sell -> false. Result Retcode: ",m_trade.ResultRetcode(),
|
|
", description of result: ",m_trade.ResultRetcodeDescription());
|
|
PrintResult(m_trade,m_symbol);
|
|
}
|
|
else
|
|
{
|
|
Print("#2 Sell -> true. Result Retcode: ",m_trade.ResultRetcode(),
|
|
", description of result: ",m_trade.ResultRetcodeDescription());
|
|
PrintResult(m_trade,m_symbol);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Print("#3 Sell -> false. Result Retcode: ",m_trade.ResultRetcode(),
|
|
", description of result: ",m_trade.ResultRetcodeDescription());
|
|
PrintResult(m_trade,m_symbol);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string text="";
|
|
if(Risk>0.0)
|
|
text="< method CheckOpenShort ("+DoubleToString(check_open_short_lot,2)+")";
|
|
else
|
|
text="< Lots ("+DoubleToString(InpLots,2)+")";
|
|
Print(__FUNCTION__,", ERROR: method CheckVolume (",DoubleToString(InpLots,2),") ",
|
|
text);
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Print(__FUNCTION__,", ERROR: method CheckVolume returned the value of \"0.0\"");
|
|
return;
|
|
}
|
|
//---
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Print CTrade result |
|
|
//+------------------------------------------------------------------+
|
|
void PrintResult(CTrade &trade,CSymbolInfo &symbol)
|
|
{
|
|
Print("Code of request result: "+IntegerToString(trade.ResultRetcode()));
|
|
Print("code of request result: "+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(trade.ResultBid(),symbol.Digits()));
|
|
Print("current ask price: "+DoubleToString(trade.ResultAsk(),symbol.Digits()));
|
|
Print("broker comment: "+trade.ResultComment());
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| 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()==m_magic)
|
|
return(true);
|
|
//---
|
|
return(false);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Calculate positions Buy and Sell |
|
|
//+------------------------------------------------------------------+
|
|
void CalculatePositions(int &count_buys,int &count_sells)
|
|
{
|
|
count_buys=0;
|
|
count_sells=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()==m_magic)
|
|
{
|
|
if(m_position.PositionType()==POSITION_TYPE_BUY)
|
|
count_buys++;
|
|
|
|
if(m_position.PositionType()==POSITION_TYPE_SELL)
|
|
count_sells++;
|
|
}
|
|
//---
|
|
return;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Close positions |
|
|
//+------------------------------------------------------------------+
|
|
void ClosePositions(const ENUM_POSITION_TYPE pos_type)
|
|
{
|
|
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()==m_magic)
|
|
if(m_position.PositionType()==pos_type) // gets the position type
|
|
m_trade.PositionClose(m_position.Ticket()); // close a position by the specified symbol
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Trailing |
|
|
//+------------------------------------------------------------------+
|
|
void Trailing()
|
|
{
|
|
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()==m_magic)
|
|
{
|
|
if(m_position.PositionType()==POSITION_TYPE_BUY)
|
|
{
|
|
if(m_position.PriceCurrent()-m_position.PriceOpen()>ExtTrailingStop+ExtTrailingStep)
|
|
if(m_position.StopLoss()<m_position.PriceCurrent()-(ExtTrailingStop+ExtTrailingStep))
|
|
{
|
|
if(!m_trade.PositionModify(m_position.Ticket(),
|
|
m_symbol.NormalizePrice(m_position.PriceCurrent()-ExtTrailingStop),
|
|
m_position.TakeProfit()))
|
|
Print("Modify ",m_position.Ticket(),
|
|
" Position -> false. Result Retcode: ",m_trade.ResultRetcode(),
|
|
", description of result: ",m_trade.ResultRetcodeDescription());
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(m_position.PriceOpen()-m_position.PriceCurrent()>ExtTrailingStop+ExtTrailingStep)
|
|
if((m_position.StopLoss()>(m_position.PriceCurrent()+(ExtTrailingStop+ExtTrailingStep))) ||
|
|
(m_position.StopLoss()==0))
|
|
{
|
|
if(!m_trade.PositionModify(m_position.Ticket(),
|
|
m_symbol.NormalizePrice(m_position.PriceCurrent()+ExtTrailingStop),
|
|
m_position.TakeProfit()))
|
|
Print("Modify ",m_position.Ticket(),
|
|
" Position -> false. Result Retcode: ",m_trade.ResultRetcode(),
|
|
", description of result: ",m_trade.ResultRetcodeDescription());
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|