Sou autodidacta e não serei capaz de vos explicar isto - apenas escolhi as funções de que preciso, sei que isto vai para lá e aquilo vai para lá.
Basicamente todas as funções que copio dos códigos de Vladimir Karputov, pelos quais lhe agradeço muito! - Ele dir-lhe-á se tiver alguma dúvida.
É autodidacta, e eu acabo de começar a programar, e a minha cabeça está cheia de perguntas.
Tenho o algoritmo para esta EA na minha cabeça e não há problema se tiver de alterar o indicador no processo, porque só há duas tarefas (apontar para cima e apontar para baixo).
Neste momento, procedo do clássico que o mais simples é o melhor. É por isso que quero simplificar...... ao máximo e, ao mesmo tempo, tirar o máximo partido daquilo que quero criar. Proponho trabalhar em conjunto no meu algoritmo - penso que seria interessante para nós os dois.
Se estiver interessado, por favor contacte-me pessoalmente.
aqui está outra opção - assim que o take for accionado - abrirá novamente na mesma direcção
Exactamente certo, com lucro!!!
À primeira vista - tudo está correcto.
E o facto de que não deve haver Stop Loss - tudo correcto também.
Mas não entendo o que acontece ao oder, que não é fechado em Take Profit....... quando a direcção do preço muda....(apenas fecha por defeito, ou seja, sobre o sinal do indicador de mudança de tendência)? Se assim for, não é essa a minha intenção.
E de acordo com a minha ideia - a ordem deve permanecer, mas aqui deve entrar em vigor - um martin com as suas configurações:
input group "======== МАРТИН ========";
inputint MMType = 1; // 1 - вкл. , 2 - выкл.inputdouble Multiplikator = 1.667; // множитель следующего лотаinputdouble Step = 150.0; // Расстояние между ордерами
Ou seja, estabelecer ordens na direcção oposta à tendência com o aumento do lote e a obtenção de lucros médios. Em suma, trabalho como um simples Martin, por exemplo (Autoprofit 3), que é código aberto na web, mas escrito em mql4.
A propósito, a variante original do trabalho de tendências, que escreveu correctamente, não foi cancelada quando trabalhou com Martin.
Em suma, o trabalho de tendências é uma tarefa, que demonstrou brilhantemente em parte, e a segunda tarefa é um martin.
Não é necessário que estas duas tarefas estejam interligadas - na minha opinião, elas podem trabalhar de forma completamente independente
E o facto de que o Stop Loss - também não deveria estar lá - tudo correcto.
Mas não percebi onde o oder, que não fechou em Take Profit....... quando a direcção do preço mudou....(apenas fecha por defeito, ou seja, sobre o sinal do indicador de mudança de tendência)? Se assim for, não é essa a minha intenção.
Mas de acordo com a minha ideia, a ordem deve permanecer, mas um martin com as suas configurações deve entrar em vigor aqui:
O mesmo é verdade para o outro lado, ou seja, estabelecer ordens na direcção oposta à tendência com o aumento do tamanho do lote e a obtenção de lucros médios. Em suma, trabalhar como um simples Martin - por exemplo (Autoprofit 3), que é código aberto na web, mas escrito em mql4.
Uma observação ao mesmo tempo: não "ordem", mas "posição".
todas as opções que consegui encontrar - parece não haver mais
//+------------------------------------------------------------------+//| 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 as opções que consegui encontrar - parece não haver mais
E se tentar utilizar 2 blocos independentes no seu Expert Advisor. Depois trabalhar-se-á por conta própria, como já se trabalhou na - tendência (utilizando um indicador)..........
E o segundo pelo sinal estabelecido pelo primeiro bloco - por posição - e não por tendência........
Já escrevi acima:
Estas duas tarefas não têm de estar interligadas - na minha opinião, podem funcionar de forma completamente independente.
Um algoritmo tal que proponho (na minha opinião) ainda não foi utilizado pelos programadores. Em qualquer caso, não encontrei tal solução - na Internet.
Sprut 185: Este algoritmo que proponho - (na minha opinião) ainda não foi utilizado pelos programadores. Em qualquer caso, não encontrei tal solução na Internet.
isto provavelmente não é possível de implementar
não dá - no símbolo, deve haver uma posição (se for fechada com lucro e reaberta uma posição) (e quando é aplicado o sinal oposto - não pode abrir na outra direcção
if(m_position.Select(Symbol()))
se apenas a partir de um sinal (de um ponto) não houver problema . (e isto não deve estar presente no código (linha acima)))
não dá - no símbolo, deve haver uma posição (se for fechada com lucro e reaberta uma posição) (e quando é aplicado o sinal oposto - não pode abrir na outra direcção
se apenas a partir de um sinal (de um ponto) não houver problema . (e depois, não deve estar presente no código (linha acima)))
Estou a ver - é provavelmente por isso que ainda não encontrei tal solução na Internet. Mas, na minha opinião, deve haver uma solução para este problema.
Obrigado - Vou procurar uma solução para este problema.....
Sou autodidacta e não serei capaz de vos explicar isto - apenas escolhi as funções de que preciso, sei que isto vai para lá e aquilo vai para lá.
Basicamente todas as funções que copio dos códigos de Vladimir Karputov, pelos quais lhe agradeço muito! - Ele dir-lhe-á se tiver alguma dúvida.
É autodidacta, e eu acabo de começar a programar, e a minha cabeça está cheia de perguntas.
Tenho o algoritmo para esta EA na minha cabeça e não há problema se tiver de alterar o indicador no processo, porque só há duas tarefas (apontar para cima e apontar para baixo).
A herança envolve a criação de uma classe.
Então estou a escrever -- de que classe devo herdar a minha classe para usar estes métodos da sua biblioteca padrão?
aqui está outra opção - assim que o take for accionado - abrirá novamente na mesma direcção
Exactamente certo, com lucro!!!
À primeira vista - tudo está correcto.
E o facto de que não deve haver Stop Loss - tudo correcto também.
Mas não entendo o que acontece ao oder, que não é fechado em Take Profit....... quando a direcção do preço muda....(apenas fecha por defeito, ou seja, sobre o sinal do indicador de mudança de tendência)? Se assim for, não é essa a minha intenção.
E de acordo com a minha ideia - a ordem deve permanecer, mas aqui deve entrar em vigor - um martin com as suas configurações:
Ou seja, estabelecer ordens na direcção oposta à tendência com o aumento do lote e a obtenção de lucros médios. Em suma, trabalho como um simples Martin, por exemplo (Autoprofit 3), que é código aberto na web, mas escrito em mql4.
A propósito, a variante original do trabalho de tendências, que escreveu correctamente, não foi cancelada quando trabalhou com Martin.
Em suma, o trabalho de tendências é uma tarefa, que demonstrou brilhantemente em parte, e a segunda tarefa é um martin.
Não é necessário que estas duas tarefas estejam interligadas - na minha opinião, elas podem trabalhar de forma completamente independente
Absolutamente certo, com lucros!!!
À primeira vista - tudo está correcto.
E o facto de que o Stop Loss - também não deveria estar lá - tudo correcto.
Mas não percebi onde o oder, que não fechou em Take Profit....... quando a direcção do preço mudou....(apenas fecha por defeito, ou seja, sobre o sinal do indicador de mudança de tendência)? Se assim for, não é essa a minha intenção.
Mas de acordo com a minha ideia, a ordem deve permanecer, mas um martin com as suas configurações deve entrar em vigor aqui:
O mesmo é verdade para o outro lado, ou seja, estabelecer ordens na direcção oposta à tendência com o aumento do tamanho do lote e a obtenção de lucros médios. Em suma, trabalhar como um simples Martin - por exemplo (Autoprofit 3), que é código aberto na web, mas escrito em mql4.Uma observação ao mesmo tempo: não "ordem", mas "posição".
Uma observação ao mesmo tempo: não "ordem" mas "posição".
todas as opções que consegui encontrar - parece não haver mais
todas as opções que consegui encontrar - parece não haver mais
Já escrevi acima:
Estas duas tarefas não têm de estar interligadas - na minha opinião, podem funcionar de forma completamente independente.
Um algoritmo tal que proponho (na minha opinião) ainda não foi utilizado pelos programadores. Em qualquer caso, não encontrei tal solução - na Internet.
isto provavelmente não é possível de implementar
não dá - no símbolo, deve haver uma posição (se for fechada com lucro e reaberta uma posição) (e quando é aplicado o sinal oposto - não pode abrir na outra direcção
se apenas a partir de um sinal (de um ponto) não houver problema . (e isto não deve estar presente no código (linha acima)))
isto provavelmente não é possível de implementar
não dá - no símbolo, deve haver uma posição (se for fechada com lucro e reaberta uma posição) (e quando é aplicado o sinal oposto - não pode abrir na outra direcção
se apenas a partir de um sinal (de um ponto) não houver problema . (e depois, não deve estar presente no código (linha acima)))
Após actualizar para a versão 2981, um erro começou a aparecer na linha