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

[0ll]

Скажите а вот такая конструкция с нахождением первого ордера будет работать ?
И еще, мы расчитали переменную LimitOpenPriceBuy а затем записали значение этой перем. в перем. onepriceBuy
будет ли это значение оставаться постоянно что бы использовать его в дальнейшем при закрытии.

И где-же конструкция? В Вашей конструкции увидел только открытие отложки Бай, а в комментах написано Селл ...
В переменных LimitOpenPriceBuy и onepriceBuy будут одинаковые значения, при пересчёте первого изменится второе. Время хранения значения между пересчётами зависит от того как переменные были объявлены, если на глобальном уровне, то будет храниться пока эксперт работает.

[Roman 13]

Хорошо, а как же сделать так чтобы сохранить цену открытия отложенного ордера и перенести её в блок закрытия?

[0ll]

Хорошо, а как же сделать так чтобы сохранить цену открытия отложенного ордера и перенести её в блок закрытия?

Млин, я ждал этот вопрос... Есть хренова куча способов сохранения любой информации, включая double-числа, НО Вам нужен осознанный алгоритм работы совы, а именно:
- в какой момент времени сохранить значение
- будут-ли открываться ещё ордера и нужно-ли сохранять их параметры?
- как будут закрываться ордера, все сразу или по одиночке?
- в какой момент старое значение нужно обнулять или записывать новое значение?
Опишите как будет работать сова, открывать и закрывать ордера, зачем Вам цена отложки и как она участвует в закрытии, и только разобрав алгоритм мы сможем посоветовать что-то.

[Roman 13]

Смысл советника состоит в следующем: первый ордер открывается по сигналу средней затем если ордер закрывается по ТР или по сигналу то ждем следующего сигнала на открытие, если цена пошла против нас то подключается в работу мартингейл вот и все , но в закрытии первого ордера участвует цена открытия первого отложенного ордера кстати форма закрытия есть предыдущем письме.

[0ll]

Roman 13 вот как я понял выглядит алгоритм:
- появился сигнал на вход - открываем ордер
- сразу вычисляем цену отложенного ордера (Мартингейл по Вашему, я не понял усреднение или переворот)
- после установки отложки сразу вычислим и запомним цену закрытия 1 ордера = onepriceBuy + CloseDelta *_Point
- ждём ТП или сигнала на закрытие - пересечение ценой уровня закрытия.
Вот так это выглядит (схематично для Бай):

Спойлер

