Fragen von Anfängern MQL5 MT5 MetaTrader 5

Sprut 185 2021.06.27 16:32 #13181

SanAlex:

Ich bin Autodidakt und werde es Ihnen nicht erklären können - ich habe einfach die Funktionen ausgewählt, die ich brauche, und weiß, dass dies dorthin gehört und das dorthin gehört.

Im Grunde genommen habe ich alle Funktionen aus den Codes von Vladimir Karputov kopiert, wofür ich ihm sehr danke! - Er wird Ihnen sagen, wenn Sie Fragen haben.

Sie sind Autodidakt, und ich habe gerade erst mit dem Programmieren begonnen, und mein Kopf ist voll von Fragen.

Ich habe den Algorithmus für diesen EA im Kopf und es ist kein Problem, wenn ich dabei den Indikator ändern muss, denn es gibt nur zwei Aufgaben (Richtungspunkt - oben und Richtungspunkt - unten).

Im Moment gehe ich von dem Klassiker aus, dass das Einfachste das Beste ist. Deshalb möchte ich...... so weit wie möglich vereinfachen und gleichzeitig das Beste aus dem herausholen, was ich schaffen möchte. Ich schlage vor, gemeinsam an meinem Algorithmus zu arbeiten - ich denke, das wäre für uns beide interessant.

Wenn Sie Interesse haben, nehmen Sie bitte persönlich Kontakt mit mir auf.

Steigende Umsätze auf dem [WARNUNG GESCHLOSSEN!] Alle Fragen [ARCHIV]Alle Fragen von Anfängern,

Kira27 2021.06.27 16:57 #13182

Vladimir Karputov:

Bei der Vererbung wird eine Klasse erstellt.

Also ich schreibe -- von welcher Klasse sollte ich meine Klasse erben, um diese Methoden aus ihrer Standardbibliothek zu verwenden?

Sprut 185 2021.06.27 17:56 #13183

SanAlex:

hier ist eine weitere Option - sobald der Take ausgelöst wird, öffnet er sich wieder in dieselbe Richtung

Genau richtig, mit Gewinn !!!

Auf den ersten Blick ist alles richtig.

Auch die Tatsache, dass es keinen Stop-Loss geben sollte, ist richtig.

Aber ich verstehe nicht, was mit dem Auftrag passiert, der nicht bei Take Profit....... geschlossen wird, wenn sich die Richtung des Preises ändert....(er schließt einfach standardmäßig, d.h. auf das Signal des Trendwechselindikators)? Wenn ja, dann ist das nicht meine Absicht.

Und nach meiner Vorstellung - der Auftrag soll bestehen bleiben, aber hier soll er zum Tragen kommen - eine Schwalbe mit ihren Einstellungen:

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

D.h. Sie setzen Aufträge in die dem Trend entgegengesetzte Richtung mit steigendem Lot und durchschnittlichem Take Profit. Kurz gesagt, arbeiten wie eine einfache Martin, zum Beispiel (Autoprofit 3), die Open-Source auf dem Web ist, aber in mql4 geschrieben.

Übrigens, die ursprüngliche Variante der Trendarbeit, die Sie richtig geschrieben haben, ist bei der Arbeit mit Martin nicht aufgehoben worden.

Kurz gesagt, die Trendarbeit ist eine Aufgabe, die Sie teilweise und brillant demonstriert haben, und die andere Aufgabe ist ein Martin.

Es ist nicht notwendig, dass diese beiden Aufgaben miteinander verknüpft sind - meiner Meinung nach können sie völlig unabhängig voneinander durchgeführt werden

Fragen von Anfängern MQL4 [Archiv!] Jede Anfängerfrage, um Wer sind die Begrüßer?

Vladimir Karputov 2021.06.27 18:31 #13184

Sprut 185:

Völlig richtig, mit Gewinn!!!

Auf den ersten Blick ist alles richtig.

Und die Tatsache, dass der Stop-Loss auch nicht dort sein sollte - alles richtig.

Aber ich habe nicht verstanden, wo der Auftrag, die nicht in der Nähe Take Profit......., wenn die Richtung der Preisänderungen....(er schließt einfach standardmäßig, d.h. auf das Signal des Trendwechselindikators)? Wenn ja, dann ist das nicht meine Absicht.

Aber nach meiner Vorstellung sollte der Auftrag erhalten bleiben, aber ein Martin mit seinen Einstellungen sollte hier zum Tragen kommen:

