Как правильно изменить советник

Илья Жуков 2014.03.11 05:58

Нужно правильно изменить в советнике исходные данные на (1 покупка, -1 продажа)

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

//| SimpleBars_rob.mq4 |
//| Copyright © 2010, ENSED Team |
//| http://www.ensed.org |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2010, ENSED Team"
#property link "http://www.ensed.org"

extern int SL = 50, // величина стоп-лосс (в пунктах)
TP = 150; // величина тейк профит (в пунктах)
extern double Lots = 0.1; // рабочий лот (микролоты - 0.01, минилоты - 0.1, нормальные лоты - 1.0)
extern string Order_Comment = "robot"; // комментарий, которым снабжаются ордера
extern int Slipage = 5; // уровень максимально допустимого проскальзывания (в пунктах)
extern int Magic_Number = 777; // магическое число - ордеров для робота, (чтобы отличал "свои" сделки)
extern bool Play_Sound = false; // воспроизведение звука при открытии: true - разрешено, false - запрещено

//--------------------------------------------------------------------------------------------------------------------+
//+ настройка таймфреймов и параметров индикатора SimpleBars |
extern int period = 6;
extern bool useClose = true;
extern int width = 3;
//+ настройка таймфреймов и параметров индикатора SimpleBars |
//--------------------------------------------------------------------------------------------------------------------+

//+-------------------------------------------------------------------------------------------------------------------+
//+ трейлинг стоп |
extern bool UseTrailing = true; // включение/выключение трейлинг стоп
extern int TrailingStop = 50; // фиксированный размер трейлинг стоп (в пунктах)
extern int TrailingStep = 1; // шаг трейлинг стоп (в пунктах)
//+ трейлинг стоп |
//+-------------------------------------------------------------------------------------------------------------------+

//+-------------------------------------------------------------------------------------------------------------------+
//| функция. которая выполняется при инициализации программы |
void init() {
if(GlobalVariableCheck("this_bar"+Symbol()+Period()))
GlobalVariableDel("this_bar"+Symbol()+Period());
return;
}
//| функция. которая выполняется при инициализации программы |
//+-------------------------------------------------------------------------------------------------------------------+

//+-------------------------------------------------------------------------------------------------------------------+
//| функция. которая выполняется при деинициализации программы |
void deinit() {
if(GlobalVariableCheck("this_bar"+Symbol()+Period()))
GlobalVariableDel("this_bar"+Symbol()+Period());
return;
}
//| функция. которая выполняется при деинициализации программы |
//+-------------------------------------------------------------------------------------------------------------------+

//+-------------------------------------------------------------------------------------------------------------------+
//| функция поиска торгового сигнала |
int fsignals() {
double signal = iCustom(NULL, 0, "SimpleBars", period, 0, 1, 4, 0);
return(0); // сигнал на открытие покупки
return(1); // сигнал на открытие продажи
return(-1); // отсутствие сигнала
} //end int fsignals()
//| функция поиска торгового сигнала |
//+-------------------------------------------------------------------------------------------------------------------+

//+-------------------------------------------------------------------------------------------------------------------+
//| функция отслеживания факта отработки робота на данном баре |
bool this_bar() {
if(
(!GlobalVariableCheck("this_bar"+Symbol()+Period()))
|| (GlobalVariableGet("this_bar"+Symbol()+Period())!=Time[0])
) {
GlobalVariableSet("this_bar"+Symbol()+Period(),Time[0]);
return(false);
} else {
return(true);
} //end if (.. (!GlobalVariableCheck("this_bar"+Symbol()+Period()))
} //end bool this_bar()
//| функция отслеживания факта отработки робота на данном баре |
//+-------------------------------------------------------------------------------------------------------------------+

//+-------------------------------------------------------------------------------------------------------------------+
//| функция поиска ордеров данного типа |
bool find_orders(int magic=-1, int type=-1, string symb="NULL") {
/* возвращает истину, если найден хотя бы один ордер данного типа с данным магическим номером по данному символу */
for (int i=OrdersTotal()-1; i>=0; i--) {
if(!OrderSelect(i,SELECT_BY_POS,MODE_TRADES)) break;
if(((OrderType()==type) || (type==-1))
&& ((OrderMagicNumber()==magic) || (magic==-1))
&& ((OrderSymbol()==Symbol() || (symb=="NONE")))) {
//если ордер найден, то возвращаем true и выходим из цикла
return(true);
break;
} //end if((OrderType()==type) && (OrderMagicNumber()==magic) && (OrderSymbol()==Symbol()))
} //end for (int i2=OrdersTotal()-1; i2>=0; i2--)

return(false); //возвращаем false
} //end bool find_orders(int magic, int type)
//| функция поиска ордеров данного типа |
//+-------------------------------------------------------------------------------------------------------------------+