if ( CountBuy() > 0 ) // Ордер Бай открыт
{
// Ждём сигнал закрытия
if ( Bid >= ClosePriceBuy && Bid { Закрываем }
}
else
{
// Ждём сигнал открытия
if ( SignalBuy() )
{
int tick = OrderSend( OP_BUY );
if ( tick >= 0 ) // Новый ордер открыт
{
// Вычисляем цену отложки и закрытия 1 ордера
prcOtl = hi1 + PriceFilter *_Point;
ClosePriceBuy = prcOtl + CloseDelta *_Point;
// Здесь выставляем отложку
}
}
}

[Roman 13]

Алгоритм выглядит так

- появился сигнал на вход, выставляем отложенный ордер
- сразу вычисляем цену отложенного ордера и запоминаем ее - firstpriceBuy .
- ждём ТП или сигнала на закрытие - if ( Bid >= NormalizeDouble ( firstpriceBuy + ( CloseDelta * Point),5) &&
Bid - если ордер не закрылся не по ТП не по сигналу и цена пошла против нас то включается мартингейл на усреднение.

Вот так это выглядит (схематично для Бай):

У меня не получается состыковать усреднение с первой частью алгоритма ,получается так что после открытия нескольких ордеров на усреднение, срабатывает условие закрытия приведенное выше, но по последнему ордеру.
Как с этим справиться?

[0ll]

У меня не получается состыковать усреднение с первой частью алгоритма ,получается так что после открытия нескольких ордеров на усреднение, срабатывает условие закрытия приведенное выше, но по последнему ордеру.
Как с этим справиться?

Становится понятней... т.е. после сигнала на вход, формируется коридор цен, внутри которого строится сетка, и она либо закрывается по ТП, либо по сигналу закрытия.
Победить можно 2 путями: вычислив сразу уровень закрытия, открываемые ордера сетки объявлять с общим СЛ = цене закрытия,
Второй способ в своём коде закрытия сделайте так:

Спойлер

//------------------------+
// Закрытие покупок
//------------------------+

if(CountBuy() > 0 )
{
if ( Bid >= onepriceBuy + CloseDelta *_Point && Bid {
for( int i = OrdersTotal()-1; i >= 0; i-- )
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
{
if(OrderMagicNumber() == Magic && OrderType() == OP_BUY && OrderSymbol() == Symbol() )
{

if(!OrderClose(OrderTicket(),OrderLots(),Bid,Sleepage,Black))
Print("Ошибка закрытия ордера на покупку");

}
}
}
}
}

ПС: NormalizeDouble в операциях сравнения не используйте - трата времени, это нужно только для передачи числа брокеру в функциях работы с ордерами.

[Roman 13]

т.е. во втором способе условие закрытия выносится перед циклом?

по поводу алгоритма , усреднение начинается только после того, если после открытия первого ордера цена пошла против нас и через определенное кол-во пунктов открывается второй ордер , т.е. со второго ордера начинается классическое усреднение с умножение лота. Никаких коридоров цен и сеток не строится.

---

Добавлено: 14-06-2018 15:59:52

---

Вот код приблизительно конечно на мой алгоритм

Спойлер

/+------------------------------------------------------------------+
//| EUR_Limit_martin_M5_Trend_MA_.mq4 |
//| Copyright 2017, MetaQuotes Software Corp. |
//| https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, MetaQuotes Software Corp."
#property link "https://www.mql5.com"
#property version "2.00"
#property strict

extern double Lots = 0.01;
extern int TakeProfit = 150;
extern int TakeProfit1 = 10;
extern double Multiplier = 1.5;
extern int Step = 150;
extern int NumberCandl = 3;
extern int SpreadLimit = 20;
extern int macdlevel = 2;
extern int CloseDelta = 50;
extern int PriceFilter = 15;
extern int Magic = 12345;
extern int Sleepage = 10;
extern int CandlLevel = 200;
extern int Hour1 = 8;
extern int Hour2 = 19;

//-------------------------------------------------------------------+
double tp,tp1;
double price,lastlot;
double LimitOpenPriceSell,LimitOpenPriceBuy;
double onepriceBuy, onepriceSell;
double onehiOpenBuy,onelowOpenSell;
double firstpriceBuy,firstpriceSell;
int ticket;
int ticket1;

//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
//---

//---
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
//---

}
//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick()
{
//--------------------------------------------------------------------+
// if(timeprev == Time[0]) return;
// timeprev = Time[0];
//--------------------------------------------------------------------+

double
stoch_main1, stoch_main2,
stoch_signal1, stoch_signal2,
// rsi1,
// ma10,ma11,ma12,
// ma10H, ma11H, ma12H,
// ma10L, ma11L, ma12L,
// ma21,ma22,ma20,
ma31,ma32,
ma130, ma131,ma132,ma133,
ma211,ma212,ma213,
// ma341,ma342,
ma81,ma82,ma80,ma83,
ma51,ma52,ma53,
ma551,ma552,ma553,
ma1441,ma1442,ma1443,
macd1,macd2,
macdsignal1,macdsignal2,
open1,close1,hi1,low1,
open2,close2,hi2,low2;
// open0,close0,hi0,low0;
// envup0,envdown0;
// envup1,envdown1;

// ma10H = iMA(NULL,0,1,0,MODE_EMA,PRICE_HIGH,0);
// ma11H = iMA(NULL,0,1,0,MODE_EMA,PRICE_HIGH,1);
// ma12H = iMA(NULL,0,1,0,MODE_EMA,PRICE_HIGH,2);

// ma10L = iMA(NULL,0,1,0,MODE_EMA,PRICE_LOW,0);
// ma11L = iMA(NULL,0,1,0,MODE_EMA,PRICE_LOW,1);
// ma12L = iMA(NULL,0,1,0,MODE_EMA,PRICE_LOW,2);

// ma20 = iMA(NULL,0,2,0,MODE_EMA,PRICE_CLOSE,0);
// ma21 = iMA(NULL,0,2,0,MODE_EMA,PRICE_CLOSE,1);
//
// ma30 = iMA(NULL,0,3,0,MODE_EMA,PRICE_CLOSE,0);
ma31 = iMA(NULL,0,3,0,MODE_EMA,PRICE_CLOSE,1);
ma32 = iMA(NULL,0,3,0,MODE_EMA,PRICE_CLOSE,2);





// ma50 = iMA(NULL,0,5,0,MODE_EMA,PRICE_CLOSE,0);
ma51 = iMA(NULL,0,5,0,MODE_EMA,PRICE_CLOSE,1);
ma52 = iMA(NULL,0,5,0,MODE_EMA,PRICE_CLOSE,2);
ma53 = iMA(NULL,0,5,0,MODE_EMA,PRICE_CLOSE,3);

ma81 = iMA(NULL,0,8,0,MODE_EMA,PRICE_CLOSE,1);
ma82 = iMA(NULL,0,8,0,MODE_EMA,PRICE_CLOSE,2);
ma83 = iMA(NULL,0,8,0,MODE_EMA,PRICE_CLOSE,3);
ma80 = iMA(NULL,0,8,0,MODE_EMA,PRICE_CLOSE,0);

ma130 = iMA(NULL,0,13,0,MODE_EMA,PRICE_CLOSE,0);
ma131 = iMA(NULL,0,13,0,MODE_EMA,PRICE_CLOSE,1);
ma132 = iMA(NULL,0,13,0,MODE_EMA,PRICE_CLOSE,2);
ma133 = iMA(NULL,0,13,0,MODE_EMA,PRICE_CLOSE,3);

ma211 = iMA(NULL,0,21,0,MODE_EMA,PRICE_CLOSE,1);
ma212 = iMA(NULL,0,21,0,MODE_EMA,PRICE_CLOSE,2);
ma213 = iMA(NULL,0,21,0,MODE_EMA,PRICE_CLOSE,3);


stoch_main1 = iStochastic(NULL,0,5,3,2,MODE_EMA,0,MODE_MAIN,1);
stoch_signal1 = iStochastic(NULL,0,5,3,2,MODE_EMA,0,MODE_SIGNAL,1);
stoch_main2 = iStochastic(NULL,0,5,3,2,MODE_EMA,0,MODE_MAIN,2);
stoch_signal2 = iStochastic(NULL,0,5,3,2,MODE_EMA,0,MODE_SIGNAL,2);



// rsi1 = iRSI(NULL,0,8,PRICE_CLOSE,1);



// ma341 = iMA(NULL,0,34,0,MODE_EMA,PRICE_CLOSE,1);
// ma342 = iMA(NULL,0,34,0,MODE_EMA,PRICE_CLOSE,2);

// ma550 = iMA(NULL,0,55,0,MODE_EMA,PRICE_CLOSE,0);
ma551 = iMA(NULL,0,55,0,MODE_EMA,PRICE_CLOSE,1);
ma552 = iMA(NULL,0,55,0,MODE_EMA,PRICE_CLOSE,2);
ma553 = iMA(NULL,0,55,0,MODE_EMA,PRICE_CLOSE,3);


ma1441 = iMA(NULL,0,144,0,MODE_EMA,PRICE_CLOSE,1);
ma1442 = iMA(NULL,0,144,0,MODE_EMA,PRICE_CLOSE,2);
ma1443 = iMA(NULL,0,144,0,MODE_EMA,PRICE_CLOSE,3);

macd1 = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,1);
macd2 = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,2);
macdsignal1 =iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,1);
macdsignal2 =iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,2);

