Любой вопрос новичка, чтоб не захламлять форум. Профи, не проходите мимо. Без вас никуда - 6. - страница 539

 
tatianati:

Спасибо! Получилось, радовалась как ребёнок, однако советник перестал выставлять "новые. Подскажите, где ошиблась?

Хух, нашла ошибку, совсем не там где искала изначально. Со следующей задачей самой не справиться.

Подскажите как задать диапазон отклонения - удаления цены от МА.

extern string s10                = ">>>>>>>>>>>>>>>>>>>>>>>>>>>>";
extern string s11                = ">>> Вход против МА";
extern int    iMA_Period         = 365;
extern int    iMA_OpenDistance   = 60;     // как задать диапазон? например 60-85 за его пределами не открывать ордеров

Вот часть со входом

int GetSignal()
{
  int Signal = 0;

  double iMA_Signal = iMA(Symbol(), 0, iMA_Period, 0, MODE_SMMA, PRICE_CLOSE, 0);
  
  int Ma_Bid_Diff = MathAbs(iMA_Signal - Bid)/vPoint;
  
  if(Ma_Bid_Diff > iMA_OpenDistance && Bid > iMA_Signal) Signal = -1;
  if(Ma_Bid_Diff > iMA_OpenDistance && Bid < iMA_Signal) Signal = 1;
  
  return(Signal);
}
 
tatianati:

Хух, нашла ошибку, совсем не там где искала изначально. Со следующей задачей самой не справиться.

Подскажите как задать диапазон отклонения - удаления цены от МА.

Вот часть со входом


extern int    Min_iMA_OpenDistance   = 60;
extern int    Max_iMA_OpenDistance   = 85;

И соответственно условие

if(Ma_Bid_Diff > Min_iMA_OpenDistance && Ma_Bid_Diff < Max_iMA_OpenDistance && Bid > iMA_Signal)
 

Нужно правильно изменить в советнике исходные данные на (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;
}
//| главная функция |
//+-------------------------------------------------------------------------------------------------------------------+
 

Привет знатокам. Помогите - неработает. Думаю, что запутался инициализацией переменых. Голова кругом идет, а найти ошибок немогу.

Вместо открытия позиций советник должен рисовать стрелки по цене Клозе(0), а вместо закрытия - крестик и отпечатать в фаил данные (fExpiration_func(Expiration), fop_time, cl_time, fop_price, cl_price, ftype) в новую строку.

Тут стохастик взят только за пример.

//+------------------------------------------------------------------+
//|                                                     binar_v1.mq4 |
//|                        Copyright 2014, MetaQuotes Software Corp. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2014, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"


//--- input Time parameters
input uchar    hs = 9; 
input uchar    ms = 0; 
input uchar    he = 18; 
input uchar    me = 0;
//--- input Indicator parameters

//--- input Expiration parameters
input uchar    Expiration = 2;//время експирации в минутах


input bool     strategy_1  =  true;


bool poz;                                  //открытая/закрытая позиция
datetime op_time;                         //время открытия
double op_price;                          //цена открытия
char type;                                //тип открытой позиции -1 СЕЛЛ, 1- БАИ
//+=================================================================================+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- 
   
      
//---
   return(INIT_SUCCEEDED);
  }
//+=================================================================================+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- destroy timer
   
      
  }
//+=================================================================================+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
  //подщитаем арифметическое среднее OC за прошлую неделю
  //Пощет один раз в неделю    
     /* if(isNewBar("",PERIOD_W1)){      
         uchar iPr=iBarShift(NULL,PERIOD_M1,iTime(NULL,PERIOD_W1,1));
         uchar iPn=iBarShift(NULL,PERIOD_M1,iTime(NULL,PERIOD_W1,1))+10080;
         double avgM1=AvgOC(iPr,iPn,0);                                     // M1 OC цредняя за прошлую неделю               
      }*/
      if(!fisTradeTimeInt(9,0,18,0))return;                                 //Время торгов
      if(strategy_1==true)fStrategy1();
  }
//+=================================================================================+
//| Timer function                                                   |
//+------------------------------------------------------------------+

//+=================================================================================+
void fStrategy1
   (
   
   )
//--------------------   
{
   

   if(poz==true)                             //если есть открыта позиция
      fClose_Pos(op_time,op_price,type);      //закрываем
   if(poz==false){                           //если нет открытой
      fOpen_buy(poz,op_time,op_price,type);   //покупка   
      fOpen_sell(poz,op_time,op_price,type);  //продажа
   }       
}
//+=================================================================================+
void fOpen_buy
   (
   bool & op,                                //открытая/закрытая позиция
   datetime & out_op_time,                       //время открытия
   double & out_op_price,                        //цена открытия
   char & out_type                               //тип открытой позиции -1 СЕЛЛ, 1- БАИ
   )