//+-------------------------------------------------------------------------------------------------------------------+
//| функция расчета величины Stop Loss для ордеров |
double sl(int sl_value, int type, double price=0.0, string symb="NONE", int rmode=1) {
//type=0 -> рыночные покупки
//type=1 -> рыночные продажи
if(symb=="NONE") symb=Symbol();
if(type==0) price=NormalizeDouble(MarketInfo(symb,MODE_ASK),MarketInfo(symb,MODE_DIGITS));
if(type==1) price=NormalizeDouble(MarketInfo(symb,MODE_BID),MarketInfo(symb,MODE_DIGITS));
if(sl_value<=0) return(0);
if(rmode==1) {
if((type==0) || (type==2) || (type==4)) return(MarketInfo(symb,MODE_ASK)-sl_value*MarketInfo(symb,MODE_POINT)); //для покупок
if((type==1) || (type==3) || (type==5)) return(MarketInfo(symb,MODE_BID)+sl_value*MarketInfo(symb,MODE_POINT)); //для продаж
}
if(rmode==2) {
if((type==0) || (type==2) || (type==4)) return(MarketInfo(symb,MODE_BID)-sl_value*MarketInfo(symb,MODE_POINT)); //для покупок
if((type==1) || (type==3) || (type==5)) return(MarketInfo(symb,MODE_ASK)+sl_value*MarketInfo(symb,MODE_POINT)); //для продаж
}
} //end double sl(int sl_value, int type, double price=0.0, string symb="NONE", int rmode=1)
//| функция расчета величины Stop Loss для ордеров |
//+-------------------------------------------------------------------------------------------------------------------+

//+-------------------------------------------------------------------------------------------------------------------+
//| функция расчета величины Take Profit для ордеров |
double tp(int tp_value, int type, double price=0.0, string symb="NONE") {
//type=0 -> рыночные покупки
//type=1 -> рыночные продажи
if(symb=="NONE") symb=Symbol();
if(type==0) price=NormalizeDouble(MarketInfo(symb,MODE_ASK),MarketInfo(symb,MODE_DIGITS));
if(type==1) price=NormalizeDouble(MarketInfo(symb,MODE_BID),MarketInfo(symb,MODE_DIGITS));
if(tp_value<=0) return(0);
if((type==0) || (type==2) || (type==4)) return(price+tp_value*MarketInfo(symb,MODE_POINT)); //для покупок
if((type==1) || (type==3) || (type==5)) return(MarketInfo(symb,MODE_BID)-tp_value*MarketInfo(symb,MODE_POINT)); //для продаж
} //end double tp(int tp_value, int type, double price=0.0, string symb="NONE")
//| функция расчета величины Take Profit для ордеров |
//+-------------------------------------------------------------------------------------------------------------------+

//+-------------------------------------------------------------------------------------------------------------------+
//| функция открытия ордеров |
void open_positions(int signal, double lot, double price=0.0, string symb="NONE") {
//signal=0 -> сигнал на открытие покупки
//signal=1 -> сигнал на открытие продажи
/* extern */ int Count_Of_Trade_Try=5, Pause_Of_Trade_Try=5;

int i = 0; //переменная для счётчика цикла
int err = 0;

if(symb=="NONE") symb=Symbol();
if(signal==0)
price=NormalizeDouble(MarketInfo(symb,MODE_ASK),MarketInfo(symb,MODE_DIGITS)); //цена открытия для покупок
if(signal==1)
price=NormalizeDouble(MarketInfo(symb,MODE_BID),MarketInfo(symb,MODE_DIGITS)); //цена открытия для продаж

while(i<=Count_Of_Trade_Try) {
//сама функия открытия ордера (встроенная). Для удобства восприятия параметры разнесены на разные строки:
int ticket = OrderSend(Symbol(), //символ
signal, //тип ордера
lot, //объем
price, //цена открытия
Slipage, //уровень допустимого реквота
sl(SL,signal), //величина Stop Loss
tp(TP,signal), //величина Take Profit
Order_Comment, //комментарий ордера
Magic_Number, //магическое число
0, //срок истечения (используется при отложенных ордерах)
CLR_NONE); //цвет отображаемой стрелки на графике (CLR_NONE - стрелка не рисуется)
if(ticket!=-1) //если открытие произошло успешно, наносим графический объект и выходим из цикла
break;
err=GetLastError();
if(err!=0) Print("Ошибка: "+Market_Err_To_Str(err));
i++;
Sleep(Pause_Of_Trade_Try*1000); //в случае ошибки делаем паузу перед новой попыткой
} //end while(i<=count)
} //end void open_positions(int signal, double lot, double price=0.0, string symb="NONE")
//| функция открытия ордеров |
//+-------------------------------------------------------------------------------------------------------------------+