Das Gleiche gilt für die andere Seite, d.h. das Setzen von Aufträgen in die entgegengesetzte Richtung des Trends mit steigender Losgröße und durchschnittlichem Take Profit. Kurz gesagt, arbeiten wie eine einfache Martin - zum Beispiel (Autoprofit 3), die Open-Source auf dem Web ist, aber in mql4 geschrieben.

Eine Bemerkung gleich vorweg: nicht "Reihenfolge", sondern "Position".

Sprut 185 2021.06.27 18:38 #13185

Vladimir Karputov:

Eine Bemerkung gleich vorweg: nicht "Ordnung", sondern "Position".

Ich entschuldige mich für den Fehler.

Ich werde dies berücksichtigen und versuchen, mich in Zukunft zu korrigieren.

SanAlex 2021.06.28 00:09 #13186

Sprut 185:

alle Optionen, die ich finden konnte - es scheint keine weiteren zu geben

//+------------------------------------------------------------------+
//|                                                  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);
  }
//+------------------------------------------------------------------+

Sprut 185 2021.06.28 08:28 #13187

SanAlex:

alle Optionen, die ich finden konnte - es scheint keine weiteren zu geben

Was passiert, wenn Sie versuchen, 2 unabhängige Blöcke in Ihrem Expert Advisor zu verwenden? Dann wird man auf seine eigene Arbeit, wie Sie bereits auf der Arbeit - Trend (mit einem Indikator)..........

Und der zweite durch das Signal, das durch den ersten Block gesetzt wurde - durch die Position - nicht durch den Trend........

Ich habe bereits oben geschrieben:

Diese beiden Aufgaben müssen nicht miteinander verknüpft sein - sie können meiner Meinung nach auch völlig unabhängig voneinander durchgeführt werden.

Ein solcher Algorithmus, den ich vorschlage, ist (meiner Meinung nach) noch nicht von Programmierern verwendet worden. Auf jeden Fall habe ich eine solche Lösung nicht gefunden - im Internet.

[Archiv] Lernen Sie, wie Woran erkenne ich, dass Muster in der Freiberuflichkeit:

SanAlex 2021.06.28 08:51 #13188

Sprut 185: Dieser Algorithmus, den ich vorschlage, ist (meiner Meinung nach) noch nicht von Programmierern verwendet worden. Jedenfalls habe ich eine solche Lösung im Internet nicht gefunden.

dies ist wahrscheinlich nicht möglich, zu implementieren

es gibt nicht - auf dem Symbol muss es eine Position geben (wenn es auf einem Gewinn geschlossen und eine Position wieder geöffnet wird) (und wenn das entgegengesetzte Signal angewendet wird - es kann nicht in die andere Richtung öffnen

   if(m_position.Select(Symbol()))

wenn nur von einem Signal (von einem Punkt) gibt es kein Problem. (und dies sollte im Code (Zeile oben) nicht vorhanden sein))

[WARNUNG GESCHLOSSEN!] Alle Fragen Signale : Fragen Sie Fehler, Irrtümer, Fragen

Sprut 185 2021.06.28 08:57 #13189

SanAlex:

dies ist wahrscheinlich nicht möglich, zu implementieren

es gibt nicht - auf dem Symbol muss es eine Position geben (wenn es auf einem Gewinn geschlossen und eine Position wieder geöffnet wird) (und wenn das entgegengesetzte Signal angewendet wird - es kann nicht in die andere Richtung öffnen

wenn nur von einem Signal (von einem Punkt) gibt es kein Problem. (und dann sollte es im Code (Zeile oben) nicht vorhanden sein))

Verstehe - das ist wahrscheinlich der Grund, warum ich eine solche Lösung nicht im Internet gefunden habe. Meiner Meinung nach muss es jedoch eine Lösung für dieses Problem geben.

Danke - ich werde nach einer Lösung für dieses Problem suchen.....

Dann lassen Sie uns erst einmal eine Pause einlegen.

Liga der Handelssysteme. Machen Die Funktion StrToTime verursacht Gibt es Händler, die

pivomoe 2021.06.28 09:25 #13190

Nach dem Upgrade auf Version 2981 erschien ein Fehler in der Zeile

MqlTradeRequest request = {0}

cannot convert 0 to enum 'ENUM_TRADE_REQUEST_ACTIONS'   OrderaiPosicii.mqh      11      34

Bitte teilen Sie mir mit, wie ich diese Leitung ersetzen kann.

Fragen von Anfängern MQL5 MT5 MetaTrader 5 - Seite 1319