Domande dai principianti MQL5 MT5 MetaTrader 5 - pagina 1319

Nuovo commento
 
SanAlex:

Sono un autodidatta e non sono in grado di spiegarvelo - ho solo scelto le funzioni che mi servono, so che questo va lì e quello va lì.

Fondamentalmente tutte le funzioni le copio dai codici di Vladimir Karputov, per cui lo ringrazio molto! - Vi dirà se avete delle domande.

Tu sei un autodidatta e io ho appena iniziato a programmare e la mia testa è piena di domande.

Ho l'algoritmo di questo EA nella mia testa e non è un problema se devo cambiare l'indicatore nel processo, perché ci sono solo due compiti (punto di direzione - su e punto di direzione - giù).

Al momento, sto procedendo dal classico che il più semplice è il migliore. Ecco perché voglio semplificare...... al massimo e allo stesso tempo ottenere il massimo da ciò che voglio creare. Propongo di lavorare insieme sul mio algoritmo - penso che sarebbe interessante per entrambi.
Se siete interessati, contattatemi di persona.
 
Vladimir Karputov:

L'ereditarietà comporta la creazione di una classe.

Quindi sto scrivendo: da quale classe dovrei ereditare la mia classe per usare questi metodi dalla loro libreria standard?

 
SanAlex:

ecco un'altra opzione - una volta che la presa è attivata - si aprirà di nuovo nella stessa direzione

Esattamente giusto, con profitto!!!

A prima vista - tutto è corretto.

E il fatto che non ci dovrebbe essere alcuno Stop Loss - tutto corretto anche.

Ma non capisco cosa succede all'oder, che non è chiuso a Take Profit....... quando la direzione del prezzo cambia....(si chiude solo per default, cioè sul segnale dell'indicatore di cambiamento di tendenza)? Se è così, non è mia intenzione.

E secondo la mia idea - l'ordine dovrebbe rimanere, ma qui dovrebbe entrare in vigore - un martin con le sue impostazioni:

input group "======== МАРТИН ========"; 
input int      MMType        = 1;        // 1 - вкл. , 2 - выкл.
input double   Multiplikator = 1.667;    // множитель следующего лота
input double   Step          = 150.0;    // Расстояние между ордерами

Cioè impostare gli ordini nella direzione opposta al trend con lotto crescente e take profit medio. In breve, funziona come un semplice Martin, per esempio (Adviser Autoprofit 3), che è in open source nel web, ma scritto in mql4.

A proposito, la variante originale del lavoro di tendenza, che hai scritto correttamente, non è stata cancellata quando si lavora con Martin.

In breve, il lavoro di tendenza è un compito, che avete brillantemente dimostrato in parte, e il secondo compito è un martin.

Non è necessario che questi due compiti siano correlati - a mio parere, possono lavorare in modo completamente indipendente

 
Sprut 185:

Assolutamente giusto, con i profitti!!!

A prima vista - tutto è corretto.

E il fatto che lo Stop Loss - non dovrebbe essere nemmeno lì - tutto corretto.

Ma non ho capito dove l'oder, che non ha chiuso a Take Profit....... quando la direzione del prezzo cambia....(si chiude solo per default, cioè sul segnale dell'indicatore di cambiamento di tendenza)? Se è così, non è mia intenzione.

Ma secondo la mia idea, l'ordine dovrebbe rimanere, ma qui dovrebbe entrare in vigore un martin con le sue impostazioni:

Lo stesso vale per l'altro lato, cioè impostando gli ordini nella direzione opposta al trend con l'aumento della dimensione del lotto e la media del take profit. In breve, funziona come un semplice Martin - per esempio (Autoprofit 3), che è open source sul web, ma scritto in mql4.

Un'osservazione subito: non "ordine", ma "posizione".

 
Vladimir Karputov:

Un'osservazione subito: non "ordine", ma "posizione".

Mi scuso per l'errore.
Ne terrò conto e cercherò di correggermi in futuro.
 
Sprut 185:

tutte le opzioni che ho potuto trovare - non sembrano esserci più

4 Sprut 185