//+-------------------------------------------------------------------------------------------------------+
//| функция расшифровки кодов ошибок |
string Market_Err_To_Str(int err) {
/* функция охватывает только коды ошибок торговых операций */
switch(err) {
case(0): return("Нет ошибки");
case(1): return("Нет ошибки, но результат неизвестен");
case(2): return("Общая ошибка");
case(3): return("Неправильные параметры");
case(4): return("Торговый сервер занят");
case(5): return("Старая версия клиентского терминала");
case(6): return("Нет связи с торговым сервером");
case(7): return("Недостаточно прав");
case(8): return("Слишком частые запросы");
case(9): return("Недопустимая операция нарушающая функционирование сервера");
case(64): return("Счет заблокирован");
case(65): return("Неправильный номер счета");
case(128): return("Истек срок ожидания совершения сделки");
case(129): return("Неправильная цена");
case(130): return("Неправильные стопы");
case(131): return("Неправильный объём");
case(132): return("Рынок закрыт");
case(133): return("Торговля запрещена");
case(134): return("Недостаточно денег для совершения операции");
case(135): return("Цена изменилась");
case(136): return("Нет цен");
case(137): return("Брокер занят");
case(138): return("Новые цены");
case(139): return("Ордер заблокирован и уже обрабатывается");
case(140): return("Разрешена только покупка");
case(141): return("Слишком много запросов");
case(145): return("Модификация запрещена, т.к. ордер слишком близок к рынку");
case(146): return("Подсистема торговли занята");
case(147): return("Использование даты истечения запрещено брокером");
case(148): return("Количество открытых и отложенных ордеров достигло предела, установленного брокером");
case(149): return("Попытка открыть противоположную позицию к уже существующей в случае, если хеджирование запрещено");
case(150): return("Попытка закрыть позицию по инструменту в противоречии с правилом FIFO");

default: return("");
} //end switch(err)
} //end string Err_To_Str(int err)
//| функция расшифровки кодов ошибок |
//+-------------------------------------------------------------------------------------------------------+

//+-------------------------------------------------------------------------------------------------------+
//| Операции закрытия сделок |
//+----------------------------------------------------------------------------------------------------+
//| функция закрытия ордера по её номеру (тикету) |

bool close_by_ticket(int c_ticket, int slipage) {
/*
функция закрытия сделки по её номеру (тикету).
При закрытии рыночного ордера учитывается уровень максимально допустимого проскальзывания (slipage)
*/
/* extern */ int Count_Of_Trade_Try=5, Pause_Of_Trade_Try=5;

int i = 0; //переменная для счетчика цикла
int err = 0;
bool ticket = false; //перменная для обозначения (не)успешности факта закрытия сделки
double price = 0.0; //цена для закрываемой сделки (для рыночных ордеров)
if(OrderSelect(c_ticket,SELECT_BY_TICKET,MODE_TRADES)) { //выбираем ордер по тикету
if(OrderType()==OP_BUY) price = NormalizeDouble(Bid,Digits); //цена для покупок
if(OrderType()==OP_SELL) price = NormalizeDouble(Ask,Digits); //цена для продаж
for(i=0;i<=Count_Of_Trade_Try;i++) {
if(OrderType()<=1) //если рыночный ордер - закрываем его, если отложенный - удаляем
ticket=OrderClose(OrderTicket(),OrderLots(),price,slipage,CLR_NONE);
else
ticket=OrderDelete(OrderTicket());

if(ticket) { //если закрытие или удаление прошло успешно - возвращаем true и выходим из цикла
return(true);
break;
} //end if(ticket)
err=GetLastError();
if(err!=0) Print("Ошибка: "+Market_Err_To_Str(err));
Sleep(Pause_Of_Trade_Try*1000); //в случае ошибки делаем паузу перед новой попыткой
} //end for(i=0;i<=Count_Of_Trade_Try;i++)
} //end if(OrderSelect(c_ticket,SELECT_BY_TICKET,MODE_TRADES))

return(false); //возвращаем false
} //end bool close_by_ticket(int c_ticket)
//| функция закрытия ордера по её номеру (тикету) |
//+----------------------------------------------------------------------------------------------------+