//--------------------
{
   double stoch_M0_1 =iStochastic(NULL,0,5,3,3,MODE_SMA,0,MODE_MAIN,1);
   double stoch_M0_2 =iStochastic(NULL,0,5,3,3,MODE_SMA,0,MODE_MAIN,2);
   double stoch_M0_1s=iStochastic(NULL,0,5,3,3,MODE_SMA,0,MODE_SIGNAL,1);
   double stoch_M0_2s=iStochastic(NULL,0,5,3,3,MODE_SMA,0,MODE_SIGNAL,2);
   
   string arrowName;
   
   if(!op){      
      if(stoch_M0_1 <20 && stoch_M0_2 < stoch_M0_2s && stoch_M0_1s < stoch_M0_1){
          out_type=-1;
          op=true;
          out_op_price=Close[0];
          out_op_time=Time[0];
          arrowName="Buy"+TimeToStr(TimeCurrent(),TIME_DATE|TIME_SECONDS);
          fDrawArrow(arrowName="",out_op_price,out_op_time,Blue,240);               //стрелка открытой позиции
      }
          
   }     
}
//+=================================================================================+
void fOpen_sell
   (
   bool op,                                //открытая/закрытая позиция
   datetime & out_op_time,                       //время открытия
   double & out_op_price,                        //цена открытия
   char & out_type                               //тип открытой позиции -1 СЕЛЛ, 1- БАИ
   )
//--------------------   
{      
   double stoch_M0_1 =iStochastic(NULL,0,5,3,3,MODE_SMA,0,MODE_MAIN,1);
   double stoch_M0_2 =iStochastic(NULL,0,5,3,3,MODE_SMA,0,MODE_MAIN,2);
   double stoch_M0_1s=iStochastic(NULL,0,5,3,3,MODE_SMA,0,MODE_SIGNAL,1);
   double stoch_M0_2s=iStochastic(NULL,0,5,3,3,MODE_SMA,0,MODE_SIGNAL,2);
   
   string arrowName;
   
   if(!op){      
      if(stoch_M0_1 > 80 && stoch_M0_2 > stoch_M0_2s && stoch_M0_1s > stoch_M0_1){
          out_type=-1;
          op=true;
          out_op_price=Close[0];
          out_op_time=Time[0];
          arrowName="Sell"+TimeToStr(TimeCurrent(),TIME_DATE|TIME_SECONDS);
          fDrawArrow(arrowName="",out_op_price,out_op_time,Red,240);              //стрелка открытой позиции
      }
          
   }     
}
//+=================================================================================+
void fClose_Pos //jei yra atidaryta, uzdarom
   (
   datetime fop_time,                      //время открытия
   double fop_price,                       //цена открытия
   char ftype                              //тип открытой позиции -1 СЕЛЛ, 1- БАИ
   )
//-------------------   
{
   string arrowName="Close"+TimeToStr(TimeCurrent(),TIME_DATE|TIME_SECONDS);    
   double cl_price;
   string fileName=StringConcatenate("Strategy_1  ",Expiration," ",Period(),".csv");
   
   if(Expiration<=5){                     //
      datetime cl_time= Expiration*60+op_time;                                         //время закрытия
      if(TimeCurrent()>=cl_time){
         
         cl_price=Close[0];               //цена закрытия         
         fDrawArrow(arrowName,cl_price,cl_time,Yellow,251);                             //наносим крестик на график
         fSaveToFile(fileName,Expiration, fop_time, cl_time, fop_price, cl_price, ftype);  //в новую строку сохроняем в файле
      }   
   }
   else{
      cl_time= fExpiration_func(Expiration)*60+op_time;                                 //время закрытия
      
      if(TimeMinute(TimeCurrent())>=TimeMinute(cl_time)){
         
         cl_price=Close[0];      
         fDrawArrow(arrowName,cl_price,cl_time,Yellow,251);                             //наносим крестик на график
         fSaveToFile(fileName,fExpiration_func(Expiration), fop_time, cl_time, fop_price, cl_price, ftype);//в новую строку сохроняем в файле
     }
   }   
}
//+=================================================================================+
bool fisNewBar 
   (
   string f_sy,   
   int f_tf
   )
{
    int iIndex = -1;
//----
    switch (f_tf)
    {
        case 1    : iIndex = 0; break;
        case 5    : iIndex = 1; break;
        case 15   : iIndex = 2; break;
        case 30   : iIndex = 3; break;
        case 60   : iIndex = 4; break;
        case 240  : iIndex = 5; break;
        case 1440 : iIndex = 6; break;
        case 10080: iIndex = 7; break;
        default   : iIndex =-1; break;
    }
    
    static int LastBar[8]= {0,0,0,0,0,0,0,0}; 
    datetime curbar = iTime (f_sy, f_tf, 0);
    if (LastBar[iIndex] != curbar)
    {
        LastBar[iIndex] = curbar;
        return (true);
    }
    else
    {return (false);
 }
 }