//+------------------------------------------------------------------+
//|                                                  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
//---
input double InpLots          =0.1;   // Lots
input int    InpTakeProfit    =50;    // Take Profit (in pips)
input bool   InpVariant       =false; // Option
input int    InpBar           =1;     // Bar
input bool   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 handle
int    ExtTimeOut=10; // time out in seconds between trade operations
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- 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 digits
   int 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                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick(void)
  {
   static datetime limit_time=0; // last trade processing time + timeout
//--- don't process if timeout
   if(TimeCurrent()>=limit_time)
     {
      //--- check for data
      if(Bars(Symbol(),Period())>2)
        {
         //--- change limit time by timeout in seconds if processed
         if(!InpVariant && Processing())
            limit_time=TimeCurrent()+ExtTimeOut;
         //--- change limit time by timeout in seconds if processed
         if(InpVariant && Processing_1())
            limit_time=TimeCurrent()+ExtTimeOut;
        }
     }
  }
//+------------------------------------------------------------------+
//| main function returns true if any position processed             |
//+------------------------------------------------------------------+
bool Processing(void)
  {
//--- refresh rates
   if(!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 position
      if(LongClosed())
         return(true);
      //--- try to close or modify short position
      if(ShortClosed())
         return(true);
     }
   else
     {
      //--- check for long position (BUY) possibility
      if(LongOpened())
         return(true);
      //--- check for short position (SELL) possibility
      if(ShortOpened())
         return(true);
     }
//--- exit without position processing
   return(false);
  }