bool cbm(int magic, int slipage, int type) {
/*
close by magic (закрытие всех ордеров данного типа с данным MagicNumber)
Учитывается максимально допустимое проскальзывание (slipage)
Используется функция close_by_ticket.
*/
int n = 0;
while (find_orders(magic, type))
for (int i2=OrdersTotal()-1; i2>=0; i2--) {
if (!OrderSelect(i2,SELECT_BY_POS,MODE_TRADES)) break;

if ((OrderType()==type) && (OrderMagicNumber()==magic)) {
close_by_ticket(OrderTicket(), slipage);
n++;
} //end if (((OrderType()==OP_BUY) || (OrderType()==OP_SELL)) && (OrderMagicNumber()==magic))
} //end for (int i2=OrdersTotal()-1; i2>=0; i2--)

if(n>0)
return(true);

return(false);
} //end bool cbm(int magic, int slipage, int type)
//| Операции закрытия сделок |
//+-------------------------------------------------------------------------------------------------------+

//+-------------------------------------------------------------------------------------------------------------------+
//| трейлинг стоп-лосс |
void T_SL() {
if(!UseTrailing) return;
int i = 0;
for(i=0; i<OrdersTotal(); i++) {
if(!(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))) continue;
if(OrderSymbol() != Symbol() || OrderMagicNumber()!=Magic_Number) continue;

if(OrderType()==OP_BUY) {
if(NormalizeDouble(Bid-OrderOpenPrice(),Digits)>NormalizeDouble(TrailingStop*Point,Digits)) {
if(NormalizeDouble(OrderStopLoss(),Digits)<NormalizeDouble(Bid-(TrailingStop+TrailingStep-1)*Point,Digits))
OrderModify(OrderTicket(), OrderOpenPrice(), NormalizeDouble(Bid-TrailingStop*Point,Digits), OrderTakeProfit(), 0, CLR_NONE);
} //end if(NormalizeDouble(Bid-OrderOpenPrice(),Digits)>NormalizeDouble(TrailingStop*Point,Digits))
} //end if(OrderType()==OP_BUY)

if(OrderType()==OP_SELL) {
if(NormalizeDouble(OrderOpenPrice()-Ask,Digits)>NormalizeDouble(TrailingStop*Point,Digits)) {
if(NormalizeDouble(OrderStopLoss(),Digits)>NormalizeDouble(Ask+(TrailingStop+TrailingStep-1)*Point,Digits))
OrderModify(OrderTicket(), OrderOpenPrice(), NormalizeDouble(Ask+TrailingStop*Point,Digits), OrderTakeProfit(), 0, CLR_NONE);
} //end if(NormalizeDouble(OrderOpenPrice()-Ask,Digits)>NormalizeDouble(TrailingStop*Point,Digits))
} //end if(OrderType()==OP_SELL)
} //end for(i=0; i<OrdersTotal(); i++)
} //end void T_SL()
//| трейлинг стоп-лосс |
//+-------------------------------------------------------------------------------------------------------------------+

//+-------------------------------------------------------------------------------------------------------------------+
//| главная функция |
void start() {

int sig = fsignals();

if(!find_orders(Magic_Number)) {
if((sig!=-1)) {
if(!this_bar()) {
open_positions(sig, Lots);
if(Play_Sound)
PlaySound("alert.wav");
}
} //end if((sig!=-1) && (!this_bar()))
} else {
if(sig==0) {
if(cbm(Magic_Number, Slipage, 1)) {
open_positions(sig, Lots);
if(Play_Sound)
PlaySound("alert.wav");
} //end if(cbm(Magic_Number, Slipage, 1))
} //end if(sig==0)
if(sig==1) {
if(cbm(Magic_Number, Slipage, 0)) {
open_positions(sig, Lots);
if(Play_Sound)
PlaySound("alert.wav");
} //end if(cbm(Magic_Number, Slipage, 0))
} //end if(sig==1)
T_SL();
} //end if(!find_orders(Magic_Number)) (else)
return;
}
//| главная функция |
//+-------------------------------------------------------------------------------------------------------------------+

Ttttimur 2015.12.02 19:17 #1

zhukov:

Нужно правильно изменить в советнике исходные данные на (1 покупка, -1 продажа)

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

Ttttimur 2015.12.02 19:25 #2

Вы не можете подсказать как изменить покупку на продажу в советнике moving average?

//+------------------------------------------------------------------+
//|                                               Moving Average.mq4 |
//|                   Copyright 2005-2014, MetaQuotes Software Corp. |
//|                                              https://www.mql4.com |
//+------------------------------------------------------------------+
#property copyright   "2005-2014, MetaQuotes Software Corp."
#property link        "https://www.mql4.com"
#property description "Moving Average sample expert advisor"

