Soy autodidacta y no podré explicártelo - sólo he elegido las funciones que necesito, sé que esto va ahí y aquello va ahí.
Básicamente, todas las funciones las copio de los códigos de Vladimir Karputov, por lo que le doy las gracias. - Él le dirá si tiene alguna pregunta.
Tú eres autodidacta y yo acabo de empezar a programar y tengo la cabeza llena de preguntas.
Tengo el algoritmo para este EA en mi cabeza y no hay problema si tengo que cambiar el indicador en el proceso, porque sólo hay dos tareas (punto de dirección - arriba y punto de dirección - abajo).
De momento, parto del clásico de que lo más sencillo es lo mejor. Por eso quiero simplificar al máximo ...... y al mismo tiempo sacar el máximo partido a lo que quiero crear. Le propongo que trabajemos juntos en mi algoritmo, creo que sería interesante para ambos.
Si está interesado, póngase en contacto conmigo en persona.
aquí hay otra opción - una vez que la toma se activa - se abrirá de nuevo en la misma dirección
Exactamente, ¡¡¡con beneficio!!!
A primera vista, todo es correcto.
Y el hecho de que no debería haber ningún Stop Loss - todo correcto también.
Pero no entiendo qué pasa con la oder, que no se cierra en Take Profit....... cuando cambia la dirección del precio....(sólo se cierra por defecto, es decir, a la señal del indicador de cambio de tendencia)? Si es así, no es mi intención.
Y según mi idea - la orden debe permanecer, pero aquí debe entrar en vigor - un martin con sus ajustes:
input group "======== МАРТИН ========";
inputint MMType = 1; // 1 - вкл. , 2 - выкл.inputdouble Multiplikator = 1.667; // множитель следующего лотаinputdouble Step = 150.0; // Расстояние между ордерами
Es decir, establecer órdenes en sentido contrario a la tendencia con lote creciente y take profit medio. En resumen, trabajar como un simple Martin, por ejemplo (Autoprofit 3), que es de código abierto en la web, pero escrito en mql4.
Por cierto, la variante original del trabajo de tendencia, que usted escribió correctamente, no ha sido cancelada al trabajar con Martin.
En resumen, el trabajo de tendencia es una tarea, que usted ha demostrado brillantemente en parte, y la segunda tarea es un martín.
No es necesario que estas dos tareas estén interrelacionadas; en mi opinión, pueden funcionar de forma totalmente independiente
Y el hecho de que el Stop Loss - tampoco debería estar ahí - todo correcto.
Pero no entendí donde el oder, que no se cerró en Take Profit....... cuando la dirección de los cambios de precios....(sólo se cierra por defecto, es decir, a la señal del indicador de cambio de tendencia)? Si es así, no es mi intención.
Pero según mi idea, la orden debería permanecer, pero aquí debería entrar en vigor un martin con sus ajustes:
Lo mismo ocurre con el otro lado, es decir, establecer órdenes en la dirección opuesta a la tendencia con un tamaño de lote creciente y promediando el take profit. En resumen, trabajar como un simple Martin - por ejemplo (Autoprofit 3), que es de código abierto en la web, pero escrito en mql4.
Una observación de una vez: no "orden", sino "posición".
todas las opciones que pude encontrar - no parece haber más
//+------------------------------------------------------------------+//| 4 Sprut 185.mq5 |//| Copyright 2021, MetaQuotes Ltd. |//| https://www.mql5.com |//+------------------------------------------------------------------+#property copyright"Copyright 2021, MetaQuotes Ltd."#property link"https://www.mql5.com"#property version"1.00"//---#define MACD_MAGIC 1234502//---#include <Trade\Trade.mqh>
#include <Trade\SymbolInfo.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\AccountInfo.mqh>
//---double m_adjusted_point; // point value adjusted for 3 or 5 points
CTrade m_trade; // trading object
CSymbolInfo m_symbol; // symbol info object
CPositionInfo m_position; // trade position object
CAccountInfo m_account; // account info wrapper//---inputdouble InpLots =0.1; // Lotsinputint InpTakeProfit =50; // Take Profit (in pips)inputbool InpVariant =false; // Optioninputint InpBar =1; // Barinputbool InpClOp =false; // Close opposite//---double m_macd_current;
double m_signal_current;
double m_take_profit;
int price_uno;
int m_handle_macd; // MACD indicator handleint ExtTimeOut=10; // time out in seconds between trade operations//+------------------------------------------------------------------+//| Expert initialization function |//+------------------------------------------------------------------+intOnInit()
{
//--- initialize common information
m_symbol.Name(Symbol()); // symbol
m_trade.SetExpertMagicNumber(MACD_MAGIC); // magic
m_trade.SetMarginMode();
m_trade.SetTypeFillingBySymbol(Symbol());
//--- tuning for 3 or 5 digitsint digits_adjust=1;
if(m_symbol.Digits()==3 || m_symbol.Digits()==5)
digits_adjust=10;
m_adjusted_point=m_symbol.Point()*digits_adjust;
//--- set default deviation for trading in adjusted points
m_take_profit =InpTakeProfit*m_adjusted_point;
//--- set default deviation for trading in adjusted points
m_trade.SetDeviationInPoints(3*digits_adjust);
//--- create StepMA_NRTR indicator
m_handle_macd=iCustom(NULL,0,"StepMA_NRTR");
if(m_handle_macd==INVALID_HANDLE)
{
printf("Error creating StepMA_NRTR indicator");
return(false);
}
//---return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+//| Expert deinitialization function |//+------------------------------------------------------------------+voidOnDeinit(constint reason)
{
//---
}
//+------------------------------------------------------------------+//| Expert tick function |//+------------------------------------------------------------------+voidOnTick(void)
{
staticdatetime limit_time=0; // last trade processing time + timeout//--- don't process if timeoutif(TimeCurrent()>=limit_time)
{
//--- check for dataif(Bars(Symbol(),Period())>2)
{
//--- change limit time by timeout in seconds if processedif(!InpVariant && Processing())
limit_time=TimeCurrent()+ExtTimeOut;
//--- change limit time by timeout in seconds if processedif(InpVariant && Processing_1())
limit_time=TimeCurrent()+ExtTimeOut;
}
}
}
//+------------------------------------------------------------------+//| main function returns true if any position processed |//+------------------------------------------------------------------+bool Processing(void)
{
//--- refresh ratesif(!m_symbol.RefreshRates())
return(false);
double m_buff_MACD_main[],m_buff_MACD_signal[];
ArraySetAsSeries(m_buff_MACD_main,true);
ArraySetAsSeries(m_buff_MACD_signal,true);
int start_pos=InpBar,count=3;
if(!iGetArray(m_handle_macd,0,start_pos,count,m_buff_MACD_main)||
!iGetArray(m_handle_macd,1,start_pos,count,m_buff_MACD_signal))
{
return(false);
}
//---
m_macd_current =m_buff_MACD_main[0];
m_signal_current =m_buff_MACD_signal[0];
//---if(m_position.Select(Symbol()))
{
//--- try to close or modify long positionif(LongClosed())
return(true);
//--- try to close or modify short positionif(ShortClosed())
return(true);
}
else
{
//--- check for long position (BUY) possibilityif(LongOpened())
return(true);
//--- check for short position (SELL) possibilityif(ShortOpened())
return(true);
}
//--- exit without position processingreturn(false);
}
//+------------------------------------------------------------------+//| main function returns true if any position processed |//+------------------------------------------------------------------+bool Processing_1(void)
{
//--- refresh ratesif(!m_symbol.RefreshRates())
return(false);
double m_buff_MACD_main[],m_buff_MACD_signal[];
bool StNRUp,StNRDn;
ArraySetAsSeries(m_buff_MACD_main,true);
ArraySetAsSeries(m_buff_MACD_signal,true);
int start_pos=InpBar,count=3;
if(!iGetArray(m_handle_macd,0,start_pos,count,m_buff_MACD_main)||
!iGetArray(m_handle_macd,1,start_pos,count,m_buff_MACD_signal))
{
return(false);
}
//---
m_macd_current =m_buff_MACD_main[0];
m_signal_current =m_buff_MACD_signal[0];
//---
StNRUp=m_buff_MACD_main[0]<m_buff_MACD_signal[0];
StNRDn=m_buff_MACD_main[0]>m_buff_MACD_signal[0];
//--- BUY Signalif(StNRUp)
{
if(InpClOp)
if(ShortClosed())
Sleep(1000);
if(price_uno<0)
LongOpened();
price_uno=+1;
return(true);
}
//--- SELL Signalif(StNRDn)
{
if(InpClOp)
if(LongClosed())
Sleep(1000);
if(price_uno>0)
ShortOpened();
price_uno=-1;
return(true);
}
//--- exit without position processingreturn(false);
}
//+------------------------------------------------------------------+//| Check for long position closing |//+------------------------------------------------------------------+bool LongClosed(void)
{
bool res=false;
//--- should it be closed?if(m_macd_current>m_signal_current)
{
//--- close positionif(InpClOp)
ClosePositions(POSITION_TYPE_BUY);
//--- processed and cannot be modified
res=true;
}
//--- resultreturn(res);
}
//+------------------------------------------------------------------+//| Check for short position closing |//+------------------------------------------------------------------+bool ShortClosed(void)
{
bool res=false;
//--- should it be closed?if(m_macd_current<m_signal_current)
{
//--- close positionif(InpClOp)
ClosePositions(POSITION_TYPE_SELL);
//--- processed and cannot be modified
res=true;
}
//--- resultreturn(res);
}
//+------------------------------------------------------------------+//| Check for long position opening |//+------------------------------------------------------------------+bool LongOpened(void)
{
bool res=false;
//--- check for long position (BUY) possibilityif(m_macd_current<m_signal_current)
{
double price=m_symbol.Ask();
double tp =m_symbol.Bid()+m_take_profit;
//--- check for free moneyif(m_account.FreeMarginCheck(Symbol(),ORDER_TYPE_BUY,InpLots,price)<0.0)
printf("We have no money. Free Margin = %f",m_account.FreeMargin());
else
{
//--- open positionif(m_trade.PositionOpen(Symbol(),ORDER_TYPE_BUY,InpLots,price,0.0,tp))
printf("Position by %s to be opened",Symbol());
else
{
printf("Error opening BUY position by %s : '%s'",Symbol(),m_trade.ResultComment());
printf("Open parameters : price=%f,TP=%f",price,tp);
}
PlaySound("ok.wav");
}
//--- in any case we must exit from expert
res=true;
}
//--- resultreturn(res);
}
//+------------------------------------------------------------------+//| Check for short position opening |//+------------------------------------------------------------------+bool ShortOpened(void)
{
bool res=false;
//--- check for short position (SELL) possibilityif(m_macd_current>m_signal_current)
{
double price=m_symbol.Bid();
double tp =m_symbol.Ask()-m_take_profit;
//--- check for free moneyif(m_account.FreeMarginCheck(Symbol(),ORDER_TYPE_SELL,InpLots,price)<0.0)
printf("We have no money. Free Margin = %f",m_account.FreeMargin());
else
{
//--- open positionif(m_trade.PositionOpen(Symbol(),ORDER_TYPE_SELL,InpLots,price,0.0,tp))
printf("Position by %s to be opened",Symbol());
else
{
printf("Error opening SELL position by %s : '%s'",Symbol(),m_trade.ResultComment());
printf("Open parameters : price=%f,TP=%f",price,tp);
}
PlaySound("ok.wav");
}
//--- in any case we must exit from expert
res=true;
}
//--- resultreturn(res);
}
//+------------------------------------------------------------------+//| Refreshes the symbol quotes data |//+------------------------------------------------------------------+bool RefreshRates()
{
//--- refresh ratesif(!m_symbol.RefreshRates())
{
return(false);
}
//--- protection against the return value of "zero"if(m_symbol.Ask()==0 || m_symbol.Bid()==0)
{
return(false);
}
//---return(true);
}
//+------------------------------------------------------------------+//| Check Freeze and Stops levels |//+------------------------------------------------------------------+void FreezeStopsLevels(double &freeze,double &stops)
{
//--- check Freeze and Stops levelsdouble coeff=(double)1;
if(!RefreshRates() || !m_symbol.Refresh())
return;
//--- FreezeLevel -> for pending order and modificationdouble freeze_level=m_symbol.FreezeLevel()*m_symbol.Point();
if(freeze_level==0.0)
if(1>0)
freeze_level=(m_symbol.Ask()-m_symbol.Bid())*coeff;
//--- StopsLevel -> for TakeProfit and StopLossdouble stop_level=m_symbol.StopsLevel()*m_symbol.Point();
if(stop_level==0.0)
if(1>0)
stop_level=(m_symbol.Ask()-m_symbol.Bid())*coeff;
//---
freeze=freeze_level;
stops=stop_level;
//---return;
}
//+------------------------------------------------------------------+//| Close positions |//+------------------------------------------------------------------+void ClosePositions(constENUM_POSITION_TYPE pos_type)
{
double freeze=0.0,stops=0.0;
FreezeStopsLevels(freeze,stops);
for(int i=PositionsTotal()-1; i>=0; i--) // returns the number of current positionsif(m_position.SelectByIndex(i)) // selects the position by index for further access to its propertiesif(m_position.Symbol()==m_symbol.Name() && m_position.Magic()==MACD_MAGIC)
if(m_position.PositionType()==pos_type)
{
if(m_position.PositionType()==POSITION_TYPE_BUY)
{
bool take_profit_level=((m_position.TakeProfit()!=0.0 && m_position.TakeProfit()-m_position.PriceCurrent()>=freeze) || m_position.TakeProfit()==0.0);
bool stop_loss_level=((m_position.StopLoss()!=0.0 && m_position.PriceCurrent()-m_position.StopLoss()>=freeze) || m_position.StopLoss()==0.0);
if(take_profit_level && stop_loss_level)
if(!m_trade.PositionClose(m_position.Ticket())) // close a position by the specified m_symbolPrint(__FILE__," ",__FUNCTION__,", ERROR: ","BUY PositionClose ",m_position.Ticket(),", ",m_trade.ResultRetcodeDescription());
}
if(m_position.PositionType()==POSITION_TYPE_SELL)
{
bool take_profit_level=((m_position.TakeProfit()!=0.0 && m_position.PriceCurrent()-m_position.TakeProfit()>=freeze) || m_position.TakeProfit()==0.0);
bool stop_loss_level=((m_position.StopLoss()!=0.0 && m_position.StopLoss()-m_position.PriceCurrent()>=freeze) || m_position.StopLoss()==0.0);
if(take_profit_level && stop_loss_level)
if(!m_trade.PositionClose(m_position.Ticket())) // close a position by the specified m_symbolPrint(__FILE__," ",__FUNCTION__,", ERROR: ","SELL PositionClose ",m_position.Ticket(),", ",m_trade.ResultRetcodeDescription());
}
PlaySound("ok.wav");
}
}
//+------------------------------------------------------------------+//| Filling the indicator buffers from the indicator |//+------------------------------------------------------------------+bool iGetArray(constint handle,constint buffer,constint start_pos,
constint count,double &arr_buffer[])
{
bool result=true;
if(!ArrayIsDynamic(arr_buffer))
{
return(false);
}
ArrayFree(arr_buffer);
//--- reset error codeResetLastError();
//--- fill a part of the iBands array with values from the indicator bufferint copied=CopyBuffer(handle,buffer,start_pos,count,arr_buffer);
if(copied!=count)
{
return(false);
}
return(result);
}
//+------------------------------------------------------------------+
todas las opciones que pude encontrar - no parece haber más
¿Qué sucede si intenta utilizar 2 bloques independientes en su Asesor Experto? Entonces uno trabajará por su cuenta, como ya ha trabajado en la - tendencia (usando un indicador)..........
Y el segundo por la señal establecida por el primer bloque - por posición - no por tendencia........
Ya he escrito más arriba:
Estas dos tareas no tienen por qué estar interrelacionadas; en mi opinión, pueden funcionar de forma totalmente independiente.
Este algoritmo que propongo (en mi opinión) aún no ha sido utilizado por los programadores. En cualquier caso, no he encontrado esa solución en Internet.
Sprut 185: Este algoritmo que propongo - (en mi opinión) aún no ha sido utilizado por los programadores. En cualquier caso, no he encontrado esa solución en Internet.
esto probablemente no es posible de implementar
no da - en el símbolo, debe haber una posición (si se cierra en una ganancia y se reabre una posición) (y cuando se aplica la señal contraria - no puede abrirse en la otra dirección
if(m_position.Select(Symbol()))
si sólo de una señal (de un punto) no hay problema . (y esto no debería estar presente en el código (línea anterior))
no da - en el símbolo, debe haber una posición (si se cierra en una ganancia y se reabre una posición) (y cuando se aplica la señal contraria - no puede abrirse en la otra dirección
si sólo de una señal (de un punto) no hay problema . (y entonces, no debería estar presente en el código (línea anterior))
Ya veo, probablemente por eso no he encontrado esa solución en Internet. Pero, en mi opinión, debe haber una solución a este problema.
Gracias - Buscaré una solución a este problema.....
Soy autodidacta y no podré explicártelo - sólo he elegido las funciones que necesito, sé que esto va ahí y aquello va ahí.
Básicamente, todas las funciones las copio de los códigos de Vladimir Karputov, por lo que le doy las gracias. - Él le dirá si tiene alguna pregunta.
Tú eres autodidacta y yo acabo de empezar a programar y tengo la cabeza llena de preguntas.
Tengo el algoritmo para este EA en mi cabeza y no hay problema si tengo que cambiar el indicador en el proceso, porque sólo hay dos tareas (punto de dirección - arriba y punto de dirección - abajo).
La herencia implica la creación de una clase.
Así que estoy escribiendo... ¿de qué clase debería heredar mi clase para utilizar estos métodos de su biblioteca estándar?
aquí hay otra opción - una vez que la toma se activa - se abrirá de nuevo en la misma dirección
Exactamente, ¡¡¡con beneficio!!!
A primera vista, todo es correcto.
Y el hecho de que no debería haber ningún Stop Loss - todo correcto también.
Pero no entiendo qué pasa con la oder, que no se cierra en Take Profit....... cuando cambia la dirección del precio....(sólo se cierra por defecto, es decir, a la señal del indicador de cambio de tendencia)? Si es así, no es mi intención.
Y según mi idea - la orden debe permanecer, pero aquí debe entrar en vigor - un martin con sus ajustes:
Es decir, establecer órdenes en sentido contrario a la tendencia con lote creciente y take profit medio. En resumen, trabajar como un simple Martin, por ejemplo (Autoprofit 3), que es de código abierto en la web, pero escrito en mql4.
Por cierto, la variante original del trabajo de tendencia, que usted escribió correctamente, no ha sido cancelada al trabajar con Martin.
En resumen, el trabajo de tendencia es una tarea, que usted ha demostrado brillantemente en parte, y la segunda tarea es un martín.
No es necesario que estas dos tareas estén interrelacionadas; en mi opinión, pueden funcionar de forma totalmente independiente
Absolutamente cierto, ¡¡¡con beneficios!!!
A primera vista, todo es correcto.
Y el hecho de que el Stop Loss - tampoco debería estar ahí - todo correcto.
Pero no entendí donde el oder, que no se cerró en Take Profit....... cuando la dirección de los cambios de precios....(sólo se cierra por defecto, es decir, a la señal del indicador de cambio de tendencia)? Si es así, no es mi intención.
Pero según mi idea, la orden debería permanecer, pero aquí debería entrar en vigor un martin con sus ajustes:
Lo mismo ocurre con el otro lado, es decir, establecer órdenes en la dirección opuesta a la tendencia con un tamaño de lote creciente y promediando el take profit. En resumen, trabajar como un simple Martin - por ejemplo (Autoprofit 3), que es de código abierto en la web, pero escrito en mql4.Una observación de una vez: no "orden", sino "posición".
Una observación a la vez: no es "orden" sino "posición".
todas las opciones que pude encontrar - no parece haber más
todas las opciones que pude encontrar - no parece haber más
Ya he escrito más arriba:
Estas dos tareas no tienen por qué estar interrelacionadas; en mi opinión, pueden funcionar de forma totalmente independiente.
Este algoritmo que propongo (en mi opinión) aún no ha sido utilizado por los programadores. En cualquier caso, no he encontrado esa solución en Internet.
esto probablemente no es posible de implementar
no da - en el símbolo, debe haber una posición (si se cierra en una ganancia y se reabre una posición) (y cuando se aplica la señal contraria - no puede abrirse en la otra dirección
si sólo de una señal (de un punto) no hay problema . (y esto no debería estar presente en el código (línea anterior))
esto probablemente no es posible de implementar
no da - en el símbolo, debe haber una posición (si se cierra en una ganancia y se reabre una posición) (y cuando se aplica la señal contraria - no puede abrirse en la otra dirección
si sólo de una señal (de un punto) no hay problema . (y entonces, no debería estar presente en el código (línea anterior))
Después de actualizar a la versión 2981, comenzó a aparecer un error en la línea