//+------------------------------------------------------------------+
//| main function returns true if any position processed             |
//+------------------------------------------------------------------+
bool Processing_1(void)
  {
//--- refresh rates
   if(!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 Signal
   if(StNRUp)
     {
      if(InpClOp)
         if(ShortClosed())
            Sleep(1000);
      if(price_uno<0)
         LongOpened();
      price_uno=+1;
      return(true);
     }
//--- SELL Signal
   if(StNRDn)
     {
      if(InpClOp)
         if(LongClosed())
            Sleep(1000);
      if(price_uno>0)
         ShortOpened();
      price_uno=-1;
      return(true);
     }
//--- exit without position processing
   return(false);
  }
//+------------------------------------------------------------------+
//| Check for long position closing                                  |
//+------------------------------------------------------------------+
bool LongClosed(void)
  {
   bool res=false;
//--- should it be closed?
   if(m_macd_current>m_signal_current)
     {
      //--- close position
      if(InpClOp)
         ClosePositions(POSITION_TYPE_BUY);
      //--- processed and cannot be modified
      res=true;
     }
//--- result
   return(res);
  }
//+------------------------------------------------------------------+
//| Check for short position closing                                 |
//+------------------------------------------------------------------+
bool ShortClosed(void)
  {
   bool res=false;
//--- should it be closed?
   if(m_macd_current<m_signal_current)
     {
      //--- close position
      if(InpClOp)
         ClosePositions(POSITION_TYPE_SELL);
      //--- processed and cannot be modified
      res=true;
     }
//--- result
   return(res);
  }
//+------------------------------------------------------------------+
//| Check for long position opening                                  |
//+------------------------------------------------------------------+
bool LongOpened(void)
  {
   bool res=false;
//--- check for long position (BUY) possibility
   if(m_macd_current<m_signal_current)
     {
      double price=m_symbol.Ask();
      double tp   =m_symbol.Bid()+m_take_profit;
      //--- check for free money
      if(m_account.FreeMarginCheck(Symbol(),ORDER_TYPE_BUY,InpLots,price)<0.0)
         printf("We have no money. Free Margin = %f",m_account.FreeMargin());
      else
        {
         //--- open position
         if(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;
     }
//--- result
   return(res);
  }
//+------------------------------------------------------------------+
//| Check for short position opening                                 |
//+------------------------------------------------------------------+
bool ShortOpened(void)
  {
   bool res=false;
//--- check for short position (SELL) possibility
   if(m_macd_current>m_signal_current)
     {
      double price=m_symbol.Bid();
      double tp   =m_symbol.Ask()-m_take_profit;
      //--- check for free money
      if(m_account.FreeMarginCheck(Symbol(),ORDER_TYPE_SELL,InpLots,price)<0.0)
         printf("We have no money. Free Margin = %f",m_account.FreeMargin());
      else
        {
         //--- open position
         if(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;
     }
//--- result
   return(res);
  }
//+------------------------------------------------------------------+
//| Refreshes the symbol quotes data                                 |
//+------------------------------------------------------------------+
bool RefreshRates()
  {
//--- refresh rates
   if(!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 levels
   double coeff=(double)1;
   if(!RefreshRates() || !m_symbol.Refresh())
      return;
//--- FreezeLevel -> for pending order and modification
   double 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 StopLoss
   double 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(const ENUM_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 positions
      if(m_position.SelectByIndex(i)) // selects the position by index for further access to its properties
         if(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_symbol
                        Print(__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_symbol
                        Print(__FILE__," ",__FUNCTION__,", ERROR: ","SELL PositionClose ",m_position.Ticket(),", ",m_trade.ResultRetcodeDescription());
                 }
               PlaySound("ok.wav");
              }
  }
//+------------------------------------------------------------------+
//| Filling the indicator buffers from the indicator                 |
//+------------------------------------------------------------------+
bool iGetArray(const int handle,const int buffer,const int start_pos,
               const int count,double &arr_buffer[])
  {
   bool result=true;
   if(!ArrayIsDynamic(arr_buffer))
     {
      return(false);
     }
   ArrayFree(arr_buffer);
//--- reset error code
   ResetLastError();
//--- fill a part of the iBands array with values from the indicator buffer
   int copied=CopyBuffer(handle,buffer,start_pos,count,arr_buffer);
   if(copied!=count)
     {
      return(false);
     }
   return(result);
  }
//+------------------------------------------------------------------+
 
SanAlex:

tutte le opzioni che ho potuto trovare - non sembrano esserci più


Cosa succede se cerchi di usare 2 blocchi indipendenti nel tuo Expert Advisor. Poi uno funzionerà da solo, come hai già lavorato sul - trend (usando un indicatore)..........
E il secondo dal segnale impostato dal primo blocco - per posizione - non per tendenza........


Ho già scritto sopra:

Questi due compiti non devono essere interconnessi - secondo me, possono lavorare in modo completamente indipendente.

Un tale algoritmo che propongo (secondo me) non è ancora stato utilizzato dai programmatori. In ogni caso, non ho trovato una tale soluzione - su Internet.

 
Sprut 185:  Questo algoritmo che propongo - (secondo me) non è stato ancora utilizzato dai programmatori. In ogni caso, non ho trovato una tale soluzione su Internet.

questo probabilmente non è possibile da implementare

non dà - sul simbolo, ci deve essere una posizione (se è chiuso su un profitto e riaperto una posizione) (e quando il segnale opposto è applicato - non può aprire nell'altra direzione

   if(m_position.Select(Symbol()))

se solo da un segnale (da un punto) non c'è problema. (e questo non dovrebbe essere presente nel codice (linea sopra))

 
SanAlex:

questo probabilmente non è possibile da implementare

non dà - sul simbolo, ci deve essere una posizione (se è chiuso su un profitto e riaperto una posizione) (e quando il segnale opposto è applicato - non può aprire nell'altra direzione

se solo da un segnale (da un punto) non c'è problema. (e poi, non dovrebbe essere presente nel codice (linea sopra))

Capisco - probabilmente è per questo che non ho trovato una soluzione simile su Internet. Ma secondo me, ci deve essere una soluzione a questo problema.
Grazie - cercherò una soluzione a questo problema.....
Allora fermiamoci per ora.
 

Dopo l'aggiornamento alla versione 2981, un errore ha iniziato ad apparire nella linea

MqlTradeRequest request = {0}
cannot convert 0 to enum 'ENUM_TRADE_REQUEST_ACTIONS'   OrderaiPosicii.mqh      11      34
Per favore, consigliate come sostituire questa linea.
1...131213131314131513161317131813191320132113221323132413251326...1504
Nuovo commento