Обучение языку MQL4 под MetaTrader 4📌

#property copyright "-"
#property link "-"
//---- отрисовка индикатора в главном окне
#property indicator_chart_window
//---- количество индикаторных буфферов
#property indicator_buffers 2
//---- цвета индикатора
#property indicator_color1 Blue
#property indicator_color2 Red
//---- входные параметры индикатора
extern int atr_period = 100;
extern double atr_k = 3;


int MA_Slow = 260;
//---- индикаторные буфферы
double buf_1[];
double buf_2[];
//+------------------------------------------------------------------+
//| Функция инициализации, запускается один раз |
//+------------------------------------------------------------------+
int init()
{
//---- 2 индикаторных буффера использованы для счёта
SetIndexBuffer(0, buf_1);
SetIndexBuffer(1, buf_2);
//---- Стиль исполнения графика
//---- DRAW_ARROW - стрелки(символы)
SetIndexStyle (0, DRAW_ARROW, STYLE_SOLID, 3);
SetIndexStyle (1, DRAW_ARROW, STYLE_SOLID, 3);
SetIndexArrow (0, 233);
SetIndexArrow (1, 234);
//---- установка значений индикатора, которые не будут видимы на графике
SetIndexEmptyValue(0,0.0);
SetIndexEmptyValue(1,0.0);
//---- установка номера бара, начиная с которого будет отрисовываться индикатор
SetIndexDrawBegin(0,MA_Slow);
SetIndexDrawBegin(1,MA_Slow);
//---- завершение инициализации
return (0);
}
//+------------------------------------------------------------------+
//| Основная Функция, запускается на каждом тике |
//+------------------------------------------------------------------+
int start()
{
//---- проверка количества баров на достаточность для расчёта
if (Bars //---- получение уже посчитанных баров
int ExtCountedBars = IndicatorCounted();
//---- проверка на возможные ошибки
if (ExtCountedBars //---- последний посчитанный бар должен быть пересчитан
if (ExtCountedBars > 0) ExtCountedBars--;
//---- основной цикл расчёта индиатора
for (int i=Bars - ExtCountedBars-1;i>=0; i--)
{
//---- получение значений индикатора в переменные

double high1 = High[1];
double low1 = Low[1];
double open1 = Open [1];
double close1 = Close [1];

double atr = iATR(Symbol(), 0, atr_period, 1);

/*
double MA_Fast_1 = iMA(NULL, 0, MA_Fast, 0, MODE_EMA, PRICE_CLOSE, i+1);
double MA_Slow_1 = iMA(NULL, 0, MA_Slow, 3, MODE_LWMA, PRICE_CLOSE, i+1);
double MA_Fast_2 = iMA(NULL, 0, MA_Fast, 0, MODE_EMA, PRICE_CLOSE, i+2);
double MA_Slow_2 = iMA(NULL, 0, MA_Slow, 3, MODE_LWMA, PRICE_CLOSE, i+2);
*/
//---- проверка условий по вашим правилам и отрисовка стрелки
// if (MA_Fast_1 > MA_Slow_1 && MA_Fast_2 // if (MA_Fast_1 = MA_Slow_2) buf_2[i+1] = High[i+1] + 10 * Point;

if(close1 {
if((high1-close1) > NormalizeDouble((atr*atr_k),5)) buf_2[i+1] = High[i+1] + 10 * Point;
}


if(close1>open1)
{
if((open1-low1) > NormalizeDouble((atr*atr_k),5)) buf_1[i+1] = Low[i+1] - 10 * Point;
}

}
//---- завершение основной функции
return (0);
}
//---- end

[

bool ModifyOrder(int mag, int otype=-1 ,string sy="")
{
double sl = 0,
tp = 0;

if (sy=="0") sy=Symbol();

for(int i=OrdersTotal()-1; i >= 0; i--)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
{
if((OrderSymbol() == sy || sy =="") && (mag {
if(otype == OP_BUY || otype == OP_SELL)
{
if(otype == OP_BUY)
{
while(true)
{
sl = High[1] - iATR(Symbol(),0,ATR_Period,ATR_Shift) * ATR_Multipler_SL;
tp = High[1] + iATR(Symbol(),0,ATR_Period,ATR_Shift) * ATR_Multipler_TP;
OrderModifyReliable(OrderTicket(),OrderOpenPrice(),sl,tp,0,clrGreenYellow);break;
}
}
else

if(otype == OP_SELL)
{
while(true)
{
sl = High[1] + iATR(Symbol(),0,ATR_Period,ATR_Shift) * ATR_Multipler_SL;
tp = High[1] - iATR(Symbol(),0,ATR_Period,ATR_Shift) * ATR_Multipler_TP;
OrderModifyReliable(OrderTicket(),OrderOpenPrice(),sl,tp,0,clrGreenYellow); break;
}

}
}
}
}
}
return(false);
}




















]

bool OrderModifyReliable(int aticket, double aprice, double stoploss,
double takeprofit, datetime expiration,
color arrow_color = CLR_NONE)
{
if (IsStopped())
{
Print("Ошибка, остановлен: IsStopped() == true");
return(false);
}

int cnt = 0;
while(!IsTradeAllowed() && cnt {
Sleep(100);
cnt++;
}
if (!IsTradeAllowed())
{
Print("Ошибка: Операция недопустима - IsTradeAllowed()==false");
_OR_err = ERR_TRADE_CONTEXT_BUSY;
return(false);
}



// if (false)
{
if(OrderSelect(aticket, SELECT_BY_TICKET, MODE_TRADES))
string asymbol = OrderSymbol();
int adigits = MarketInfo(asymbolx, MODE_DIGITS);
if (adigits > 0)
{
aprice = NormalizeDouble(aprice,adigits);
stoploss = NormalizeDouble(stoploss,adigits);
takeprofit = NormalizeDouble(takeprofit,adigits);
}
if (stoploss != 0) OrderReliable_EnsureValidStop(asymbolx,aprice,stoploss);
}

int err = GetLastError(); // so we clear the global variable.
err = 0;
_OR_err = 0;
bool exit_loop = false;
cnt = 0;
bool result = false;

while (!exit_loop)
{
if (IsTradeAllowed())
{
result = OrderModify(aticket, aprice, stoploss,
takeprofit, expiration, arrow_color);
err = GetLastError();
_OR_err = err;
}
else
cnt++;

if (result == true)
exit_loop = true;

switch (err)
{
case ERR_NO_ERROR:
exit_loop = true;
break;

case ERR_NO_RESULT:
exit_loop = true;
break;

case ERR_SERVER_BUSY:
case ERR_NO_CONNECTION:
case ERR_INVALID_PRICE:
case ERR_OFF_QUOTES:
case ERR_BROKER_BUSY:
case ERR_TRADE_CONTEXT_BUSY:
case ERR_TRADE_TIMEOUT: // for modify this is a retryable error, I hope.
cnt++; // a retryable error
break;

case ERR_PRICE_CHANGED:
case ERR_REQUOTE:
RefreshRates();
continue; // we can apparently retry immediately according to MT docs.

default:
// an apparently serious, unretryable error.
exit_loop = true;
break;

} // end switch

if (cnt > retries)
exit_loop = true;

if (!exit_loop)
{
Print("Ошибка, попыток: (" + IntegerToString(cnt) + "/" + IntegerToString(retries) +
"): " + OrderReliableErrTxt(err));
Sleep(500);
RefreshRates();
}

if (exit_loop)
{
if ((err != ERR_NO_ERROR) && (err != ERR_NO_RESULT))
Print("Ошибка: " + OrderReliableErrTxt(err));
}
}

// we have now exited from loop.
if ((result == true) || (err == ERR_NO_ERROR))
{
Print("Успешная модификация");
if(OrderSelect(aticket, SELECT_BY_TICKET, MODE_TRADES))
OrderPrint();
return(true); // SUCCESS!
}

if (err == ERR_NO_RESULT)
{
return(true);
}

Print("Ошибка модификации после " + IntegerToString(cnt) + " попыток");
Print("Ошибка модификации: " + IntegerToString(aticket) + " " + asymbolx +
"@" + DoubleToStr(aprice,_Digits) + " tp@" + DoubleToString(takeprofit,_Digits) + " sl@" + DoubleToString(stoploss,_Digits));
Print("Ошибка : " + OrderReliableErrTxt(err));

return(false);
}
//+------------------------------------------------------------------+
void OrderReliable_EnsureValidStop(string asymbol, double aprice, double &asl)
{
// Return if no S/L
if (asl == 0)
return;

double servers_min_stop = MarketInfo(asymbol, MODE_STOPLEVEL) * MarketInfo(asymbol, MODE_POINT);

if (MathAbs(aprice - asl) {
// we have to adjust the stop.
if (aprice > asl)
asl = aprice - servers_min_stop; // we are long

else if (aprice asl = aprice + servers_min_stop; // we are short

else
Print("EnsureValidStop: error, passed in aprice == sl, cannot adjust");

asl = NormalizeDouble(asl, MarketInfo(asymbol, MODE_DIGITS));
}
}
//+------------------------------------------------------------------+
string OrderReliableErrTxt(int err)
{
return ("" + IntegerToString(err) + ":" + ErrorDescription(err));
}











]

extern double Lots = 0.1;
extern int StopLoss = 30;
extern int TakeProfit = 30;
extern int Slippage = 5;
extern string comment = "TMA BOT";
extern int Magic = 123;
extern string Indicator = "Данные индикатора";
extern string TimeFrame = "current time frame";
extern int HalfLength = 56;
extern int Price = PRICE_CLOSE;
extern double ATRMultiplier = 2.0;
extern int ATRPeriod = 100;
extern bool Interpolate = true;

double PriceHigh, PriceLow, SL, TP, OT;
int ticket, count;
//+------------------------------------------------------------------+
int init()
{
//Проверка брокера на пятизнак
if (Digits ==3 || Digits == 5)
TakeProfit *=10;
StopLoss *=10;
Slippage *=10;
}
//+------------------------------------------------------------------+
int deinit()
{
return(0);
}
//+------------------------------------------------------------------+
void OnTick()
{
/// Обозначаем верхнюю и нижнюю границы канала ТМА
PriceHigh = iCustom(Symbol(), 0, "TMA with Distances", TimeFrame, HalfLength, Price, ATRMultiplier, ATRPeriod, Interpolate, 1, 0);
PriceLow = iCustom(Symbol(), 0, "TMA with Distances", TimeFrame, HalfLength, Price, ATRMultiplier, ATRPeriod, Interpolate, 2, 0);

//Условия на продажу
if(Bid >= PriceHigh && CountSell() == 0 )
{
SL=NormalizeDouble(Bid + StopLoss*Point, Digits);
TP=NormalizeDouble(Bid - TakeProfit*Point, Digits);

ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage, 0, 0, comment, Magic, 0, Red);
if ( ticket > 0)
{
if( OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES )==true)
OrderModify( ticket, OrderOpenPrice(), SL, TP, 0 );
}
}
//Условия на покупку
if( Ask {
SL=NormalizeDouble(Ask - StopLoss*Point, Digits);
TP=NormalizeDouble(Ask + TakeProfit*Point, Digits);

ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, Slippage, 0, 0, comment, Magic, 0, Blue);
if ( ticket > 0)
{
if( OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES )==true)
OrderModify( ticket, OrderOpenPrice(), SL, TP, 0 );
}

}
}
//+------------------------------------------------------------------+
int CountBuy()

{
count = 0;
for (int trade = OrdersTotal()-1; trade >=0; trade --)
{
OrderSelect(trade, SELECT_BY_POS, MODE_TRADES);
if(OrderSymbol() ==Symbol() && OrderMagicNumber() == Magic)
{
if(OrderType() == OP_BUY)
count ++;
}
}
return(count);
}
//+------------------------------------------------------------------+
int CountSell()
{
count = 0;
for (int trade = OrdersTotal()-1; trade >=0; trade --)
{
OrderSelect(trade, SELECT_BY_POS, MODE_TRADES);
if(OrderSymbol() ==Symbol() && OrderMagicNumber() == Magic)
{
if(OrderType() == OP_SELL)
count ++;
}
}
return(count);
}