// envup0 = iEnvelopes(NULL,0,55,MODE_EMA,0,PRICE_CLOSE,ENVLevel,MODE_UPPER,0);
// envdown0 = iEnvelopes(NULL,0,55,MODE_EMA,0,PRICE_CLOSE,ENVLevel,MODE_LOWER,0);
// envup1 = iEnvelopes(NULL,0,55,MODE_EMA,0,PRICE_CLOSE,ENVLevel,MODE_UPPER,1);
// envdown1 = iEnvelopes(NULL,0,55,MODE_EMA,0,PRICE_CLOSE,ENVLevel,MODE_LOWER,1);

// open0 = iOpen(NULL,0,0);
// close0 = iClose(NULL,0,0);
// hi0 = iHigh(NULL,0,0);
// low0 = iLow(NULL,0,0);

open1 = iOpen(NULL,0,1);
close1 = iClose(NULL,0,1);
hi1 = iHigh(NULL,0,1);
low1 = iLow(NULL,0,1);

open2 = iOpen(NULL,0,2);
close2 = iClose(NULL,0,2);
hi2 = iHigh(NULL,0,2);
low2 = iLow(NULL,0,2);

// datetime time1 = iTime(NULL,0,1);
// datetime time2 = iTime(NULL,0,2);

//----------------------------------+
// Продажа
//----------------------------------+