//+=================================================================================+
int fExpiration_func
   (
   uchar e
   )
//--------------------   
{  
   uchar ex=0;
   uchar mod=0;
   if(e<6) 
      ex=e;//return(e);
   else {
      mod=fmod(e,5);
      if(mod==4) 
         ex=e+mod;//return(e+mod);
      else
         if(mod <4) 
            ex=e-mod;//return(e-mod);
    }     
   return(ex);//grazina laiko tarpa minutemis
}
//+=================================================================================+
bool fisTradeTimeInt     //время торгов
   (
   uchar hstart=0, 
   uchar mstart=0, 
   uchar hend=0, 
   uchar mend=0
   ) 
//--------------------   
{
  datetime db, de;           
  uchar      hc;              

  db=StrToTime(TimeToStr(TimeCurrent(), TIME_DATE)+" "+hstart+":"+mstart);
  de=StrToTime(TimeToStr(TimeCurrent(), TIME_DATE)+" "+hend+":"+mend);
  hc=TimeHour(TimeCurrent());
  if (db>=de) {
    if (hc>=hend) de+=24*60*60; 
    else db-=24*60*60;
  }
  if (TimeCurrent()>=db && TimeCurrent()<=de) return(True);
  else return(False);
}
//+=================================================================================+
void fDrawArrow //наносим стрелки на график
   (
   string arrowName="",
   double dwPrice=0,
   datetime dwTime=0,
   color dwColor=Silver,
   uchar dwArrowIndex=0
   )
//--------------------   
{
   ObjectCreate      (0,arrowName,OBJ_ARROW,0,0,0,0,0);                 // создадим стрелку
   ObjectSetInteger  (0,arrowName,OBJPROP_ARROWCODE,dwArrowIndex);      // установим код стрелки
   ObjectSetInteger  (0,arrowName,OBJPROP_COLOR,dwTime);                // зададим время
   ObjectSetInteger  (0,arrowName,OBJPROP_COLOR,dwColor);               // зададим Цвет
   ObjectSetDouble   (0,arrowName,OBJPROP_PRICE,dwPrice);               // зададим цену
   ChartRedraw(0);
}
//+=================================================================================+
//Aritmetinis vidurkis

double fAvgOC
   (
   uchar count_start,      //nuo kurio baro pradesim skaiciuoti
   uchar end_count,        //iki kurio baro skaiciuosime
   uchar j=0               //keli barai is eiles
   )
//--------------------   
{
   static double sum=0;
   if(sum==0){
      int n=0;
      for(int i=end_count; i<count_start; i++){
         double h=iClose(NULL,PERIOD_M1,i);  
         double l=iOpen(NULL,PERIOD_M1,i+j); 
         sum+=fabs(h-l);                  //padidinam avg 
         n++;                             //kie kartu buvo didintas avg
      }
      double avg=sum/n;                          //Surandam Mean aritmetini vidurki                 
   }   
   return(avg);                           //grazina kainu skirtumo vidurki
}
//+=================================================================================+
void fSaveToFile
   (
   string fileName,
   char expirration,       //realus ekspiracijos laikas minutemis
   datetime fop_time,
   datetime fcl_time,
   double fop_price,
   double fcl_price,
   uchar ftype
   )