#define MAGICMA  20131111
//--- Inputs
input double Lots          =0.1;
input double MaximumRisk   =0.02;
input double DecreaseFactor=3;
input int    MovingPeriod  =12;
input int    MovingShift   =6;
//+------------------------------------------------------------------+
//| Calculate open positions                                         |
//+------------------------------------------------------------------+
int CalculateCurrentOrders(string symbol)
  {
   int buys=0,sells=0;
//---
   for(int i=0;i<OrdersTotal();i++)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) break;
      if(OrderSymbol()==Symbol() && OrderMagicNumber()==MAGICMA)
        {
         if(OrderType()==OP_BUY)  buys++;
         if(OrderType()==OP_SELL) sells++;
        }
     }
//--- return orders volume
   if(buys>0) return(buys);
   else       return(-sells);
  }
//+------------------------------------------------------------------+
//| Calculate optimal lot size                                       |
//+------------------------------------------------------------------+
double LotsOptimized()
  {
   double lot=Lots;
   int    orders=HistoryTotal();     // history orders total
   int    losses=0;                  // number of losses orders without a break
//--- select lot size
   lot=NormalizeDouble(AccountFreeMargin()*MaximumRisk/1000.0,1);
//--- calcuulate number of losses orders without a break
   if(DecreaseFactor>0)
     {
      for(int i=orders-1;i>=0;i--)
        {
         if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY)==false)
           {
            Print("Error in history!");
            break;
           }
         if(OrderSymbol()!=Symbol() || OrderType()>OP_SELL)
            continue;
         //---
         if(OrderProfit()>0) break;
         if(OrderProfit()<0) losses++;
        }
      if(losses>1)
         lot=NormalizeDouble(lot-lot*losses/DecreaseFactor,1);
     }
//--- return lot size
   if(lot<0.1) lot=0.1;
   return(lot);
  }
//+------------------------------------------------------------------+
//| Check for open order conditions                                  |
//+------------------------------------------------------------------+
void CheckForOpen()
  {
   double ma;
   int    res;
//--- go trading only for first tiks of new bar
   if(Volume[0]>1) return;
//--- get Moving Average 
   ma=iMA(NULL,0,MovingPeriod,MovingShift,MODE_SMA,PRICE_CLOSE,0);
//--- sell conditions
   if(Open[1]>ma && Close[1]<ma)
     {
      res=OrderSend(Symbol(),OP_SELL,LotsOptimized(),Bid,3,0,0,"",MAGICMA,0,Red);
      return;
     }
//--- buy conditions
   if(Open[1]<ma && Close[1]>ma)
     {
      res=OrderSend(Symbol(),OP_BUY,LotsOptimized(),Ask,3,0,0,"",MAGICMA,0,Blue);
      return;
     }
//---
  }
//+------------------------------------------------------------------+
//| Check for close order conditions                                 |
//+------------------------------------------------------------------+
void CheckForClose()
  {
   double ma;
//--- go trading only for first tiks of new bar
   if(Volume[0]>1) return;
//--- get Moving Average 
   ma=iMA(NULL,0,MovingPeriod,MovingShift,MODE_SMA,PRICE_CLOSE,0);
//---
   for(int i=0;i<OrdersTotal();i++)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) break;
      if(OrderMagicNumber()!=MAGICMA || OrderSymbol()!=Symbol()) continue;
      //--- check order type 
      if(OrderType()==OP_BUY)
        {
         if(Open[1]>ma && Close[1]<ma)
           {
            if(!OrderClose(OrderTicket(),OrderLots(),Bid,3,White))
               Print("OrderClose error ",GetLastError());
           }
         break;
        }
      if(OrderType()==OP_SELL)
        {
         if(Open[1]<ma && Close[1]>ma)
           {
            if(!OrderClose(OrderTicket(),OrderLots(),Ask,3,White))
               Print("OrderClose error ",GetLastError());
           }
         break;
        }
     }
//---
  }
//+------------------------------------------------------------------+
//| OnTick function                                                  |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- check for history and trading
   if(Bars<100 || IsTradeAllowed()==false)
      return;
//--- calculate open orders by current symbol
   if(CalculateCurrentOrders(Symbol())==0) CheckForOpen();
   else                                    CheckForClose();
//---
  }
//+------------------------------------------------------------------+

Victor Nikolaev 2015.12.03 01:40 #3

Для вставки кода используйте кнопку "SRC" в редакторе.

Новый комментарий