if (( CountSell() == 0 &&
CountBuy() == 0 &&
SellStopCount() == 0 &&
BuyStopCount() == 0 &&

//---------------------------------------------------------------------------------------

((hi1 - low1)/Point) //-------------------------------------------------------------------------------------------
MathRound ( Ask - Bid / Point ) //---------------------------------------------------------------------------------------------------
//
//---------------------------------------------------------------------------------------
Hour() >= Hour1 && Hour() //--------------------------------------------------------------------------------------------
ma1441 // ma551 ma211 ma131 ma81 ma31 //------------------------------------
// ma1441 > ma551 && // Взаиморасположение средних
// ma1442 > ma552 &&
//-----------------------------------
ma1441 > ma131 &&
ma1441 > ma81 &&
ma1441 > hi1 &&
//-----------------------------------
ma211 > ma131 &&
ma131 > ma81 &&
ma81 > ma31 &&
//-----------------------------------
ma1442 > ma132 &&
ma1442 > ma82 &&
ma1442 > hi2 &&
//---------------------------------------
// macd1 MathAbs( macd1) > ( macdlevel * Point) &&
// macd1 //-------------------------------------------
// open1 //------------------------------------------
close1 //-------------------------------------------
open1 > ma81 &&
close1



// stoch_main1 > 20 &&
// stoch_signal1 > 20 &&
// stoch_main1

//----------------------------------------------------------------------------------------------------------------



( CountSell() == 0 &&
CountBuy() == 0 &&
SellStopCount() == 0 &&
BuyStopCount() == 0 &&

//---------------------------------------------------------------------------------------

((hi1 - low1)/Point) //-------------------------------------------------------------------------------------------
MathRound ( Ask - Bid / Point ) //---------------------------------------------------------------------------------------------------
// MathAbs((low1 - close1)/Point) //-------------------------------------------------------------------------------------------
// Bid // Bid > low1 - OpenDif * Point && // Цена выше заданного уровня
//------------------------------------------------------------------------------------------------
// close1 - low1 //-------------------------------------------------------------------------------------------------
// MathAbs ( close1 - open1) > close1 - low1 && // тело свечи больше шипов
// MathAbs ( close1 - open1) > hi1 - open1 && // тело свечи больше шипов
//---------------------------------------------------------------------------------------
Hour() >= Hour1 && Hour() //--------------------------------------------------------------------------------------------
ma1441 // ma131 // ma81 // ma31 //------------------------------------
// Взаиморасположение средних
//-----------------------------------
ma1441 > ma131 &&
ma1441 > ma81 &&
ma1441 > open1 &&
//----------------------------------
ma81 > ma31 &&
//-----------------------------------
// ma1442 > ma132 &&
// ma1442 > ma82 &&
// ma1442 > hi2 &&

//---------------------------------------
// macd1 MathAbs( macd1) > ( macdlevel * Point) &&
// macd1 //-------------------------------------------
// close1 //-------------------------------------------
ma82 > ma132 &&
ma81 //-----------------------------------------------------------------



//------------------------------------------------------------------------------------------------

{

LimitOpenPriceSell = NormalizeDouble(low1 - PriceFilter * Point,Digits);

onepriceSell = LimitOpenPriceSell;


datetime vioo = TimeCurrent() + NumberCandl * 5 * 60; // vioo - время истечения отложенного ордера


tp = NormalizeDouble( LimitOpenPriceSell - TakeProfit * Point,Digits);


ticket = OrderSend(Symbol(),OP_SELLSTOP,Lots,LimitOpenPriceSell,Sleepage,0,tp,"EUR_Limit_martin_M5_TREND_MA",Magic,vioo,Red);
if ( ticket Print ( " Не удалось открыть ордер на продажу" );



//-------------------------------------------------------------------------------------------
}
//-----------------------------------------------------------------------------------------






//---------------------------------+
// Покупка
//---------------------------------+

if ( ( CountBuy() == 0 &&
BuyStopCount() == 0 &&
CountSell() == 0 &&
SellStopCount() == 0 &&
//-----------------------------------------------------------------------------------------
// TimeCurrent()-Time[0] //(выполнится только 1 раз, т.к. далее условие на данной свече невыполнимо)
//----------------------------------------------------------------------------------------------

((hi1 - low1)/Point) //--------------------------------------------------------------------------------------------
MathRound ( Ask - Bid / Point ) //------------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------------------

Hour() >= Hour1 && Hour() //--------------------------------------------------------------------------------------------------
ma1441 > ma1442 && // Наклон средних
// ma551 >= ma552 && //
ma211 > ma212 &&
ma131 > ma132 &&
ma81 > ma82 &&
ma31 > ma32 &&
//------------------------------------
// ma1441 // ma1442 //-------------------------------------
ma1441 ma1441 ma1441 //---------------------------------------
ma211 ma131 ma81
//---------------------------------------
ma1442 ma1442 ma1442 //-------------------------------------------

// macd1 > macd2 &&
MathAbs( macd1) > ( macdlevel * Point) &&
// macd1 > macdsignal1 &&
//-------------------------------------------

//------------------------------------------
close1 > open1 && // Восходящая свеча
//-------------------------------------------
open1 close1 > ma81 ) ||


// stoch_main1 // stoch_signal1 // stoch_main2 // stoch_main1 >= stoch_signal1 ) ||

//--------------------------------------------------------------------------------------------



( CountBuy() == 0 &&
BuyStopCount() == 0 &&
CountSell() == 0 &&
SellStopCount() == 0 &&
//-----------------------------------------------------------------------------------------
// TimeCurrent()-Time[0] //(выполнится только 1 раз, т.к. далее условие на данной свече невыполнимо)
//----------------------------------------------------------------------------------------------

((hi1 - low1)/Point) //--------------------------------------------------------------------------------------------
MathRound ( Ask - Bid / Point ) //------------------------------------------------------------------------------------------
// MathAbs((low1 - close1)/Point) //-----------------------------------------------------------------------------------------------
// Bid > hi1 + PriceFilter * Point && // Цена выше максимума свечи
// Bid //-------------------------------------------------------------------------------------------------
// hi1 - close1 //-------------------------------------------------------------------------------------------------
// MathAbs ( close1 - open1) > hi1 - close1 && // тело свечи больше шипов
// MathAbs ( close1 - open1) > open1 - low1 && // тело свечи больше шипов
//--------------------------------------------------------------------------------------------------

Hour() >= Hour1 && Hour() //--------------------------------------------------------------------------------------------------
ma1441 > ma1442 && // Наклон средних
// ma551 >= ma552 && //
// ma211 > ma212 &&
// ma131 > ma132 &&
// ma81 > ma82 &&
// ma31 > ma32 &&
//------------------------------------
// ma1441 // ma1442 //-------------------------------------
ma1441 ma1441 ma1441 //--------------------------------------
ma81 //--------------------------------------

// macd1 > macd2 &&
MathAbs( macd1) > ( macdlevel * Point) &&
// macd1 > macdsignal1 &&
//-------------------------------------------

//------------------------------------------
// close1 > open1 && // Восходящая свеча
//-------------------------------------------
ma82 ma81 >= ma131 ) ) // Открытие на пересечении средних


//-----------------------------------------------------------------





{
LimitOpenPriceBuy = NormalizeDouble(hi1 + PriceFilter * Point,Digits); // цена по которой устанавл. отлож. ордер

onepriceBuy = LimitOpenPriceBuy ;

datetime vioo = TimeCurrent() + NumberCandl * 5 * 60; // время истеч отлож ордера


tp = NormalizeDouble( LimitOpenPriceBuy + TakeProfit * Point,Digits);


ticket = OrderSend(Symbol(),OP_BUYSTOP,Lots,LimitOpenPriceBuy,Sleepage,0,tp,"EUR_Limit_martin_M5_TREND_MA_",Magic,vioo,Green);
if(ticket Print ( " Не удалось открыть отложенный ордер на продажу" );



//-------------------------------------------------------------------------------------------
}
//------------------------------------------------------------------------------------------








//-------------------------------------+
// Проверяем на закрытие
//-------------------------------------+
// Закрытие продаж
//-------------------------------------+


if (CountSell() > 0 )

{
for(int i = OrdersTotal() - 1; i >= 0; i--)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
{
if(OrderMagicNumber() == Magic && OrderType() == OP_SELL && OrderSymbol() == Symbol() )
{


if ( Bid
Bid >= hi1 ) // цена выше максимума предыдущ. свечи


{
if(!OrderClose(OrderTicket(),OrderLots(),Ask,Sleepage,Black))
Print("Ошибка закрытия ордера на продажу");
}
}
}
}
}




//------------------------+
// Закрытие покупок
//------------------------+



if(CountBuy() > 0 )

{
for( int i = OrdersTotal()-1; i >= 0; i-- )
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
{
if(OrderMagicNumber() == Magic && OrderType() == OP_BUY && OrderSymbol() == Symbol() )

{


if ( Bid >= NormalizeDouble ( onepriceBuy + ( CloseDelta * Point),5) &&
Bid
//

//
{
if(!OrderClose(OrderTicket(),OrderLots(),Bid,Sleepage,Black))
Print("Ошибка закрытия ордера на покупку");
}
}
}
}
}

// если ордер не закрылся по нашим условиям и цена пошла против нас , то включается мартингейл с усреднением и умнож. лота




//--------------------------------------------------------------------+
// Мартин
//--------------------------------------------------------------------+


if(CountTrades() > 0)

{
int order_type = FindLastOrderType();
if(order_type == OP_BUY)
{
price = FindLastPrice(OP_BUY);

if(Ask {
lastlot = FindLastLots(OP_BUY);
lastlot = NormalizeDouble(lastlot * Multiplier,2);
ticket = OrderSend(Symbol(),OP_BUY,lastlot,Ask,Sleepage,0,0,"",Magic,0,Blue);
if(ticket Print( "Ошибка открытия ордера на покупку");
ModifyOrders(OP_BUY);
}
}
if(order_type == OP_SELL)
{
price = FindLastPrice(OP_SELL);
if(Bid >= price + Step * Point)
{
lastlot = FindLastLots(OP_SELL);
lastlot = NormalizeDouble(lastlot * Multiplier,2);
ticket = OrderSend(Symbol(),OP_SELL,lastlot,Bid,Sleepage,0,0,"",Magic,0,Red);
if(ticket Print("Ошибка открытия ордера на продажу");
ModifyOrders(OP_SELL);
}
}
}


//---------------------------------------------------------------------+
}
//---------------------------------------------------------------------+



//---------------------------------------------------------------------+
// Функции
//---------------------------------------------------------------------+


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


//---------------------------------------------------------------------------------------------------+
int CountSell()
{
int count = 0;

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



//------------------------------------------------------------------------------------------------------+


int BuyStopCount()
{
int count = 0;
for ( int i = OrdersTotal() - 1; i >= 0; i--)
{
if (OrderSelect( i,SELECT_BY_POS,MODE_TRADES) == true &&
OrderMagicNumber() == Magic &&
OrderType() ==OP_BUYSTOP )
{
count ++;
}
}
return (count);
}


//-----------------------------------------------------------------------+

int SellStopCount()
{
int count = 0;
for ( int i = OrdersTotal() - 1; i >= 0; i--)
{
if ( OrderSelect( i,SELECT_BY_POS,MODE_TRADES) == true &&
OrderMagicNumber() == Magic &&
OrderType() == OP_SELLSTOP )
{
count ++;
}
}
return (count);
}



//---------------------------------------------------------------------------+
// Функции Мартин
//+--------------------------------------------------------------------------+



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


//+------------------------------------------------------------------+

int FindLastOrderType()
{
for(int i = OrdersTotal() -1; i >= 0; i--)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
{
if(OrderSymbol() == Symbol() && OrderMagicNumber() == Magic)
return(OrderType());
}
}
return(-1);
}


//--------------------------------------------------------------------+

double FindLastPrice(int otype)
{
int oldticket;
double oldopenprice = 0;
ticket = 0;
for(int cnt = OrdersTotal() -1; cnt >= 0; cnt--)
{
if(OrderSelect(cnt,SELECT_BY_POS,MODE_TRADES))
{
if(OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && OrderType() == otype)
{
oldticket = OrderTicket();
if(oldticket > ticket)
{
ticket = oldticket;
oldopenprice = OrderOpenPrice();
}
}
}
}
return(oldopenprice);
}


//-------------------------------------------------------------------------+

double FindLastLots(int otype)
{
int oldticket;
double oldlots = 0;
ticket = 0;
for(int cnt = OrdersTotal() -1;cnt >= 0;cnt--)
{
if(OrderSelect(cnt,SELECT_BY_POS,MODE_TRADES))
{
if(OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && OrderType() == otype)
{
oldticket = OrderTicket();
if(oldticket > ticket)
{
ticket = oldticket;
oldlots = OrderLots();
}
}
}
}
return(oldlots);
}


//-------------------------------------------------------------------------+

void ModifyOrders(int otype)
{
double avg_price,order_lots =0;
price = 0;
for(int i= OrdersTotal() -1; i >=0; i--)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
{
if(OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && OrderType() == otype)
{
price +=OrderOpenPrice() * OrderLots();
order_lots +=OrderLots();

}
}
}
avg_price = NormalizeDouble(price/order_lots,Digits);
if(otype == OP_BUY) tp1 = NormalizeDouble(avg_price + TakeProfit1 * Point,Digits);
if(otype == OP_SELL)tp1 = NormalizeDouble(avg_price - TakeProfit1 * Point,Digits);
for(int i = OrdersTotal() -1; i >= 0; i--)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
{
if(OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && OrderType() ==otype)
{
if(OrderModify(OrderTicket(),OrderOpenPrice(),0,tp1,0))
Print("Ордера успешно модифицированы");
else Print("Ошибка модификации ордера");
}
}
}
}


//-----------------------------------------------------------------------------------------------------+
// Находим цену открытия 1-го ордера BUY
//-----------------------------------------------------------------------------------------------------+

double Find_1_Price_BUY()
{
int oneticket;
double oneopenprice = 0;
ticket = -1;
for(int cnt = OrdersTotal() -1; cnt >= 0; cnt--)
{
if(OrderSelect(cnt,SELECT_BY_POS,MODE_TRADES))
{
if(OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && OrderType() == OP_BUY)
{
oneticket = OrderTicket();
if( ticket1 {
ticket1 = oneticket;
oneopenprice = OrderOpenPrice();
}
}
}
}
return(oneopenprice);
}


//-------------------------------------------------------------------------+

//-----------------------------------------------------------------------------------------------------+
// Находим цену открытия 1-го ордера SELL
//-----------------------------------------------------------------------------------------------------+

double Find_1_Price_SELL()
{
int oneticket;
double oneopenprice = 0;
ticket = -1;
for(int cnt = OrdersTotal() -1; cnt >= 0; cnt--)
{
if(OrderSelect(cnt,SELECT_BY_POS,MODE_TRADES))
{
if(OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && OrderType() == OP_SELL)
{
oneticket = OrderTicket();
if( ticket1 {
ticket1 = oneticket;
oneopenprice = OrderOpenPrice();
}
}
}
}
return(oneopenprice);
}



//-----------------------------------------------------------------------------------------------------+
// Находим цену открытия 1-го ордера по времени открытия
//-----------------------------------------------------------------------------------------------------+

double Find_1_time_Price(int otype)
{
datetime onetime;
double oneopenprice = 0;
datetime time = 0;

for(int cnt = OrdersTotal() -1; cnt >= 0; cnt--)
{
if(OrderSelect(cnt,SELECT_BY_POS,MODE_TRADES))
{
if(OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && OrderType() == otype)
{
onetime = OrderOpenTime();
if( time {
time = onetime;
oneopenprice = OrderOpenPrice();
}
}
}
}
return(oneopenprice);
}

//------------------------------------------------------------------------

Изменено 14 июня, 2018 пользователем Roman 13

[0ll]

Roman 13 да условие закрытия должно быть до цикла, если сработало, то все ордера по направлению закрываются.
С коридором Вам было-бы проще, Стоп рассчитывается от стартовой цены и по мере роста сетки не меняется - значит считайте сразу и ставьте СЛ. Усреднение ордера (с мартином или без) обычно называется сеткой - так легче представить алгоритм. Кстати он рабочий, только количество усредняющих ордеров не более 4, иначе из ямы может не вылезти...

По коду: чтоб подобрать периоды средних, нужно вынести их во внешние переменные совы и оптимизировать в тестере, на мой взгляд периоды должны быть от 6 до 20 часов (на любом ТФ)
Имхо, для мартина слишком сложные условия входа - зло, он должен фигачить без остановки, иначе сольёт раньше чем отобьёт депо.
Но при использовании средних, ночью входить нельзя, так-что время работы поддерживаю. Изменено 14 июня, 2018 пользователем 0ll

[Roman 13]

А что значит коридор цен ?

[0ll]

А что значит коридор цен ?

Диапазон, внутри которого ведётся торговля. Вы-же рассчитываете цену первого ордера - это одна граница, потом цена пошла против входа, открываются усредняющие ордера - сетка, цена продолжает идти против ордеров и доходит до ограничения CloseDelta - это 2 граница торгового диапазона.

[Roman 13]

Извините , что бестолковлюсь , но в итоге, как все таки запомнить цену первого ордера что бы она не изменялась при пересчете цены отложенного ордера, и затем эту запомненную цену можно было бы перенести блок закрытия.

[0ll]

Roman 13 объявите переменную double на глобальном уровне - вне всех функций. Цену отложки сохраняйте в момент проверки успешности её открытия, чтоб при повторении сигнала на вход, сова не стала заново пытаться отложку устанавливать - у Вас проверка эта есть, так-что проблем не вижу.

[Roman 13]

А не могли бы вы указать в коде - "момент проверки успешности её открытия, чтоб при повторении сигнала на вход, сова не стала заново пытаться отложку ".

[0ll]

А не могли бы вы указать в коде

Вот это место для продаж:
ticket = OrderSend(Symbol(),OP_SELLSTOP,Lots,LimitOpenPriceSell,Sleepage,0,tp,"EUR_Limit_martin_M5_TREND_MA",Magic,vioo,Red);
if ( ticket else openprcSell = LimitOpenPriceSell; // если отложка установлена - запоминаем цену

ПС: кстати у Вас при проверки условий на вход 2 раза повторяются проверки на отсутствии ордеров:
CountBuy() == 0 && BuyStopCount() == 0 && CountSell() == 0 && SellStopCount() == 0 &&
т.к. лимитники не используете, то можно написать проверку попроще - функцию NoOrders(), которая возвращает false, если находит любой открытый ордер по символу и магику - это значительно сократит время теста в будущем.

[Sacred70]

Добрый день. Надеюсь что в нужной теме пишу. Пожалуйста, подскажите как на графике поставить разделение по часам. чтобы на мелких ТФ наглядней было видно?

[usver73]

Добрый день. Надеюсь что в нужной теме пишу. Пожалуйста, подскажите как на графике поставить разделение по часам. чтобы на мелких ТФ наглядней было видно?

Проверяете время свечи (Time[0]). Если минуты ==00, значит новый час..
Если условие соблюдено, рисуете вертикальную линию (или как Вы предполагаете маркировать) с параметром "Время" = Времени открытия 0-го(текущего) бара.

[Rever27]

Проверяете время свечи (Time[0]). Если минуты ==00, значит новый час..

Я думаю он не спрашивает, как написать такой код, а как просто это активировать. На подобии период, которые разделяют дни на графике.
Ответ: без кода никак.
С кодом - накидал тебе скрипт. You welcome

Draw_H1_Line_by_ReVeR27.mq4

[Ser10]

Всем привет. Ребят, возможно не в ту тему написал, но нужны ваши знания,я сам вообще в совах не шарю. Хочу понять, возможно ли в принципе создание отдельного скрипта или советника, который будет копировать сигналы на открытие ордера другим советником, если сам ордер не был открыт по причине отсутствия средств на счете?
Ситуация следующая: на отдельном счете стоит советник(1), который не торгует, т.к. средств на счете нет, но сигналы на открытие посылает. Советник жестко прикреплен к номеру счета, перенести его нельзя,изменить тоже(в каталоге данных только файлы ex4 и dat). Депо не пополняю,т.к. советник сливает. Далее, есть второй счет, на котором стоит другой советник(2), который должен изменять параметры ордера первой совы и выставлять свой ордер. Хочу использовать сигналы на открытие ордера совы(1) с первого счета как сигналы для открытия отложенных ордеров совы(2) на втором счете. В журнале первого счета видно, что сова пытает открыть ордера, но не получается, т.к. средств нет. На этом же счете нельзя торговать,т.к. и сова(1)сливная. Вручную отслеживать нереально, т.к. ордера приходят редко - 1-2 в день в разное время.
Заранее, спасибо.

[0ll]

создание отдельного скрипта или советника, который будет копировать сигналы на открытие ордера другим советником

Да, возможно, но это будет индивидуальное решение - не дёшево...

[usver73]

Всем здравствуйте.
Помогите с логикой.

Необходимо собирать и хранить данные с многоуровневой группировкой. Каждая группировка на картинке выделена цветом.
Начал реализовывать с помощью массива, но не хватило его размерности- необходим пятимерный массив.
Или другое техническое решение...

[0ll]

usver73 Часть данных вычисляется, их хранить незачем (%%), имхо.
Для остального создать структуру типа:
struct BARSINFO { int all, bar[2]; };
BARSINFO HiLo[20], OpCl[20], Vnutr[20];
Как пользовать:
Закрылась свеча, вычисляем размеры в 4 зн. - sizHiLo, sizeOpCl и направление BarType = OP_BUY/OP_SELL, пишем в структуру
HiLo[sizeHiLo].all++; HiLo[sizeHiLo].bar[BarType]++;
// для остального аналогично.
При выводе инфы запускаем цикл от 0 до 20 (по размеру баров), % вычисляем на лету.
Не понял за нарастающий итог - это для нескольких дней? или внутри для?

[usver73]

Спасибо, 0ll, примерно так и начал делать- вычисляемые %% убрал из размерности массива, в результате в одной размерности отпала необходимость.
%% хотел засунуть в одну кучу с количеством, чтобы потом проще было организовать вывод на экран и в файл.
Со структурами не получится обойтись тремя массивами. Есть еще группировка по времени- как минимум две, как максимум- 6. Итого нужно будет до 18 массивов.

Цитата

Не понял за нарастающий итог - это для нескольких дней? или внутри для?

Нарастающие % по соседней (левой) колонке. "Целый день" криво обозначил. По сути- это все свечи за выбранный период (несколько дней).
А дальше эта таблица тиражируется на:
-за весь период по понедельникам;
-за весь период по вторникам;
- ---------- по пятницам;
- за весь период ХХ часов в сутки;
- за весь период ХХ часов по понедельникам;
- за весь период ХХ часов по вторникам... и т.д.
Максимум получается 12 таблиц по 18 колонок :))

Возможно до такой глубокой детализации дело не дойдет, но "за весь период ХХ часов в сутки" точно надо сделать...

[Юлия-Julik]

Здравствуйте!
Я совсем новичок и в трейдинге, и программировании, поэтому прошу не смеяться, если вопросы покажутся глупыми.
В теме "Forex TrailinRobot — Стань Мастером Трейлинг Cтопа" был выложен советник.

Мне почему-то не удается его перекомпилировать. Появляются предупреждения (не ошибки) в строчках, где есть "или":
check operator precedence for possible error; use parentheses to clarify precedence trailingator.mq4 33 67

Вот в этих:
if (Bid > l_ord_open_price_20 + ld_8 * gd_100 || !ProfitTrailing && l_price_36 >= l_ord_stoploss_28 + TrailingStep * gd_100 && ld_8 * gd_100 > ld_0 * gd_100)

После чего советник перестает работать:
2018.06.22 11:43:18.232 trailingator USDJPY,H1: Sell OrderModify Error 4109
2018.06.22 11:43:18.232 trailingator USDJPY,H1: trade operations not allowed by settings
2018.06.22 11:43:18.232 trailingator USDJPY,H1: initialized
2018.06.22 11:43:18.203 trailingator USDJPY,H1 inputs: ProfitTrailing=true; TrailingStop=15.0; TrailingStep=2.0; MagicNumber=-1;

Помогите разобраться, пожалуйста.

[kaetosh]

Всем привет!
Хочу предложить тему для урока по MQL4 - Автооптимизатор советника.
В чем идея - допустим у вас есть советник, который на тестах на достаточно продолжительном периоде показывает плюс, но вас не устраивает доходность или плавность кривой доходности. Мне кажется, если на продолжительном участке истории советник хоть что-то зарабатывает, значит торговая идея в его основе рабочая, возможно результаты можно улучшить регулярными переоптимизациями. Раз в месяц/неделю вручную делать оптимизацию не трудно, а если поэкспериментировать - делать переоптимизацию каждый день и на коротком промежутке истории (месяц)? То есть советник как бы постоянно будет соответствовать изменениям на рынке. Тут бы пригодился автооптимизатор, чтобы советник сам ее проводил с заданной регулярностью и сам сохранял лучшие настройки. На просторах сети есть подобные решения, но они безнадежно устарели и не компилируются. Если тема будет интересна, может наши преподаватели что-нибудь придумают?