//--------------------   
{
   //--- правильный способ работы в "файловой песочнице"
   ResetLastError();
  
   int filehandle=FileOpen(fileName,FILE_WRITE|FILE_CSV);
   if(filehandle!=INVALID_HANDLE)
     {
      FileWrite(filehandle,
               expirration,//real expiration time
               fop_time,//TimeToStr(op_time,TIME_DATE|TIME_SECONDS),
               fcl_time,//TimeToStr(cl_time,TIME_DATE|TIME_SECONDS),
               op_price,
               fcl_price,
               type);
      FileClose(filehandle);
      Print("FileOpen OK");
     }
   else Print("Операция FileOpen неудачна, ошибка ",GetLastError());
}
//+=================================================================================+
/*int gUrdala_News()
{
   HideTestIndicators(true);
   int nResult = iCustom(NULL, PERIOD_M1, "Urdala_News", MinDo, MinPosle, ChasPoyasServera, 0, 0);
   HideTestIndicators(false);
   return(nResult);
}*/
//+=================================================================================+
/*datetime SecondsAfter    //grazinamas laiko tarpas po timeOp
   (
   datetime timeOp,      //laiko atskaitos pradzia
   datetime t
   ) 
{
     
   if (t<timeOp) t=timeOp;          
   return(TimeCurrent()-t);
}*/
//+=================================================================================+
//---------------------------------------------------
  /* void click
   (
   int x, 
   int y
   ) 
   {    
      SetCursorPos(x,y); // см. тут _http://www.vsokovikov.narod.ru/New_MSDN_API/Cursor/fn_setcursorpos.htm 
      mouse_event(MOUSEEVENTF_LEFTDOWN, x, y, 0, 0); 
      mouse_event(MOUSEEVENTF_LEFTUP, x, y, 0, 0); 
   }*/
//+=================================================================================+
//---------------------------------------------------
   /*void key
   (
   uchar kodas
   )
   {  
      keybd_event(kodas,0,0,0);      
      keybd_event(kodas,0,KEYEVENTF_KEYUP,0); 
   } */  
 

Тогда вопрос такой - как вернуть два значения. Пробовал так, но ошибки

void OnTick()
  {
//---
   
   xy(10,20,100,100);
   Print("x=",x,"y=",y);
  }
//+------------------------------------------------------------------+
void xy(int xx,int xxx, int yy,int yyy,int & x,int & y){
   x=xx*xxx;
   y=yy+yyy;
}
 
gince:

Тогда вопрос такой - как вернуть два значения. Пробовал так, но ошибки


void OnTick()
  {
//---
   int x,y;
   xy(10,20,100,100,x,y);
   Print("x=",x,"y=",y);
  }
//+------------------------------------------------------------------+
void xy(int xx,int xxx, int yy,int yyy, int &x,int &y){
   x=xx*xxx;
   y=yy+yyy;
}
 
gince:

Тогда вопрос такой - как вернуть два значения. Пробовал так, но ошибки


А переменные не пробовали использовать. Вдруг поможет

void OnTick()
  {
//---
   int x=100.0, y=100.0;
   xy(10,20,100, 100, x,y);
   Print("x=",x,"y=",y);
  }
//+------------------------------------------------------------------+
void xy(int xx,int xxx, int yy,int yyy,int & x,int & y){
   x=xx*xxx;
   y=yy+yyy;
}
 

помогите если нежалко

научить советник торговать по индикатору

BS_Living Now ver #1.mq4 https://www.mql5.com/ru/code/11014#50910

UP= iCustom(Symbol(),NULL,"Now",BQuant,0,0);

DOW= iCustom(Symbol(),NULL,"Now",BQuant,1,0);


if(DOW){OrderSend(Symbol(), OP_SELL, Lot, Bid, Slip, 0, 0, "Forex-Robots.ru SELL", Magic, 0,Red);}


if(UP ){OrderSend(Symbol(), OP_BUY, Lot, Ask, Slip, 0, 0, "Forex-Robots.ru BUY", Magic, 0,Blue);}


Comment

(

"\n Профит: ", UP,

"\n Профит: ", DOW

);

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

 
Vinin:


А переменные не пробовали использовать. Вдруг поможет


Спасибо, работает

 
sannin:

помогите если нежалко

научить советник торговать по индикатору

BS_Living Now ver #1.mq4 https://www.mql5.com/ru/code/11014#50910


UP= iCustom(Symbol(),NULL,"Now",BQuant,0,2);//

DOW= iCustom(Symbol(),NULL,"Now",BQuant,1,2);


if(DOW != 0){OrderSend(Symbol(), OP_SELL, Lot, Bid, Slip, 0, 0, "Forex-Robots.ru SELL", Magic, 0,Red);}



if(UP != 0){OrderSend(Symbol(), OP_BUY, Lot, Ask, Slip, 0, 0, "Forex-Robots.ru BUY", Magic, 0,Blue);}
Cильно не вникал, но думаю, как-то так.
Причина обращения: